Skip to main content

KBRE: a framework for knowledge-based requirements engineering


Detecting inconsistencies is a critical part of requirements engineering (RE) and has been a topic of interest for several decades. Domain knowledge and semantics of requirements not only play important roles in elaborating requirements but are also a crucial way to detect conflicts among them. In this paper, we present a novel knowledge-based RE framework (KBRE) in which domain knowledge and semantics of requirements are central to elaboration, structuring, and management of captured requirements. Moreover, we also show how they facilitate the identification of requirements inconsistencies and other-related problems. In our KBRE model, description logic (DL) is used as the fundamental logical system for requirements analysis and reasoning. In addition, the application of DL in the form of Manchester OWL Syntax brings simplicity to the formalization of requirements while preserving sufficient expressive power. A tool has been developed and applied to an industrial use case to validate our approach.

This is a preview of subscription content, access via your institution.

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9


  1. In our model, expressions in Manchester Syntax can be translated into description logics automatically and vice versa.

  2. In description logics, roles represent binary relationships between classes.


  • Anton, A. (1996). Goal-based requirements analysis. In Proceedings of the second international conference on requirements engineering, pp. 136–144. IEEE.

  • Baader, F., Horrocks, I., & Sattler, U. (2007). Description logics. In van Harmelen, F., Lifschitz, V., Porter, B., editors, Handbook of knowledge representation. Amsterdam: Elsevier.

    Google Scholar 

  • Boehm, B., Bose, P., Horowitz, E., & Lee, M. (1995). Software requirements negotiation and renegotiation aids: A theory-W based spiral approach. In Proceeding of the 17th international conference on software engineering, on IEEE, pp. 243–243.

  • Boehm, B. & In, H. (1999). Conflict analysis and negotiation aids for cost-quality requirements. Software Quality Professional, 1(2), 38–50.

    Google Scholar 

  • Breaux, T., Antón, A., & Doyle, J. (2008). Semantic parameterization: A process for modeling domain descriptions. ACM Transactions on Software Engineering and Methodology (TOSEM), 18(2), 5.

    Google Scholar 

  • Brockmans, S., Volz, R., Eberhart, A., & Löffler, P. (2004). Visual modeling of owl dl ontologies using uml. The semantic web–ISWC 2004, pp. 198–213.

  • Chung, K. (1993). Representing and using non-functional requirements: A process-oriented approach. IEEE Transactions on Software Engineering, 18(6), 483–497.

    Google Scholar 

  • Clark & Parsia, LCC. (2012). Pellet—OWL 2 reasoner.

  • Corcho, O., & Gómez-Pérez, A. (2000). A roadmap to ontology specification languages. In Proceedings of the 12th European workshop on knowledge acquisition, modeling and management, EKAW ’00, London: Springer, pp. 80–96.

  • Cregan, A., Schwitter, R., & Meyer, T. (2007). Sydney OWL Syntax—towards a controlled natural language syntax for OWL 1.1. In Proceedings of the OWLED 2007 workshop on OWL: Experiences and directions. OWLED.

  • D’Aquin, M., & Noy, N. (2011). Where to publish and find ontologies? A survey of ontology libraries. Web Semantics: Science, Services and Agents on the World Wide Web.

  • Dardenne, A., Fickas, S., & van Lamsweerde, A. (1991). Goal-directed concept acquisition in requirements elicitation. In Proceedings of the 6th international workshop on software specification and design, IEEE Computer Society Press, pp. 14–21.

  • Dardenne, A., Van Lamsweerde, A., & Fickas, S. (1993). Goal-directed requirements acquisition. Science of Computer Programming, 20(1–2), 3–50.

    Article  MATH  Google Scholar 

  • DeMarco, T. (1979). Structured analysis and system specification. Upper Saddle River, NJ: Yourdon Press.

    Google Scholar 

  • Doe, R. (2009). The standish group chaos report.

  • Dwyer, M., Avrunin, G., & Corbett, J. (1999). Patterns in property specifications for finite-state verification. In Software engineering, 1999. proceedings of the 1999 international conference on IEEE, pp. 411–420.

  • Dwyer, M. B., Avrunin, G. S., & Corbett, J. C. (1998). Property specification patterns for finite-state verification. In Proceedings of the second workshop on formal methods in software practice, pp. 7–15.

  • Egyed, A., & Grunbacher, P. (2004). Identifying requirements conflicts and cooperation: How quality attributes and automated traceability can help. IEEE Software, 21(6), 50–58.

    Article  Google Scholar 

  • Fuchs, N., Höfler, S., Kaljurand, K., Rinaldi, F., & Schneider, G. (2005). Attempto controlled English: A knowledge representation language readable by humans and machines. Reasoning Web, pp. 95–95.

  • Fuxman, A., Liu, L., Mylopoulos, J., Pistore, M., Roveri, M., & Traverso, P. (2004). Specifying and analyzing early requirements in tropos. Requirements Engineering, 9(2), 132–150.

    Article  Google Scholar 

  • Goldin, L., & Berry, D. (1997). Abstfinder, a prototype natural language text abstraction finder for use in requirements elicitation. Automated Software Engineering, 4(4), 375–412.

    Article  Google Scholar 

  • Greenspan, S., Mylopoulos, J., & Borgida, A. (1994). On formal requirements modeling languages: Rml revisited. In Proceedings of the 16th international conference on software engineering on IEEE Computer Society Press, pp. 135–147.

  • Grundy, J., Hosking, J., & Mugridge, W. (1998). Inconsistency management for multiple-view software development environments. IEEE Transactions on Software Engineering, 24(11), 960–981.

    Article  Google Scholar 

  • Guarino, N., Oberle, D., & Staab, S. (2009). What is an ontology? Handbook on ontologies, pp. 1–17.

  • Henderson, P. (2006). Why large IT projects fail. ACM Transactions on Programming Languages and Systems, 15(5), 795–825.

    Google Scholar 

  • Horridge, M., Drummond, N., Goodwin, J., Rector, A., Stevens, R., & Wang, H. (2006). The Manchester OWL Syntax. OWL: Experiences and directions, pp. 10–11.

  • Horridge, M., & Patel-Schneider, P. F. (2009). OWL 2 web ontology language manchester Syntax. W3C Working Group Note, W3C.

  • Horrocks, I., Kutz, O., & Sattler, U. (2006). The even more irresistible SROIQ. In Proceedings of the 10th international conference on principles of knowledge representation and reasoning, pp. 57–67.

  • Jaramillo, C., Gelbukh, A., & Isaza, F. (2006). Pre-conceptual schema: A conceptual-graph-like knowledge representation for requirements elicitation. MICAI 2006: Advances in Artificial Intelligence, pp. 27–37.

  • Kaiya, H., & Saeki, M. (2005). Ontology based requirements analysis: Lightweight semantic processing approach. In Proceedings of the fifth international conference on quality software on IEEE, pp. 223–230.

  • Kaiya, H., Shimizu, Y., Yasui, H., Kaijiri, K., & Saeki, M. (2010). Enhancing domain knowledge for requirements elicitation with web mining. In Proceedings of the 17th Asia Pacific software engineering conference on IEEE, pp. 3–12.

  • Kalyanpur, A., Parsia, B., Sirin, E., Grau, B., & Hendler, J. (2006). Swoop: A ’Web’ Ontology Editing browser. Web Semantics: Science, Services and Agents on the World Wide Web, 4(2), 144–153.

    Article  Google Scholar 

  • Kamalrudin, M., Grundy, J., & Hosking, J. (2010). Managing consistency between textual requirements, abstract interactions and essential use cases. In Proceedings of the 34th annual IEEE computer software and applications conference on IEEE, pp. 327–336.

  • Kazakov, Y. (2008). Riq and sroiq shoiq.

  • Kenzi, K., Soffer, P., & Hadar, I. (2010). The role of domain knowledge in requirements elicitation: An exploratory study. In Proceedings of the 5th mediterranean conference on information systems. paper 48.

  • Krötzsch, M., Rudolph, S., & Hitzler, P. (2012). Complexities of horn description logics. ACM Transacton on Computer Logics To Appear.

  • Lauenroth, K., & Pohl, K. (2008). Dynamic consistency checking of domain requirements in product line engineering. In Proceedings of the 16th IEEE international conference on requirements engineering on IEEE, pp. 193–202.

  • Lee, J. (1991). Extending the potts and bruns model for recording design rationale. In Proceedings of the 13th international conference on software engineering on IEEE, pp. 114–125.

  • Maedche, A., & Staab, S. (2001). Ontology learning for the semantic web. Intelligent systems. IEEE, 16(2), 72–79.

    Google Scholar 

  • Mostow, J. (1985). Toward better models of the design process. AI Magazine, 6(1), 44.

    Google Scholar 

  • Mylopoulos, J., Borgida, A., Jarke, M., & Koubarakis, M. (1990). Telos: Representing knowledge about information systems. ACM Transactions on Information Systems (TOIS), 8(4), 325–362.

    Article  Google Scholar 

  • Noy, N., Crubézy, M., Fergerson, R., Knublauch, H., Tu, S., Vendetti, J., & Musen, M., et al. (2003). Protégé-2000: An open-source ontology-Development and Knowledge-Acquisition Environment. In Proceedings of the AMIA annual symposium, p. 953.

  • Noy, N., & McGuinness, D., et al. (2001). Ontology development 101: A guide to creating your first ontology.

  • O’Madadhain, J., Fisher, D., Smyth, P., White, S., & Boey, Y. (2005). Analysis and visualization of network data using JUNG. Journal of Statistical Software, 10(2), 1–25.

    Google Scholar 

  • Pratt-Hartmann, I. (2003). A two-variable fragment of English. Journal of Logic, Language and Information, 12(1), 13–45.

    Article  MATH  MathSciNet  Google Scholar 

  • Pressman, R. S. (2005). Software engineering: A practitioner’s approach, 6th edn. Maidenherd: McGraw Hill.

    Google Scholar 

  • Robinson, W., & Pawlowski, S. (1999). Managing requirements inconsistency with development goal monitors. IEEE Transactions on Software Engineering, 25(6), 816–835.

    Article  Google Scholar 

  • Ross, D. (1977). Structured Analysis (SA): A language for communicating ideas. IEEE Transactions on Software Engineering.

  • Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-oriented modeling and design, Vol. 38. Upper Saddle River: Prentice Hall.

    Google Scholar 

  • Schwitter, R. (2002). English as a formal specification language. In Database and expert systems applications. Proceedings of the 13th international workshop on IEEE, pp. 228–232.

  • Schwitter, R., Kaljurand, K., Cregan, A., Dolbear, C., & Hart, G. (2008). A comparison of three controlled natural languages for owl 1.1. In 4th OWL experiences and directions workshop (OWLED 2008 DC), Washington, pp. 1–2.

  • Siegemund, K., Thomas, E., Zhao, Y., Pan, J., & Assmann, U. (2011). Towards Ontology-driven Requirements Engineering. In Proceedings of the 7th international workshop on semantic web enabled software engineering on SWESE.

  • Sistla, A. P., & Clarke, E. M. (1985). The complexity of propositional linear temporal logics. Journal of the ACM (JACM), 32(3), 733–749.

    Article  MATH  MathSciNet  Google Scholar 

  • Sommerville, I. (2011). Software Engineering, 9th edition. Saddle River, NJ: Pearson Education Inc..

    Google Scholar 

  • Sommerville, I., & Sawyer, P. (1997). Requirements engineering: A good practice guide. Bristol: Wiley.

    MATH  Google Scholar 

  • Spanoudakis, G., & Zisman, A. (2001). Inconsistency management in software engineering: Survey and open research issues. Handbook of software engineering and knowledge engineering, 1, pp. 329–380.

    Article  Google Scholar 

  • TONES. (2008). Tones ontology repository.

  • Tsai, J., Weigert, T., & Jang, H. (1992). A hybrid knowledge representation as a basis of requirement specification and specification analysis. Software Engineering, IEEE Transactions on, 18(12), 1076–1100.

    Article  Google Scholar 

  • Van Lamsweerde, A. (2000). Requirements engineering in the year 00: A research perspective. In Proceedings of the 22nd international conference on software engineering on ACM, pp. 5–19.

  • Van Lamsweerde, A. (2001). Goal-oriented requirements engineering: A guided tour. In Proceedings of the fifth IEEE international symposium on requirements engineering on IEEE, pp. 249–262.

  • van Lamsweerde, A. (2003). Goal-oriented requirements engineering: From system objectives to uml models to precise software specifications. In Proceedings of the 25th international conference on software engineering on IEEE computer society, pp. 744–745.

  • Van Lamsweerde, A., Darimont, R., & Letier, E. (1998). Managing conflicts in goal-driven requirements engineering. IEEE Transactions on Software Engineering, 24(11), 908–926.

    Article  Google Scholar 

  • Weston, N., Chitchyan, R., & Rashid, A. (2009). Formal semantic conflict detection in aspect-oriented requirements. Requirements Engineering, 14(4), 247–268.

    Article  Google Scholar 

  • Wiki, P. (2007).

  • Yu, E. (1993). Modeling organizations for information systems requirements engineering. In Proceedings of the IEEE international symposium on requirements engineering on IEEE, pp. 34–41.

  • Zave, P., & Jackson, M. (1997). Four dark corners of requirements engineering. ACM Transactions on Software Engineering and Methodology (TOSEM), 6(1), 1–30.

    Article  Google Scholar 

