JP2013084023A - Specification creation support device and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a specification creation support device which can provide rigorous requirement description, which is not evident in creating a conventional natural language specification, for creating a formal language specification.SOLUTION: A specification creation support device comprises: a formal specification storage DB; a formal verification execution unit comprising a series of processing concerning a formal verification technique; a requirement interpolation rule for generating missing requirement candidates required for describing a specification by formal verification, from requirements described in a specification; and a requirement interpolation unit for generating missing requirements from the requirement interpolation rule. The requirement interpolation rule is composed of missing requirement derivation requirements describing a requirement pattern in a specification which can be a candidate for the missing requirements and missing requirements describing a requirement pattern of missing requirements generated from the missing request derivation requirements. The requirement interpolation unit searches for the requirement interpolation rule corresponding to the requirement pattern in the missing requirement derivation requirements in the requirement interpolation rule storage DB, from requirements in the specification, and if there is corresponding requirement interpolation rule, generates missing requirements from the missing requirements corresponding to the requirement interpolation rule.

Description

  The present invention relates to technology for supporting software development, and more particularly to technology for creating, verifying, and correcting software specifications.

  When creating software specifications, it is important to improve the design quality by describing specifications without ambiguity and errors, and to reduce the return in software development. For this reason, a formal verification technique is known in which a specification is created using a description language capable of strict specification description and a specification without ambiguity or error is created by verifying the specification. Hereinafter, the specification created by the formal verification technique is referred to as a formal language specification.

  Also, support tools for creating and verifying specifications for formal language specifications are known. For example, in “Event-B” which is one of model normative description languages, “Rodin Platform” (Non-patent Document 1) is known as a specification creation support tool. In order to create formal language specifications using these specification creation support tools, specification descriptions (natural language specifications) expressed in diagrams and natural language are re-expressed in formal language specifications, and specifications are verified and corrected. Need to do. Therefore, in order to create specifications without ambiguity and errors using formal language specifications, it is necessary to be familiar with formal verification technology.

  Therefore, a design document creation support method is known for assisting designers who are not familiar with formal verification technology to create specifications without ambiguity or errors. For example, in Patent Document 1, by defining a conversion rule from a natural language specification to a formal language specification in advance and assisting designers in creating specifications, it is possible to reduce ambiguity and errors without directly writing formal language specifications. A design document creation support method is disclosed.

JP2008-158853

Event-B. org, “Event-B and Rodin Platform” [Online], [searched July 11, 2011], Internet <URL: http: // www. event-b. org />

  The purpose of the conventional technology is to support the creation of a design document having no ambiguity or error based on the formal verification technology using the natural language by defining a conversion rule from the natural language specification to the formal language specification.

  However, when creating a formal language specification, it is necessary to create a more strict specification description as compared with the conventional specification creation using a natural language. Therefore, it is necessary to explicitly describe requirements that were not recognized in the conventional natural language specifications. Therefore, it is an object of the present invention to support the creation of specifications without ambiguity and errors by generating missing requirements from the requirements described in the specifications when creating specifications using formal verification technology.

  In response to the above-described problems, the present invention inputs, for each requirement, each of the expression format in the natural language of the requirement, the expression format in the formal language of the requirement, and input information required for the expression format in the natural language. A deficiency requirement derivation having a description conversion rule having an input reference source indicating a reference source in an information specification, a deficiency requirement derivation requirement format described in a natural language, and a deficiency requirement derivation requirement format described in a formal language A requirement interpolation rule having a requirement format and a deficient requirement format described in a natural language, and outputs one or more natural language expression format candidates based on the description conversion rule, and the one or more natural languages Before receiving the selection of one or more natural language expression formats from the expression format candidates by the prior language expression receiving means based on the description conversion rule An input reference source corresponding to each of one or more natural language representation formats is output as a candidate of input information required for the one or more natural language representation formats, and the one or more natural language representations from the input information candidates One selection of input information for each format is received, and one or more requirements expressed in the natural language are generated from the selected expression format in the one or more natural languages and the input information, and the one expressed in the natural language Create a natural language specification with the above requirements, and for each requirement included in the natural language specification, the shortage described in the natural language corresponding to the expression format in the natural language used to generate the requirement The requirement derivation requirement format is searched for whether it is registered in the requirement interpolation rule, and is associated with the extracted requirement requirement format described in the extracted natural language. Apply the input information used to create the requirement to the deficient requirement derivation requirement format described in the formal language to generate the deficient requirement derivation information, and describe it in the extracted natural language based on the requirement interpolation rule. The shortage requirement format is extracted from the shortage requirement derivation requirement format, and the shortage requirement format described in the natural language is generated by applying the shortage requirement derivation information to the shortage requirement format. Is added to the natural language specification, the natural language specification is converted into a formal language specification based on the description conversion rules, a formal language specification is generated, and the formal language specification is verified. It is characterized by doing.

  In creating software specifications using formal verification technology, strict specification creation is supported, and specification creation without ambiguity and errors can be supported.

It is an example of the block diagram which shows the structure of the specification creation assistance apparatus in a 1st Example. It is a figure which shows an example of the hardware constitutions of a specification creation assistance apparatus. It is a figure which shows an example of the correspondence of the natural language specification and formal language specification in a 1st Example. It is a figure which shows the outline | summary of the creation process of the natural language specification in a 1st Example. It is a figure which shows an example of the description / conversion rule table | surface of a natural language and a formal language in a 1st Example. It is a figure which shows an example of a structure of the requirement interpolation rule in a 1st Example. It is a figure which shows an example of the flow which produces a natural language specification based on the description / conversion rule in a 1st Example. It is a figure which shows an example of the processing flow for converting from a natural language to a formal language based on the description / conversion rule in a 1st Example. It is a figure which shows an example of the processing flow for producing | generating a short requirement based on the requirement interpolation rule in a 1st Example. It is a figure which shows an example of the specification preparation by the natural language specification preparation part in a 1st Example. It is a figure which shows an example of the natural language specification stored in the natural language specification storage DB in a 1st Example. It is a figure which shows an example of the result of having corrected the natural language specification based on the requirement interpolation rule in a 1st Example. It is a figure which shows an example of a formal language specification. It is an example of the block diagram which shows the minimum structure of the specification creation assistance apparatus in a 2nd Example. It is a figure which shows an example of a structure of the requirement interpolation rule in a 2nd Example.

  FIG. 1 is a configuration diagram of a specification creation support apparatus 100 according to the present embodiment. The specification creation support apparatus 100 includes an input unit 101, a display unit 106, an input / output control unit 107, a natural language specification creation unit 102, a model conversion unit 103, a format specification creation unit 104, a format verification execution unit 105, and a requirement interpolation rule. Storage database (requirement interpolation rule storage DB 120), natural language specification storage database (natural language specification storage DB 121), description / conversion rule storage database (description / conversion rule storage DB 122), and format specification storage database (format specification storage) DB123). The natural language specification creation unit includes a design document creation unit 108, a requirement interpolation unit 109, and a requirement description unit 110.

  Here, the natural language specification storage DB 121 is a storage area for storing natural language specifications, and the formal specification storage DB 113 is a storage area for storing formal language specifications. The description / conversion rule storage DB 112 is a storage area for storing a description rule for creating a natural language specification and a conversion rule for mutually converting the created natural language specification and formal language specification. The rule storage DB 110 is a storage area that stores rules for complementing the missing requirements in the created natural language specification.

  The format verification execution unit 105 performs syntax check and verification of the formal language based on the formal language specification stored in the formal specification storage DB 123. In addition, the model conversion unit 103 converts the natural language specification stored in the natural language specification storage DB 121 into a formal specification language or reverse conversion thereof according to the conversion rule of the description / conversion rule storage DB 122, and performs formal verification. The verification result in the execution unit 105 is reflected in the natural language specification storage DB 121.

  The natural language specification creation unit 102 includes a design document creation unit 108, a requirement interpolation unit 109, and a requirement description unit 110. The design document creation unit 108 is a processing unit for creating a design document based on a natural language specification. The design document creation unit 108 communicates with the requirement description unit 110, and from the input unit 101 in accordance with the description / conversion rule. Accepts user input, performs requirement description in natural language, and creates specifications. Furthermore, the design document creation unit 108 communicates with the requirement interpolation unit 109 to generate a missing requirement from the created requirement.

  The formal language specification creation unit 104 is a processing unit for directly creating a formal language specification, and the formal specification creation unit 104, the formal specification storage DB 123, and the formal verification execution unit 105 are specification descriptions related to the formal verification technology. In addition, a specification creation support tool (for example, Non-Patent Document 1) of an existing formal verification technology that performs syntax check and verification may be used.

  According to the present embodiment, the user creates a natural language specification based on the description rule stored in the description / conversion rule stored in the description / conversion rule storage DB 122 in the specification creation support apparatus 100, so that the formal language Convert to specification. Further, by using the requirement interpolation rule stored in the requirement interpolation rule storage DB 120, a deficient requirement is generated from the requirement described in the natural language specification. As a result, the user is supported for creating specifications without ambiguity and errors using formal language specifications.

  FIG. 2 shows an example of a hardware configuration for realizing the specification creation support apparatus 100 shown in FIG.

  In the configuration example of FIG. 2, the specification creation support apparatus 100 includes a CPU (Central Processor Unit) 201, a RAM (Random Access Memory) 202, an input device 101, a display device 204, and an external storage device 210 via an interface 205. It is a connected computer (electronic computer) having a general configuration.

  The input device 101 is, for example, a keyboard or a mouse, the display device 204 is a display for display, and the external storage device 210 is an HDD (Hard Disk Drive) or the like. The CPU 201 implements the natural language specification creation unit 102, the model conversion unit 103, the formal language specification creation unit 104, and the formal verification execution unit 105 shown in FIG. 1 as processes by executing a program loaded on the RAM 202. To do. The interface 205 is an internal path for transmitting and receiving data between each component in the apparatus, and the external storage device 210 includes each database (requirement interpolation rule storage DB 120 and the like), a natural language specification creation unit 102, The execution programs of the model conversion unit 103, the formal language specification creation unit 104, and the formal verification execution unit 105 are stored. The display device 203 causes the natural language specification creation unit 102 and the formal language specification creation unit 104 to display the natural language specification or formal language specification being created on a display or the like.

  Hereinafter, in this embodiment, the design document support apparatus 100 will be described by taking as an example the case where the model normative specification description language “Event-B” is used as the formal language specification. In the following, a specific configuration of the specification creation support apparatus 100 will be described by taking “Event-B” as an example. However, the present invention similarly applies to other model normative specification description languages such as “B-method”. It is feasible.

  FIG. 3 shows a correspondence relationship between the natural language specification 301 and the formal language specification 320 in the present embodiment when Event-B is used. In the formal language “Event-B”, the formal language specification includes a Context 321 and a MACHINE 323. The Context 321 includes a set 331 for creating a formal language specification (called an abstract machine in Event-B), information 332 regarding constants, a MACHINE 323 includes a variable 333 representing a system state, and , An invariant condition 334 indicating a condition to be satisfied by the variable, an initialization 339 of the variable, a precondition 337 of the state change of the variable, and an event 335 describing a post condition (action) 338.

  As shown in FIG. 3, in the first embodiment, the natural language specification 301 corresponding to the formal language specification 320 includes modeling information 302 including a set list 305, constant list 306, variable list 307, and data requirement list 308. It consists of data requirement related information 303 and use case design document 304. Here, the use case design document 304 includes a use case name 309, a use case summary 310, a parameter 311, a precondition 312, and an action 313 for each use case. Note that the arrows in FIG. 3 represent the corresponding components in the formal language specification 320 in which the modeling information 302, the data requirement related information 303, and the use case design document 304 are present.

  The configuration and names of the design document shown in FIG. 3 are not limited to the above. Further, the unit for creating the design document is not limited to the above. For example, the modeling information 302 and the data requirement related information 303 may be collected as one design document. The description content of the design document may include items other than the above.