Download references


We thank the anonymous reviewers for the helpful discussions and comments. This work is supported by the ARC Grant DP0987380.

Author information

Authors and Affiliations


Corresponding author

Correspondence to Tuong Huan Nguyen.



ReInDetector description

In this section, we present a scenario to demonstrate the functionality of REInDetector. The scenario in this demonstration is part of the traveler social networking use case which was taken in the evaluation section. The steps through this demonstration are described as followed.

  1. 1.

    In the first step, the requirement F24_IfGrpCommNoForum is added (assume that it has not been added) (cf. Fig. 10).

    Fig. 10
    figure 10

    Adding new requirements

  2. 2.

    In this step, we show the value of domain knowledge and semantics and how they can help in detecting requirements inconsistencies. We use

    • F22_SupForum : System needs to provide a forum for discussions ( System SubClassOf supportFeature SOME Forum ).

    • F26_SupUserGroup : System supports the creation of user groups to facilitate the connection ( System SubClassOf supportFeature SOME UserGroup ).

    • F24_IfGrpCommNoForum : If the system supports any type of group communication, then no forum is needed ( supportFeature SOME GroupCommunication NOT (SubClassOf supportFeature SOME Forum) ).

    But without a proper characterization of the associated relationship between the capture concepts, no problems can manifest (cf. Fig. 11). We wish to emphasize this point here, in particular, to motivate the need for proper knowledge representation in RE.

    Fig. 11
    figure 11

    Requirements set with inconsistent goals

  3. 3.

    Next, we demonstrate how the ontology editor can be used to define concepts, roles, instances, domain knowledge, rules, and constraints (cf. Fig. 12) In particular, we show how “UserGroup” can be defined as a sub-concept of “GroupCommunication”.

    Fig. 12
    figure 12

    Defining semantics with ontology editor

  4. 4.

    Next, we show how to use the reasoner in analyzing requirements to identify inconsistencies and how the provided explanations may help requirements engineers get more insights into the problem (cf. Fig. 13).

    Fig. 13
    figure 13

    A scenario of inconsistency

  5. 5.

    In the next step, we present the requirement query support provided by REInDetector. We particularly make a query to analyze a partial set of requirements which does not contains all requirements involved in the inconsistency. The results from the reasoner indicates that there is no inconsistency in this set of requirements (cf. Figure 14).

    Fig. 14
    figure 14

    Requirement query service

  6. 6.

    In the final step of the demonstration, we show how the identified inconsistency can be resolved. In this case, that is done by removing one of the inconsistent requirements ( F24_IfGrpCommNoForum ) (cf. Fig. 15)

    Fig. 15
    figure 15

    All inconsistencies resolved


REInDetector, accompanied with a demo scenario and user quick-start guide are available for download at:

Rights and permissions

Reprints and Permissions

About this article

Cite this article

Nguyen, T.H., Vo, B.Q., Lumpe, M. et al. KBRE: a framework for knowledge-based requirements engineering. Software Qual J 22, 87–119 (2014).

Download citation

  • Published:

  • Issue Date:

  • DOI:


  • Requirements engineering
  • Inconsistencies
  • Identification
  • Description logics
  • Manchester OWL Syntax
  • Ontology