FIG. 4 shows an outline of a specification creation flow based on the natural language specification shown in FIG. The flow is as follows.
401: Start 402: The input unit 101 receives an input based on the description / conversion rule 112 from the user, and the design document creation unit 108 and the requirement description unit 111 of the natural language creation unit 102 create modeling information 302.
403: The input unit 101 receives an input based on the description / conversion rule 112 from the user, and the design document creation unit 108 and the requirement description unit 111 of the natural language creation unit 102 create the data requirement relation 303.
404: The input unit 101 receives an input based on the description / conversion rule 112 from the user, and the design document creation unit 108 and the requirement description unit 111 of the natural language creation unit 102 create a use case design document 304.
405: If all use case design documents have been created, go to step 406. If there is still a use case design document to be created, the process proceeds to step 404.
406: The design document creation unit 108 and the requirement interpolation unit 112 of the natural language creation unit 102 generate deficient requirements from the requirements in the specifications created based on the requirement interpolation rules 120, and reflect them in the design document.
407: The user calls the model conversion unit 103 from the natural language specification creation unit 102, and uses the model conversion unit 103 to convert the natural language specification 302 created by the natural language creation unit 102 into the formal language specification 320.
408: The specification creation support apparatus 100 uses the formal verification execution unit to perform syntax check and verification of the formal language specification 320 generated in step 407, and reflects the result in the natural language specification 320.
409: If all the requirements (certification duties) have been successfully verified, the process proceeds to step 411. If there is a requirement that has failed verification, the process proceeds to 410.
410: The user performs the same work as steps 402, 403, and 404 using the natural language specification creating unit 102 to correct the natural language specification.
411: End In the above creation flow, after all use case design documents have been created, after step 406, requirement interpolation (step 406), conversion to formal language specifications (step 407), formal language specifications However, the present invention is not limited to the above. For example, the processing of steps 406, 407, and 408 may be executed for each design document creation stage (steps 402, 403, and 404). Further, the design document creation unit 108 may automatically call the processing in accordance with the user's requirement description instead of explicitly calling the processing in steps 406, 407, 408, and the like.

  The specification correction in step 410 is performed directly on the formal language specification 320 using the formal language specification creating unit 104 instead of the natural language specification creating unit 102, and the result is converted into the natural language using the model conversion unit 103. It may be reflected in the language specification 301.

  In the above processing, the processing flow assumes that all formal language specifications are created from natural language specifications, but may be different from the above. For example, if there is an item that is commonly used in an existing system or a plurality of systems, a part of the modeling information 302 or the data requirement related information 303 is created in advance, and specifications are made using these. You may make it.

  FIG. 5 shows an example of the description / conversion rules stored in the description / conversion rule DB 122 in this embodiment. As shown in FIG. 5, the description / conversion rule DB 122 in this embodiment includes a conversion ID 501 that represents an identifier of a description / conversion rule, a natural language expression 503 that represents a requirement description pattern in a natural language specification, and a natural language expression. It includes a formal language expression 504 representing a requirement description pattern in the corresponding formal language specification. In addition, each description / conversion rule includes a variable 502, an invariant condition, etc., an object 502 that can use the description / conversion rule, and input information necessary for generating a requirement instance using each description / conversion rule 505 is included.

  In the reference sources 506 and 508 of the input information 505 of this embodiment, and the shortage requirement derivation requirement 602 and the shortage requirement 605 targets 606, 608, and 610 shown in FIG. S (Set) for reference, C (Constant) for reference to the constant list 306, V (Variables) for reference to the variable list 307, I (Invariants) for reference to the data requirement list 308, When referring to the event parameter 311, P (Parameter), when referring to the precondition 312, W (Where), when referring to the action 313, it is abbreviated as A (Action). The reference sources 506 and 508 of the input information 505 include S, C, V, and P in order to select from the set list 305, constant list 306, variable list 307, and parameter 311 declared for specification description. Either. Similarly, types 507 and 509 are abbreviated as E (Element) when the type of input information is element, and S (Set) when set as a set. Note that types other than the above may be added, for example, mapping as well as elements and sets. Further, for example, classes and attributes may be collected from different viewpoints.

  Next, FIG. 6 shows an example of the description / conversion rule stored in the requirement interpolation rule DB 120 in this embodiment. As shown in FIG. 6, the requirement interpolation rule DB 120 includes an interpolation ID 601 that represents the identifier of the requirement interpolation rule, a shortage requirement 605 that describes the description pattern of the shortage requirement, and a condition for generating the shortage requirement (requirement description in the specification). A deficient requirement derivation requirement 602 describing a pattern). The deficient requirement derivation requirement 602 further includes a base requirement 603 and a dependent requirement 604. Note that the base requirement 603 and the subordinate requirement 604 may be combined as one column as the deficient requirement derivation requirement 602. However, in this embodiment, in order to easily derive the deficient requirement (deficient requirement 605), the base requirement It is divided into two columns 603 and subordinate requirements 604. This is to reduce the trouble of searching for all the deficient requirement derivation requirements collectively when the deficient requirement is generated from the specification using the deficient requirement derivation requirement 602. In generating a deficient requirement, first, a deficient requirement candidate is searched based on the base requirement 603, and the subordinate requirement 604 is narrowed down from the requirement description in the specification to the relevant candidate. Identification and generation.

  The following is a processing flow of requirement description processing by the requirement description unit 110, conversion processing to formal language specifications by the model conversion unit 103, and generation processing of deficient requirements by the requirement interpolation unit 109 using FIG. 5 and FIG. Will be described. A specific example will be described later with reference to FIGS.

FIG. 7 shows an outline of a processing flow of requirement description in each design document in this embodiment (processing flow in the requirement description unit 110, processing in steps 402 to 404 in FIG. 4).
701: Start 702: The requirement description unit 110 reads a description / conversion rule corresponding to a description item from the description / conversion rule DB 122 based on the target 502, and displays a list of the read description / conversion rules.
703: The input unit 101 receives the description / conversion rule selected by the user from the displayed description / conversion rule list and sends it to the requirement description unit 110.
704: The requirement description unit 110 reads the corresponding input information 505 from the received description / conversion rule.
705: If there is still input information, go to Step 705;
706: The requirement description unit 110 acquires reference source information from the input information 505.
707: The requirement description unit 110 acquires input information candidates (input candidates) according to the descriptions of the reference sources 506 and 508.
708: The requirement description unit 110 acquires the types 507 and 509, and acquires only the corresponding input candidates from the input candidates in Step 707.
709: A list of the input candidates acquired in step 708 is displayed.
710: The input unit 101 sends the input candidate selection selected by the user from the displayed list of input candidates to the acceptance requirement description unit 110, and the process proceeds to step 705.
711: The requirement description unit 110 stores the conversion ID 501 of the description / conversion rule and the input candidate (referred to as input information instance) acquired in Step 710 as a requirement instance in the natural language specification storage DB 121.
712: End In the example shown in FIG. 3, the natural language specification 301 is composed of a plurality of design documents (modeling information 302, data requirement related information 303, use case design document 304), and description items ( A data requirement list 308 or the like corresponds to each component of the formal language specification (such as the invariant 334).

  The above processing is a processing flow for individually creating requirements described in each description item of the natural language specification 301. For example, when the data requirement list 308 is described, the column of the target 502 is “data”. When a description / conversion rule with “requirement” is displayed in a list and an action 313 is described, a description / conversion rule with the target 502 as “action” is displayed in a list and a variable 307 is described. Displays a list of description / conversion rules whose target 502 is “variable” (step 702).

  The user selection is accepted (step 703), and the selected description / conversion rule is acquired. For example, when the user selects a description / conversion rule whose conversion ID 501 is T11 in FIG. 5, input information “A” includes “B”. Processing for generating an instance (steps 705 to 710) is executed.

  In step 706 and step 707, reference source information and type information regarding the input information A of T11 are referred to, and input candidates of the input information A are acquired. Specifically, since the reference information regarding the input information A of T11 is “V (variable list)”, input candidates are acquired from the variable list 307. Since the type related to the input information A is “E (element)”, in step 708, a variable declared as an element is acquired from the acquired input candidate. The acquired variables are displayed as a list of input candidates for the input information A, and user selection of the input information A is accepted (steps 709 and 710). Similar processing (steps 705 to 710) is performed on the input information B, and a user selection of the input information B is accepted. Then, an input information instance is created from the input information A and the input information B selected by the user, and a requirement instance is generated from the conversion ID 501 and the input information instance. The generated requirement instance is stored in the natural language specification storage DB 121 by the design document creation unit 108 (step 121).

  In the above processing flow, a method of selecting an input information instance from input candidates has been shown. However, a set list 305, a constant list 306, a variable list 307, and a parameter 310 are sets, constants, and variables used in the system. Alternatively, since it is an item for defining parameters used in the use case, text input from the user is accepted instead of accepting input candidates. For example, the description / conversion rule whose conversion ID 501 is T01 and T02 shown in FIG. 5 is a description / conversion template to a variable. At this time, the natural language expression 503 does not have the information of the input information A like the “element B” of T01. Regarding the input information 505 A, “−” is described in the reference source 506 and the type 507. For the input information A, this means that a free input by text from the user is accepted and a variable is declared using the result.

  Further, the natural language expression “A includes B” in T11 is the same as the natural language expression in T12. In this case, instead of explicitly nominating T11 and T12, the user obtains a description / conversion rule candidate from the natural language expression, and converts the subsequent input information instance based on the input information instance selected by the user. The ID may be specified. By doing so, the user can describe the specification in the natural language expression without being aware of the formal language expression. In the description / conversion template shown in FIG. 5, the description / conversion rule based on the text expression is described as the natural language expression. For example, a UML class diagram or the like may be used as the natural language expression.

  Next, a process for generating the formal language specification 320 from the natural language specification 301 configured by the requirement instance created by the process of FIG. 7 (the process of step 407 in FIG. 4) will be described.

  As shown in FIG. 3, each description item such as the data requirement list 308 in the natural language specification 301 corresponds to each component in the formal language specification 320. In the conversion from the natural language specification 301 to the formal language specification 320 by the model conversion unit 103, first, the formal language corresponding to each description item of each created design document (modeling information, data requirement related information, use case design document) is created. A formal language specification 320 is generated by generating each component of the specification and converting a requirement instance described in each description item into a formal language expression.

FIG. 8 shows a processing flow in the model conversion unit 103 for converting the requirement instance stored in each of the above described items into a formal language expression.
801: Start 802: The model conversion unit 103 acquires a requirement instance from the natural language specification storage DB 121.
803: The model conversion unit 103 acquires a conversion ID from the requirement instance acquired in step 802.
804: If there is still an input information instance in the requirement instance acquired in step 802, the process proceeds to step 805. Otherwise, the process proceeds to step 806.
805: The model conversion unit 103 acquires an input information instance in the requirement instance.
806: The model conversion unit 103 acquires a description / conversion rule having a conversion ID 501 that matches the conversion ID acquired in step 803 from the description / conversion rule DB 122.
807: The model conversion unit 103 substitutes the input information instance acquired in step 805 for the formal language expression 504 of the description / conversion rule having the conversion ID 501 acquired in step 806.
808: End As described in the processing flow of the requirement instance in FIG. 7, each requirement instance is composed of a conversion ID and an input information instance. Further, since the corresponding formal language expression 504 is determined from the conversion ID 501 by the configuration of the description / conversion rule shown in FIG. 5, if an entity value (input information instance) of the input information is given, conversion to the formal language expression is possible. Is possible. Therefore, conversion of each requirement instance into a description in the formal language specification is obtained by obtaining the conversion ID in step 803, obtaining the input information instance in step 805, and obtaining the formal language expression in step 806 (step 806). 807) becomes possible. The natural language specification 301 is converted into the formal language specification 320 by executing the above conversion processing for all requirement instances.

FIG. 9 shows a processing flow for generating a deficient requirement using the requirement interpolation rule storage DB 120 by the requirement interpolation unit 109 (processing of step 406 in FIG. 4).
901: Start 902: The requirement interpolation unit 109 acquires a requirement instance from the natural language specification storage DB 121.
903: The requirement interpolation unit 109 searches for the requirement interpolation rule in the requirement interpolation rule DB 120, and if there is a requirement interpolation rule for the base requirement 603 having a conversion ID that matches the requirement instance acquired in step 902, the flow goes to step 904. If YES in step 905, the flow advances to step 905.
904: The requirement interpolation unit 109 creates an instance of the base requirement 603 from the requirement instance acquired in step 902 and the conversion ID acquired in step 903.
905: The requirement interpolation unit 109 acquires the dependent requirement 604 of the requirement interpolation rule acquired in step 903.
906: The requirement interpolation unit 109 searches for a requirement instance in the natural language specification storage DB 121 for each of the dependent requirements acquired in step 905 for a requirement instance having a conversion ID that matches the conversion ID of the dependent requirement. . If there is a requirement instance with the same conversion ID for all subordinate requirements, the process proceeds to step 907; otherwise, the process proceeds to step 910.
907: The requirement interpolation unit 109 attempts to generate an instance of the dependent requirement 604 using the instance of the base requirement 603 for the requirement instance acquired in step 906, and if it can be generated, go to step 908. If YES, go to step 910.
908: The requirement interpolation unit 109 acquires the requirement interpolation rule deficiency requirement 505 acquired in step 903.
909: The requirement interpolation unit 109 generates a deficiency requirement using the acquired deficiency requirement 605.
910: End With respect to the requirement instance acquired in step 902, in step 903, the requirement requirement rule 603 whose conversion ID matches the requirement instance is searched from the requirement interpolation rule DB 120. When the conversion ID described in the requirement of the base requirement 603 matches the conversion ID of the requirement instance, the input information instance of the requirement instance is substituted into X, XX, Y,. An instance is created (step 904). Here, X means a subset of XX, and Y means a subset of YY. Next, a dependent requirement 604 corresponding to the base requirement 603 is obtained (step 905), a requirement instance that matches the target 608 of the dependent requirement 604 is extracted, and the extracted requirement instance is described in the dependent requirement 604. The presence / absence of a requirement instance having a conversion ID that matches the conversion ID is searched (step 906). If there is a requirement instance for all the dependent requirements 604, an attempt is made to generate an instance of the dependent requirement (step 907). At this time, if X, XX,... Are in the base requirement, the same input information instance as the base requirement is used. If not, the input information instance acquired in step 906 is used.

  When the above-described processing has generated the requirement instances of the dependent requirement for all the requirements in the dependent requirement 604, the instance of the insufficient requirement described in the insufficient requirement 605 is generated, and the shortage requirement 605 in the design document is generated. Generate missing requirements at the location specified in the target. In addition, when “single quotation” is added to the shortage requirement like A ′, it represents that the input information is newly generated.

  The deficiency requirement generated as described above may be automatically reflected in the design document by the design document creation unit 108, or may be displayed as a deficiency requirement candidate and checked for reflection to the user. Good. Further, as described above, when the automatic reflection to the design document is performed, the direct reflection to the design document is not performed (not displayed on the design document), and the natural language specification storage DB 121 is set as a non-display requirement. And converted into formal language specifications in the model conversion unit 103. By doing so, it is possible to assist the user who is not familiar with the formal language specifications without being aware of redundant expressions unique to formal verification, and to make the design document easier to read.

  If there is not one deficient requirement generated by the above process, for example, list the deficient requirements as candidates and accept the input from the user so that the deficient requirements are reflected in the corresponding part of each design document. That's fine. In addition, when a plurality of deficient requirements are displayed, a priority column is separately provided in advance in the requirement interpolation rule DB 120, and deficient requirements are displayed in order from the highest priority according to the priority column. Good.

  Hereinafter, the processes of FIGS. 7, 8, and 9 will be described with reference to FIGS.

  FIG. 10 shows an example of a design document created by this embodiment. The data requirement related information 1000 in FIG. 10 is an example of the data requirement related information 303 in FIG. 3, and a variable list 1001 and a data requirement list 1002 are described using the description / conversion rule DB 122. The use case design document 1010 in FIG. 10 is an example of the use case design document 304 in FIG. 3, and the use case name 1011 and the parameter 1013 are described using the description / conversion rule DB 122 as in the data requirement related information 1000. A precondition 1014 and an action 1015 are described. Furthermore, the use case summary 1012 is a column for explaining the summary of the use case, and is a free description column that does not need to be converted into a formal language specification.

  The verification result column 1020 in FIG. 10 is converted into the formal language specification 320, and the model verification unit 103 performs the specification verification (generation of certification obligations and verification thereof) by the formal verification execution unit 105. It is a column to display. In the case of FIG. 10, it means that the result of the specification verification does not satisfy the requirement that “all registered forms are allocated to the form folder”.

  FIG. 11 is an example in which the data requirement related information 1000 of FIG. 10 and the data representation in the natural language specification storage DB 121 of the use case design document 1010 are partially represented. As shown in FIG. 11, the natural language specification storage DB 121 does not need to store the design document shown in FIG. 10 as it is. In the example of FIG. 11, the natural language specification storage DB 121 includes information on each design document using a conversion ID and an input information instance using XML (extensible Markup Language).

  The data requirement related information 1000 in FIG. 10 is described as XML data composed of the data requirement related information element 1101 in FIG. 11 including a variable list element 1103 representing a variable list and a data requirement list element 1104 representing a data requirement list. The The use case design document 1010 includes a use case name element 1105, a parameter element 1107, a precondition element 1108, and an action element 1109 as XML data including the use case design document element 1102. Note that the supplementary information element 1106 is a field for describing information that does not need to be converted into formal language specifications. FIG. 11 shows summary elements (corresponding to the summary 1012 and the use case summary 310) for explaining the summary of the use case. Including.

  In the example of FIG. 11, each requirement element (1120 to 1124) represents each requirement instance, and a conversion ID (requirement element ID attribute) and an input information instance (requirement element A, B,... Child elements) Consists of. By storing the conversion ID and the input information instance in the natural language specification storage DB 121, each requirement instance can be converted into a formal language expression by the processing flow shown in FIG. Further, by using the table shown in FIG. 5 from the conversion ID and the input information instance, the natural language specification shown in FIG. 10 can be restored from the information in the natural language specification storage DB 121 of FIG. .

  For example, the requirement element 1124 stores “id = T44” as an attribute, and “new form” and “registered form” are stored in the child elements A and B, respectively. From FIG. 5, the natural language expression whose conversion ID is “T44” is “add A to B”, and the natural language expression of the requirement instance is “register new form” from the input information instances of the child elements A and B. It can be seen that “Add to completed form”. Similarly, since the formal language expression is “B: = B∪ {A}”, it is understood that “registered form: = registered form ∪ {new form}” (the conversion result will be described later). (See act 4 of requirement 4 1311 in FIG. 13).

  In the example of FIGS. 10 and 11, each design document is created based on the description / conversion rule and stored in the natural language specification storage DB 121. In creating the design document shown in FIG. 10, requirements not included in the description / conversion rule may be described. In this case, for example, it is desirable that the corresponding formal language expression can be input together so that the formal language expression corresponding to the natural language expression can be understood.

  Further, in the natural language specification 320 of FIG. 11, a special conversion ID (for example, T9999 or the like) representing the free description is determined in advance for the natural language expression and the formal language expression input for the free description, By defining elements for describing natural language expressions and formal language expressions as child elements, natural language expressions and formal language expressions by free description may be stored.

  Note that a requirement that does not necessarily need to be converted into a formal language expression (for example, supplementary information) with respect to a freely described requirement does not need to include the formal language expression as a child element.

  When displaying the natural language specification 301 in FIG. 10, for example, the description / conversion rule storage DB 122 is used to pop up the converted formal language expression so that the correspondence with the formal language expression of each requirement can be understood (free description). In this case, an element for describing a formal language expression may be used). Further, when there is no corresponding formal language expression, it may be clearly indicated that there is no corresponding formal language expression, for example, by changing a character or a background color.

  In FIG. 11, data representation by XML is used as an implementation example of the natural language specification 301, but it may be different from this. Even when XML is used, the element names and the XML structure are not necessarily limited to those shown in FIG.

  FIG. 12 shows the result of interpolating the deficient requirements from the natural language specifications shown in FIG. 10 and FIG. 11 based on the deficient requirement generation process using the requirement interpolation rule storage DB 120 shown in FIG. 6 and FIG. Represents. The requirements 1 and 2 in FIG. 12 represent the shortage requirements added. The generation of requirement 1 is generated as follows according to the processing flow of FIG. First, by the processing in step 902, a requirement instance is acquired for the requirement “all registered forms are assigned to a form folder” in the data requirement list. As shown in the requirement element 1121 in FIG. 11, this requirement instance has a requirement id (conversion ID) of T13. Next, by the process of step 903, the requirement interpolation rule of the interpolation ID “A11” whose conversion ID is T13 is acquired, and “X” based on the input information instance (A = registered form, B = form folder) of the requirement instance. By substituting “= registered form” and “Y = form folder”, an instance of the base requirement 603 is generated (step 904). Further, in step 905, a requirement is acquired from the corresponding dependent requirement 604, and a requirement instance whose conversion ID is T01 is acquired by the processing in steps 906 and 907. In this case, as indicated by the variable list element 1120 in FIG. 11, the input information instances of the acquired requirement instances are “registered form (a subset of the entire form)” and “form folder (a subset of the entire folder)”. Therefore, in the dependent requirement 604, “X = registered form, XX = whole form”, Y = form folder “YY = whole folder”, and an instance of the dependent requirement 604 can be generated. From the above processing, in step 908 and step 909, the instance “registered form-to-form folder (relation from registered form to form folder)” of the deficiency requirement “T02: relationship from B to C” of the corresponding deficiency requirement ” Is generated. The generated requirement is added to the corresponding “variable list” of the design document corresponding to the target field (requirement 1 1201).

  Similarly, the requirement 2 described in the action in the use case design document 1010, “Add new form to registered form (conversion ID: T44)” “Add registration destination folder to form folder. (Conversion ID: T44) ”is selected as the base requirement whose interpolation ID is“ A23 ”(Steps 901 to 904), and the requirement 2 1202 is obtained through the subordinate requirement search and instance generation (Steps 905 to 907). Is generated (step 908 to step 910).

  FIG. 13 is an example showing a result of generating formal language specifications (specification description by Event-B) from the design document shown in FIG. Each design document created by the user using the design document creation unit 108 is stored in the natural language storage DB 121. The model conversion unit 103 converts each requirement into a formal language specification based on the description / conversion rule according to the processing flow shown in FIG. 8 (in this embodiment, each requirement instance is converted to a conversion ID as described above. And the information of the input information instance are included, and the information can be converted into a formal language expression). Further, the model conversion unit 103 describes each requirement converted into the formal language expression in the corresponding part according to the syntax rules of the formal language (Event-B in this example). As a result, a formal language specification corresponding to the natural language specification created by the user is created. FIG. 13 shows examples of formal language specifications generated based on the description / conversion rules and requirement interpolation rules shown in FIGS. 5 and 6, and different description / conversion rules and requirement interpolation rules. When is used, a formal language specification as shown in FIG. 13 is not always generated.

  It is desirable that the description / conversion rules stored in the description / conversion rule storage DB 122 can be converted into formal language specifications without error and that appropriate description / conversion rules are stored in accordance with the properties to be verified in the design document. . Further, the requirement interpolation rule stored in the requirement interpolation rule storage DB 120 is a shortage requirement or a shortage requirement candidate for creating a specification having no error when converted into a formal language specification according to the description / conversion rule. It is desirable to store appropriate information so that is generated.

  In the first embodiment, the user creates a design document according to natural language specifications using a description / conversion rule prepared in advance. In addition, a shortage requirement is generated for the generated design document, and the generated design document is converted into a formal language specification. In this way, we have described a method to help users who are not familiar with formal verification technology to create design documents without ambiguity and errors based on formal verification technology. In the second embodiment, a method for deriving deficient requirements on formal language specifications will be described. As a result, even for users who can create specifications in the formal language, description support is provided for requirements that are often forgotten in the process of formal language specification creation and additional requirements that are subordinately derived. This provides support when creating formal language specifications directly.

  FIG. 14 is a diagram illustrating a minimum configuration of the design document creation support apparatus 100 according to the second embodiment. In the second embodiment, unlike the first embodiment, a shortage requirement is generated on the formal language specification. Therefore, the processing units (natural language specification creation unit 102, model conversion unit 103) and storage areas (natural language specification storage DB 121, description / conversion rule storage DB 122) related to creation of the natural language specifications may be omitted. However, the configuration of the first embodiment may be included in the configuration of FIG. In this case, since the interpolation of the deficient requirement is performed according to the formal language specification, the requirement interpolation unit 109 and the requirement interpolation rule storage DB 120 in FIG. 1 are not necessary.

  In the second embodiment, the formal language specification creation unit 104 includes a formal specification description unit 104a and a requirement interpolation unit 112a in order to generate a shortage requirement on the formal language specification. Here, the formal language specification description unit 104a is a processing unit for directly creating a specification in the formal language, and creation support software for the formal language (for example, Non-Patent Document 1) may be used. As described above, the requirement interpolation unit 112a in the second embodiment generates deficient requirements from the formal language specifications created by the user based on the requirement interpolation rules stored in the requirement interpolation rule storage DB 120a.

  FIG. 15 is an example showing a configuration in the requirement interpolation rule storage DB 120a in the second embodiment. As shown in FIG. 15, the requirement interpolation rule storage DB 120a includes an interpolation ID 601a, a base condition 603a, a precondition 604a, and a subordinate condition 605a, as in the configuration of the first embodiment (FIG. 6). However, the requirement interpolation rule storage DB 120a in the second embodiment is different from the first embodiment (FIG. 6) in that the requirement interpolation rules stored in the base requirement 603a, the dependent requirement 604a, and the shortage requirement 605a are formal languages. The expression is described directly. In the first embodiment, the natural language specification is converted into the formal language specification, and the shortage requirement is generated in the natural language specification. In the second embodiment, the natural language specification is converted into the formal language specification. This is because direct deficiency requirement interpolation is performed, so that conversion from natural language expression to formal language expression is not necessary.

  The deficiency requirement generation process can be generated in the same manner as the deficiency requirement generation process (FIG. 9) in the first embodiment. However, the following points are different between the first embodiment and the second embodiment. As described above, in the first embodiment, the shortage requirement is generated based on the conversion process from the natural language expression to the formal language expression. For this reason, in the first embodiment, by using the conversion ID of the description / conversion rule, a base requirement and a subordinate requirement are searched from the natural language specification, and based on the result, a shortage requirement is generated based on the description / conversion rule. (The shortage requirement to be generated is expressed by the conversion ID and the input information instance).

  On the other hand, in the second embodiment, since the shortage requirement is generated in the formal language specification, the base requirement 603a, the dependent requirement 604a, and the shortage requirement 605a are included in the formal language expression in the requirement interpolation rule storage DB 120a. Directly described. Therefore, for example, in the search for the requirement instance by the conversion ID in step 903 and step 906, a match or mismatch between the requirements described in the formal expression is searched. In addition, for the generation of instances such as base requirements and dependent requirements, instances in the formal language expression are directly generated.

  In the formal language specification shown in FIG. 13, when the requirements 3 and 4 are created by the user, the processing flow of FIG. 9 and the requirement interpolation rule storage DB 120a of FIG. Similar to requirement 2 1202 (FIG. 12), requirement 5 is generated as follows. First, the requirement interpolation unit 112a selects a basic requirement whose interpolation ID 601a is “A23” from the requirement 4 1311 and the basic requirement 603a in the action (steps 902 to 903), “XX = registered form”, “X = Base requirement instances are generated as “new form”, “YY = form folder”, and “Y = registration destination folder” (step 904). Next, a corresponding dependent requirement is obtained (step 905), requirement 3 1310 exists as a requirement corresponding to the dependent requirement (step 906), and a corresponding instance of the dependent requirement is generated from the base requirement instance (step 906). Step 907). Then, the requirement interpolation rule for the corresponding deficient requirement is acquired (step 908), and as the deficient requirement instance, “Registered form to form folder: = Registered form to form folder registered form ∪ {New form |-> Form” Folder} "is generated (step 910).

  As described above, in the second embodiment, the direct requirement interpolation is performed on the formal language specification. Therefore, in the configuration diagram of FIG. 14, the processing unit (natural language specification creating unit 102) related to the creation of the natural language specification. , The model conversion unit 103) and the storage area (natural language specification storage DB 121, description / conversion rule storage DB 122) are not included, but may be configured to include these.

  In this case, the shortage requirement generated based on the second embodiment or each requirement created by the formal specification description unit 104a is based on the conversion ID, and the formal language expression in the description / conversion rule storage DB 122. The input information instance may be identified and converted into a corresponding natural language expression.

  When a plurality of formal language expressions correspond to the description / conversion rule storage DB 122, priorities are set in advance in the description / conversion rule DB 122, and natural language expressions are determined based on the priorities. Alternatively, a plurality of corresponding natural language expressions (based on priority) may be displayed in a list and determined by user selection. Further, when there is no corresponding formal language expression in the description / conversion rule storage DB 122, the natural language expression corresponding to the user may be directly described.

  In the implementation method of the embodiment, the specification creation support apparatus 100 creates a basic part of a design document for a user who is not familiar with formal verification, and verification by formal verification is performed by a formal verification specialist. Useful when using.

100 specification creation support apparatus 101 input unit 102 natural language specification creation unit 103 model conversion unit 104 formal language specification creation unit 105 format verification execution unit 106 display unit 107 input / output control unit 108 design document creation unit 109 requirement interpolation unit 110 requirement description unit 120 Requirement interpolation rule storage database 121 Natural language specification storage database 122 Description / conversion rule storage database 123 Format specification storage database 200 Electronic computer 201 CPU
202 RAM
203 Display Device 204 Input Device 205 Interface 210 External Storage Device

Claims (10)

A specification creation support device that converts a natural language into a formal language to create a specification,
For each requirement, an input indicating the reference source in the specification of the input information for each requirement information in the natural language expression format, the requirement formal language representation format, and the input information required for the natural language representation format A description conversion rule having a reference source;
A requirement interpolation rule having a deficiency requirement derivation requirement format having a deficiency requirement derivation requirement format described in a natural language and a deficiency requirement derivation requirement format described in a formal language; and a deficiency requirement format described in a natural language; ,
A natural language format output means for outputting one or more natural language expression format candidates based on the description conversion rule;
Natural language expression receiving means for receiving selection of one or more natural language expression formats from the one or more natural language expression format candidates;
Based on the description conversion rule, input information candidates required for the one or more natural language expression formats as input reference sources corresponding to the one or more natural language expression formats received by the prior language expression reception unit Input information candidate output means for outputting as:
Input information receiving means for receiving selection of input information for each of the expression formats in the one or more natural languages from the input information candidates;
From the selected expression format in the one or more natural languages and the input information, one or more requirements expressed in the natural language are generated, and the specification of the natural language having the one or more requirements expressed in the natural language A natural language specification creation means for creating
For each requirement included in the natural language specification,
A deficiency requirement derivation requirement format search means for searching whether the deficiency requirement derivation requirement format described in the natural language corresponding to the natural language expression format used to generate the requirement is registered in the requirement interpolation rule;
Input used to create the requirement in the requirement requirement derivation requirement format described in the formal language associated with the requirement requirement derivation requirement format described in the natural language extracted by the lack requirement requirement derivation format search means A deficiency requirement derivation information generating means for applying information and generating deficiency requirement derivation information;
Based on the requirement interpolation rule, a shortage requirement format for the shortage requirement derivation requirement format described in the natural language extracted by the shortage requirement derivation requirement format search means is extracted, and the shortage requirement derivation information is added to the shortage requirement format. Deficiency requirement generating means for applying and generating deficiency requirements written in natural language;
A deficiency requirement appending means for adding the deficiency requirement described in the natural language to the natural language specification;
Language conversion means for converting the natural language specification into a formal language specification based on the description conversion rules and generating a formal language specification;
Specification verification means for verifying the specification of the formal language;
A specification creation support apparatus characterized by comprising: A specification creation support apparatus according to claim 1,
The deficiency requirement derivation requirement format of the requirement interpolation rule includes a deficiency requirement derivation requirement format described in a first natural language, a deficiency requirement derivation requirement format described in a first formal language, and a second natural language. And the deficiency requirement derivation requirement format described in the second formal language,
The deficient requirement derivation requirement format search means includes:
For each requirement included in the natural language specification,
Search whether the shortage requirement derivation requirement format described in the first natural language corresponding to the natural language representation format used to generate the requirement is registered in the requirement interpolation rule,
The deficient requirement derivation information generating means includes:
The shortage requirement derivation requirement format described in the first formal language associated with the shortage requirement derivation requirement format described in the first natural language extracted by the shortage requirement derivation requirement format search means, Apply the input information used to create the requirement to generate the first deficient requirement derivation information,
The deficient requirement derivation requirement format search means includes:
The deficiency requirement derivation requirement described in the second natural language corresponding to the deficiency requirement derivation requirement format described in the first natural language extracted by the deficiency requirement derivation requirement format search means based on the requirement interpolation rule. Extract the format, and search whether the requirement corresponding to the deficient requirement derivation requirement format described in the second natural language exists in the specification in the natural language,
The deficient requirement derivation information generating means includes:
When the requirement corresponding to the deficient requirement derivation requirement format described in the second natural language exists in the specification in the natural language, the deficiency requirement derivation requirement format described in the second natural language and the first Generate second deficiency requirement derivation information from one deficiency requirement derivation information,
The deficient requirement generating means is
Based on the requirement interpolation rule, the deficient requirement format described in the natural language corresponding to the deficient requirement derived requirement format described in the first natural language and the deficient requirement derived requirement format described in the second natural language And generating the deficiency requirements described in the natural language by applying the first deficiency requirement derivation information and the second deficiency requirement derivation information to the deficiency requirement format described in the natural language. A specification creation support device. A specification creation support apparatus according to claim 2,
Further, when the specification verification unit fails to verify the formal language specification,
A specification correction means for accepting correction of the natural language specification or the formal language specification;
In the case where correction of the natural language specification is accepted by the specification correction means, the specification creation support device,
A specification creation support apparatus that generates, for each requirement included in a revised natural language specification, a shortage requirement written in the natural language and adds the requirement to the revised natural language specification. A specification creation support apparatus according to claim 3,
The description conversion rule further includes a conversion identifier for uniquely identifying the requirement for each requirement,
Each of the shortage requirement derivation requirement format of the requirement interpolation rule further includes a conversion identifier of a requirement corresponding to the shortage requirement derivation requirement format,
The deficient requirement derivation requirement form search means, for each requirement described in the natural language specification,
A specification creation support apparatus that searches whether a requirement requirement derivation requirement format having the same conversion identifier as the requirement conversion identifier is registered in the requirement interpolation rule. A specification creation support device that generates a specification in a formal language,
A requirement interpolation rule having a first deficiency requirement derivation requirement format described in a formal language, a second deficiency requirement derivation requirement format described in a formal language, and a deficiency requirement format described in a formal language;
For each requirement listed in the specification in the formal language,
A first deficiency requirement derivation requirement format search means for searching whether a first deficiency requirement derivation requirement format corresponding to the requirement format is registered in the requirement interpolation rule;
First deficiency requirement derivation for generating first deficiency requirement derivation information by applying input information constituting the requirement to the first deficiency requirement derivation requirement format extracted by the first deficiency requirement derivation requirement format search means Information generating means;
Based on the requirement interpolation rule, a second deficiency requirement derivation requirement format corresponding to the first deficiency requirement derivation requirement format extracted by the first deficiency requirement derivation requirement format search means is extracted, and the second deficiency requirement format is extracted. A second deficient requirement derivation requirement format retrieval means for retrieving whether a requirement corresponding to the requirement derivation requirement format exists in the specification in the formal language;
Second deficiency requirement derivation for generating second deficiency requirement derivation information by applying the first deficiency requirement derivation information to the second deficiency requirement derivation requirement format extracted by the second deficiency requirement derivation requirement search means Information generating means;
Based on the requirement interpolation rule, a shortage requirement format corresponding to the first shortage requirement derivation requirement format and the second shortage requirement derivation requirement format is extracted, and the shortage requirement format includes the first shortage requirement derivation information and Applying the second deficiency requirement derivation information, deficiency requirement generation means for generating deficiency requirements described in a formal language,
A deficient requirement appending means for appending the deficient requirement described in the formal language to the specification of the formal language;
Specification verification means for verifying the specification of the formal language;
A specification creation support apparatus characterized by comprising: A method in a specification creation support apparatus for creating a specification by converting from a natural language to a formal language,
The specification creation support device includes:
A natural language specification creation unit, a model conversion unit, a format verification execution unit,
For each requirement, an input indicating the reference source in the specification of the input information for each requirement information in the natural language expression format, the requirement formal language representation format, and the input information required for the natural language representation format A description conversion rule having a reference source;
A requirement interpolation rule having a deficiency requirement derivation requirement format having a deficiency requirement derivation requirement format described in a natural language and a deficiency requirement derivation requirement format described in a formal language; and a deficiency requirement format described in a natural language; ,
Have
The natural language specification creating unit
A natural language format output step for outputting one or more natural language expression format candidates based on the description conversion rules;
A natural language expression accepting step for accepting selection of one or more natural language expression formats from the one or more natural language expression format candidates;
Based on the description conversion rule, input information candidates required for the one or more natural language expression formats as input reference sources corresponding to the one or more natural language expression formats received by the prior language expression reception step Input information candidate output step to output as
An input information receiving step for receiving selection of input information for each of the expression formats in the one or more natural languages from the input information candidates;
From the selected expression format in the one or more natural languages and the input information, one or more requirements expressed in the natural language are generated, and the specification of the natural language having the one or more requirements expressed in the natural language Creating natural language specifications,
For each requirement included in the natural language specification,
A deficient requirement derivation requirement format search step for searching whether the deficiency requirement derivation requirement format described in the natural language corresponding to the natural language expression format used to generate the requirement is registered in the requirement interpolation rule;
Input used to create the requirement in the requirement requirement derivation requirement format described in the formal language associated with the requirement requirement derivation requirement format described in the natural language extracted by the lack requirement derivation requirement format search step A deficiency requirement derivation information generation step that applies information and generates deficiency requirement derivation information;
Based on the requirement interpolation rule, a shortage requirement format for the shortage requirement derivation requirement format described in the natural language extracted by the shortage requirement derivation requirement format search step is extracted, and the shortage requirement derivation information is added to the shortage requirement format. A deficiency generation step to apply and generate deficiency requirements written in natural language;
A deficient requirement adding step for adding deficient requirements written in the natural language to the natural language specification;
Have
The model converter is
A language conversion step of converting the natural language specification into a formal language specification based on the description conversion rule to generate a formal language specification;
The format verification execution unit
A specification verification step for verifying the specification in the formal language;
A method characterized by comprising: A method according to claim 6, comprising:
The deficiency requirement derivation requirement format of the requirement interpolation rule includes a deficiency requirement derivation requirement format described in a first natural language, a deficiency requirement derivation requirement format described in a first formal language, and a second natural language. And the deficiency requirement derivation requirement format described in the second formal language,
The deficient requirement derivation requirement format search step includes:
For each requirement included in the natural language specification,
Search whether the shortage requirement derivation requirement format described in the first natural language corresponding to the natural language representation format used to generate the requirement is registered in the requirement interpolation rule,
The deficient requirement derivation information generation step includes:
The deficiency requirement derivation requirement format described in the first formal language associated with the deficiency requirement derivation requirement format described in the first natural language extracted by the deficiency requirement derivation requirement format search step, Apply the input information used to create the requirement to generate the first deficient requirement derivation information,
The deficient requirement derivation requirement format search step includes:
The deficiency requirement derivation requirement described in the second natural language corresponding to the deficiency requirement derivation requirement format described in the first natural language extracted by the deficiency requirement derivation requirement format search step based on the requirement interpolation rule. Extract the format, and search whether the requirement corresponding to the deficient requirement derivation requirement format described in the second natural language exists in the specification in the natural language,
The deficient requirement derivation information generation step includes:
When the requirement corresponding to the deficient requirement derivation requirement format described in the second natural language exists in the specification in the natural language, the deficiency requirement derivation requirement format described in the second natural language and the first Generate second deficiency requirement derivation information from one deficiency requirement derivation information,
The deficient requirement generation step includes:
Based on the requirement interpolation rule, the deficient requirement format described in the natural language corresponding to the deficient requirement derived requirement format described in the first natural language and the deficient requirement derived requirement format described in the second natural language And generating the deficiency requirements described in the natural language by applying the first deficiency requirement derivation information and the second deficiency requirement derivation information to the deficiency requirement format described in the natural language. And how to. A method according to claim 7, comprising:
Further, when verification of the specification of the formal language in the specification verification step fails,
A specification correction step for accepting correction of the natural language specification or the formal language specification;
When the correction of the natural language specification is accepted by the specification correction step,
The method
A method comprising: generating, for each requirement included in the modified natural language specification, a shortage requirement described in the natural language and adding the requirement to the modified natural language specification. A method according to claim 8, comprising:
The description conversion rule further includes a conversion identifier for uniquely identifying the requirement for each requirement,
Each of the shortage requirement derivation requirement format of the requirement interpolation rule further includes a conversion identifier of a requirement corresponding to the shortage requirement derivation requirement format,
In the deficient requirement derivation requirement format search step, for each requirement described in the natural language specification,
A method of searching whether a deficient requirement derivation requirement format having the same conversion identifier as that of the requirement is registered in the requirement interpolation rule. A method in a specification creation support device for generating a specification in a formal language,
The specification creation support device includes:
A formal language specification creation unit, a formal verification execution unit,
A requirement interpolation rule having a first deficiency requirement derivation requirement format described in a formal language, a second deficiency requirement derivation requirement format described in a formal language, and a deficiency requirement format described in a formal language;
Have
The formal language specification creation unit
For each requirement listed in the specification in the formal language,
A first deficiency requirement derivation requirement format search step for searching whether or not a first deficiency requirement derivation requirement format corresponding to the requirement format is registered in the requirement interpolation rule;
First deficiency requirement derivation for generating first deficiency requirement derivation information by applying input information constituting the requirement to the first deficiency requirement derivation requirement format extracted by the first deficiency requirement derivation requirement format search step An information generation step;
Based on the requirement interpolation rule, a second deficiency requirement derivation requirement format corresponding to the first deficiency requirement derivation requirement format extracted by the first deficiency requirement derivation requirement format search step is extracted, and the second deficiency requirement format is extracted. A second deficient requirement derivation requirement format search step for searching whether a requirement corresponding to the requirement derivation requirement format exists in the specification in the formal language;
The second deficiency requirement derivation information is generated by applying the first deficiency requirement derivation information to the second deficiency requirement derivation requirement format extracted by the second deficiency requirement derivation requirement search step. An information generation step;
Based on the requirement interpolation rule, a shortage requirement format corresponding to the first shortage requirement derivation requirement format and the second shortage requirement derivation requirement format is extracted, and the shortage requirement format includes the first shortage requirement derivation information and Applying the second deficiency requirement derivation information to generate the deficiency requirement described in the formal language;
A deficient requirement adding step of adding deficient requirements described in the formal language to the formal language specification;
Have
The format verification execution unit
A specification verification step for verifying the specification in the formal language;
A method characterized by comprising:

Images