| { |
| "paper_id": "U19-1017", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T03:07:38.990322Z" |
| }, |
| "title": "CNL ER : A Controlled Natural Language for Specifying and Verbalising Entity Relationship Models", |
| "authors": [ |
| { |
| "first": "Bayzid", |
| "middle": [ |
| "Ashik" |
| ], |
| "last": "Hossain", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "Macquarie University", |
| "location": { |
| "settlement": "Sydney", |
| "country": "Australia" |
| } |
| }, |
| "email": "" |
| }, |
| { |
| "first": "Gayathri", |
| "middle": [], |
| "last": "Rajan", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "Macquarie University", |
| "location": { |
| "settlement": "Sydney", |
| "country": "Australia" |
| } |
| }, |
| "email": "gayathri.rajan@students.mq.edu.au" |
| }, |
| { |
| "first": "Rolf", |
| "middle": [], |
| "last": "Schwitter", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "Macquarie University", |
| "location": { |
| "settlement": "Sydney", |
| "country": "Australia" |
| } |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "The first step towards designing an information system is conceptual modelling where domain experts and knowledge engineers identify the necessary information together to build an information system. Entity relationship modelling is one of the most popular conceptual modelling techniques that represents an information system in terms of entities, attributes and relationships. Entity relationship models are constructed graphically but are often difficult to understand by domain experts. To overcome this problem, we suggest to verbalise these models in a controlled natural language. In this paper, we present CNL ER , a controlled natural language for specifying and verbalising entity relationship (ER) models that not only solves the verbalisation problem for these models but also provides the benefits of automatic verification and validation, and semantic round-tripping which makes the communication process transparent between the domain experts and the knowledge engineers.", |
| "pdf_parse": { |
| "paper_id": "U19-1017", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "The first step towards designing an information system is conceptual modelling where domain experts and knowledge engineers identify the necessary information together to build an information system. Entity relationship modelling is one of the most popular conceptual modelling techniques that represents an information system in terms of entities, attributes and relationships. Entity relationship models are constructed graphically but are often difficult to understand by domain experts. To overcome this problem, we suggest to verbalise these models in a controlled natural language. In this paper, we present CNL ER , a controlled natural language for specifying and verbalising entity relationship (ER) models that not only solves the verbalisation problem for these models but also provides the benefits of automatic verification and validation, and semantic round-tripping which makes the communication process transparent between the domain experts and the knowledge engineers.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "An information system is a piece of software that has integrated components for organizing and analyzing data to aid decision making in an organization (Laudon and Laudon, 2015) . One of the major roles of an information system is to accumulate data, turn it into information and later transform that information into organizational knowledge (Bourgeois, 2014) . To be successful an information system always depends on a good design and conceptual modelling is the first step in the design process (Oliv\u00e9, 2007) . Information systems are best specified on the conceptual level using a language with names for individuals, concepts, and relations that occur in the application domain. Such a language is easy to understand by the domain experts and enhances correctness, compati-bility, productivity and clarity in information system design (Halpin, 1998) . Conceptual modelling involves different parties (e.g., domain experts and knowledge engineers) who brainstorm together to identify the necessary information for building the system (Hossain and Schwitter, 2018) . After identifying the required information, knowledge engineers build a conceptual model of the information system by using conceptual modelling techniques such as entity relationship modelling (ERM) (Richard, 1990; Frantiska, 2018) , object oriented modelling (UML) (O'Regan, 2017), or object role modelling (ORM) (Halpin, 2009) .", |
| "cite_spans": [ |
| { |
| "start": 152, |
| "end": 177, |
| "text": "(Laudon and Laudon, 2015)", |
| "ref_id": "BIBREF14" |
| }, |
| { |
| "start": 343, |
| "end": 360, |
| "text": "(Bourgeois, 2014)", |
| "ref_id": "BIBREF3" |
| }, |
| { |
| "start": 499, |
| "end": 512, |
| "text": "(Oliv\u00e9, 2007)", |
| "ref_id": "BIBREF20" |
| }, |
| { |
| "start": 841, |
| "end": 855, |
| "text": "(Halpin, 1998)", |
| "ref_id": "BIBREF8" |
| }, |
| { |
| "start": 1039, |
| "end": 1068, |
| "text": "(Hossain and Schwitter, 2018)", |
| "ref_id": "BIBREF11" |
| }, |
| { |
| "start": 1271, |
| "end": 1286, |
| "text": "(Richard, 1990;", |
| "ref_id": "BIBREF23" |
| }, |
| { |
| "start": 1287, |
| "end": 1303, |
| "text": "Frantiska, 2018)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 1386, |
| "end": 1400, |
| "text": "(Halpin, 2009)", |
| "ref_id": "BIBREF9" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "One of the problems with these models is that they are constructed graphically and as a result they are often hard to understand for domain experts (Jarrar et al., 2006) . Another problem with these conceptual modelling techniques is that they have no formal semantics; therefore, they are not machine comprehensible, do not support automatic verification and validation nor automatic reasoning (Calvanese, 2013) .", |
| "cite_spans": [ |
| { |
| "start": 148, |
| "end": 169, |
| "text": "(Jarrar et al., 2006)", |
| "ref_id": "BIBREF13" |
| }, |
| { |
| "start": 395, |
| "end": 412, |
| "text": "(Calvanese, 2013)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "To overcome these problems previous works used logic in parallel with traditional conceptual modelling techniques (Lutz, 2002; Berardi et al., 2005; . There are tools (Fillottrani et al., 2012; Lembo et al., 2016b,a) that allow knowledge engineers to draw the conceptual model and then translate the model constructs into a logical representation. This logical representation is then used to verify and validate the model. Using logic with traditional conceptual modelling techniques also introduces some problems like the difficulty to generate logical representations. Furthermore, it is not easy to understand these logical representations for domain experts since no well established methodology is available to make this process transparent (Calvanese, 2013) .", |
| "cite_spans": [ |
| { |
| "start": 114, |
| "end": 126, |
| "text": "(Lutz, 2002;", |
| "ref_id": "BIBREF18" |
| }, |
| { |
| "start": 127, |
| "end": 148, |
| "text": "Berardi et al., 2005;", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 167, |
| "end": 193, |
| "text": "(Fillottrani et al., 2012;", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 194, |
| "end": 216, |
| "text": "Lembo et al., 2016b,a)", |
| "ref_id": null |
| }, |
| { |
| "start": 746, |
| "end": 763, |
| "text": "(Calvanese, 2013)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Recent research on conceptual modelling showed that using a controlled natural language Figure 1 : A CNL based conceptual modelling framework (CNL) for specification and verbalisation can overcome the problems introduced by logic in the conceptual modelling process (Hossain and Schwitter, 2018) . A CNL can be defined as a subset of natural language that is obtained by constraining the grammar and vocabulary in order to eliminate the ambiguity as well as the complexity of the language. A CNL can be designed in such a way that it has well defined computational properties and thus can be translated unambiguously into a formal representation (Schwitter, 2010) . Using a CNL in conceptual modelling helps the domain experts to understand the conceptual models through specification and verbalisation, allows the machine to understand the models as the CNL can be translated into a formal representation, and therefore supports automated reasoning and question answering.", |
| "cite_spans": [ |
| { |
| "start": 266, |
| "end": 295, |
| "text": "(Hossain and Schwitter, 2018)", |
| "ref_id": "BIBREF11" |
| }, |
| { |
| "start": 646, |
| "end": 663, |
| "text": "(Schwitter, 2010)", |
| "ref_id": "BIBREF25" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 88, |
| "end": 96, |
| "text": "Figure 1", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The idea of using natural language for conceptual modelling is not new but previous approaches (Saeki et al., 1989; Mich, 1996; Harmain and Gaizauskas, 2003; Ambriola and Gervasi, 2006; Ibrahim and Ahmad, 2010) did not constrain the natural language enough and did not use logic to formally represent the conceptual models. Furthermore, the idea of semantic round-tripping from a specification to a conceptual model and from a conceptual model to a specification (verbalisation) is novel in this context. A recent survey (St\u00f6rrle, 2017) on conceptual models showed that there are three modes of conceptual modelling: 1. informal modelling for cognition and communication; 2. semi-formal modelling for planning and documentation; and 3. formal modelling for generation and contracts. In the software industry 70-79% of the modelling is done informally (St\u00f6rrle, 2017) .", |
| "cite_spans": [ |
| { |
| "start": 95, |
| "end": 115, |
| "text": "(Saeki et al., 1989;", |
| "ref_id": "BIBREF24" |
| }, |
| { |
| "start": 116, |
| "end": 127, |
| "text": "Mich, 1996;", |
| "ref_id": "BIBREF19" |
| }, |
| { |
| "start": 128, |
| "end": 157, |
| "text": "Harmain and Gaizauskas, 2003;", |
| "ref_id": "BIBREF10" |
| }, |
| { |
| "start": 158, |
| "end": 185, |
| "text": "Ambriola and Gervasi, 2006;", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 186, |
| "end": 210, |
| "text": "Ibrahim and Ahmad, 2010)", |
| "ref_id": "BIBREF12" |
| }, |
| { |
| "start": 521, |
| "end": 536, |
| "text": "(St\u00f6rrle, 2017)", |
| "ref_id": "BIBREF27" |
| }, |
| { |
| "start": 851, |
| "end": 866, |
| "text": "(St\u00f6rrle, 2017)", |
| "ref_id": "BIBREF27" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "2" |
| }, |
| { |
| "text": "We want to use CNL in the conceptual modelling process to overcome the problems that occur in traditional conceptual modelling approaches. We want to bridge the gap between an informal and formal conceptual model. We also want to offer verbalisation for ERM. ERM is frequently used in the industry and has no verbalisation support. Existing tools that support creating ERM models do not provide the facility of writing specifications for conceptual models and therefore semantic round-tripping is not possible. We have developed a CNL-based conceptual modelling framework [ Fig. 3 ] that supports the following points:", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 574, |
| "end": 580, |
| "text": "Fig. 3", |
| "ref_id": "FIGREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "2" |
| }, |
| { |
| "text": "1. Writing textual specifications for the conceptual modelling process.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "2" |
| }, |
| { |
| "text": "2. Description logic based common formal representation (DL ALCQI) for different conceptual models.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "2" |
| }, |
| { |
| "text": "3. Generating a conceptual model from a written specification and the other way around.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "2" |
| }, |
| { |
| "text": "In this paper we present CNL ER , a controlled natural language that is specially designed to specify and verbalize ERM constructs.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Verification and validation of the written specification.", |
| "sec_num": "4." |
| }, |
| { |
| "text": "An ERM represents an information system in terms of entities, attributes and relationships (Song and Chen, 2009) . ERM is mainly used to design relational databases and to do the planning and requirement analysis of an information system. The outcome of an ERM process is a graphical model often known as ER diagram (ERD). The basic components of an ERD are entities, attributes, and relationships [ Fig. 2 ]. An entity is a real world object having independent existence (e.g., person, place, organisation) (Song and Chen, 2009 ). An entity is also known as a class or a concept. There are two types (1) strong entities that have key attributes to uniquely identify each instance of an entity (e.g., student has student id as a key attribute); and (2) weak entities that do not have any key attributes and they depend on other strong entities to get identified (e.g., a room can not exist without a building, so \"room\" is a weak entity whereas \"building\" is a strong entity).", |
| "cite_spans": [ |
| { |
| "start": 91, |
| "end": 112, |
| "text": "(Song and Chen, 2009)", |
| "ref_id": "BIBREF26" |
| }, |
| { |
| "start": 508, |
| "end": 528, |
| "text": "(Song and Chen, 2009", |
| "ref_id": "BIBREF26" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 400, |
| "end": 406, |
| "text": "Fig. 2", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "ERM Constructs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "An attribute indicates a property or characteristic of an entity (Li and Chen, 2009) . For example, if a student is an entity then \"student name\", \"student id\", and \"phone number\" would be the attributes for that student. Attributes help us to differentiate between entities. An attribute can be single valued (e.g., \"student name\") or multivalued (e.g., \"skills\"). A single valued attribute or a collection of single valued attributes that identify an instance of an entity uniquely is known as A key attribute or a primary key.", |
| "cite_spans": [ |
| { |
| "start": 65, |
| "end": 84, |
| "text": "(Li and Chen, 2009)", |
| "ref_id": "BIBREF17" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "ERM Constructs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "A relationship depicts the association between or among the entities. For example, if \"student\" and \"program\" are entities then in the fact \"student is enrolled in program\", the expression \"is enrolled in\" is the relationship between \"student\" and \"program\". Every relationship has a cardinality which defines the number of occurrences (minimum and maximum) of one entity that is related to a single occurrence of the other entity (Song and Chen, 2009) . Based on the form of cardinality, we can divide a relationship in ERM into three types: oneto-one, one-to-many and many-to-many. Sometimes a many-to-many relationship acts as an entity itself which is known as an associative entity. An associative entity can have attributes that represent the properties of the corresponding relationship (Li and Chen, 2009) . For example, if \"student\" and \"course\" are entities then the facts \"every student studies 1 or more courses\" and \"every course is studied by 1 or more students\" indicate that \"student\" and \"course\" have a many-to-many relationship. So the relationship between these two entities can act as an associative entity. We can consider \"study details\" as an associative entity that can have \"study start date\" and \"study end date\" as attributes. ", |
| "cite_spans": [ |
| { |
| "start": 431, |
| "end": 452, |
| "text": "(Song and Chen, 2009)", |
| "ref_id": "BIBREF26" |
| }, |
| { |
| "start": 794, |
| "end": 813, |
| "text": "(Li and Chen, 2009)", |
| "ref_id": "BIBREF17" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "ERM Constructs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "In this section we discuss how to express ERM constructs using CNL ER . For this purpose, we have taken an example scenario from the paper (Frantiska, 2018) and extended it by adding a weak entity and modifying the associative entity. CNL ER has a distinct sentence format to declare an entity in ERM. For example, to define the fact that a student is an entity, CNL ER has the following sentence pattern with a noun (student) in subject position, followed by a copula (is) and the key phrase an entity type in object position (e.g., see sentences 1-6 in table [1] ). CNL ER also has a particular sentence pattern to declare attributes in ERM. For example, to specify an attribute of type integer, CNL ER uses a sentence that contains a previously declared entity name (e.g., student) followed by an attribute name (e.g., id); this forms a data property name (student id) which is followed by a copula (is), and the key phrase (e.g., of integer data type). For example, sentences 7-18 in Table [1] show the attribute declarations for the example scenario.", |
| "cite_spans": [ |
| { |
| "start": 139, |
| "end": 156, |
| "text": "(Frantiska, 2018)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 561, |
| "end": 564, |
| "text": "[1]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 988, |
| "end": 997, |
| "text": "Table [1]", |
| "ref_id": "TABREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To declare a relationship, we use a declared entity type name (e.g., student) in subject position and a declared entity type name (e.g., department) in object position with a relationship name (e.g., belongs to) in between. (e.g., see sentences 19-27 in table [1] for relationship declarations).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To define cardinality constraints over the relationships, CNL ER uses a quantifying expression followed by entities and attributes: a quantifier (every) in subject position and either a quantifier (0 or more, 1 or more) or a cardinality constraint (at least, at most, exactly) in object position. For example, to define a one-to-one relationship cardinality between the entities \"student\" and \"department\", sentence (28) in table [1] is used, and to define a one-to-many relationship cardinality, sentence (29) in table [1] is used.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "In order to define a many-to-many relationship in CNL ER , we have to write two sentences that express the relationship between the entities in both direction. For example, to express a may-to-many relationship between \"student\" and \"course\", we have to write the following two sentences.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "\u2022 Every student studies 1 or more courses.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "\u2022 Every course is studied by 1 or more students.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To declare an associative entity in CNL ER (e.g., \"enrolment\"), we have to declare the entity first. After that the entity needs to be linked with a many-to-many relationship using a predefined word \"associates\". The sentence 27 in table [1] declares an associative entity that links the ternary relationship among a teacher, a student and a unit. The relationship \"includes\" in the sentences 34, 35 and 36 of table [1] is predefined and can only be used together with an associative entity. An associative entity can have attributes like other entities. For example, sentence 41 in table [1] specifies attributes for the associative entity \"enrolment\".", |
| "cite_spans": [ |
| { |
| "start": 238, |
| "end": 241, |
| "text": "[1]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To declare a weak entity in CNL ER , we have to declare both strong and weak entities first as entities (e.g., \"course\" and \"section\" in table [1] ). After that we need to specify that the weak entity is dependent of the strong entity. For example, to declare that a section is a weak entity, sentence 42 specifies that \"section\" is a dependent of the \"course\" entity by using a predefined relationship \"dependent of\" in table [1] .", |
| "cite_spans": [ |
| { |
| "start": 143, |
| "end": 146, |
| "text": "[1]", |
| "ref_id": null |
| }, |
| { |
| "start": 427, |
| "end": 430, |
| "text": "[1]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CNL ER for ERM Constructs", |
| "sec_num": "4" |
| }, |
| { |
| "text": "We use a definite clause grammar (DCG) (Pereira and Shieber, 2002) to process and translate a CNL ER specification. The key advantage of using a DCG is that it implements a logic program that allows us to build a bi-directional grammar. The grammar translates the CNL ER sentences into a corresponding internal description logic (DL) representation. This internal DL representation is further processed to generate an ERD.", |
| "cite_spans": [ |
| { |
| "start": 39, |
| "end": 66, |
| "text": "(Pereira and Shieber, 2002)", |
| "ref_id": "BIBREF22" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "A specification in CNL ER consists of function words and content words. Function words (quantifiers, cardinality constraints and operators) describe the structure of the sentences and the number of these function words is fixed. In contrast, content words (nouns and verbs) are domain specific and are added to the lexicon during the writing process when they are declared. It is important to note that the bi-directional DCG contains grammar rules that translate every CNL ER sentence into the internal DL representation and vice versa; this enable semantic round-tripping in our conceptual modelling framework. In this paper, we discuss the DCG rules that process some of the core ERM constructs. Below we discuss the grammar rules that process entity, attribute, relationship, constraint and associative entity declarations.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Grammar", |
| "sec_num": "5" |
| }, |
| { |
| "text": "Listing [1] shows the grammar rules for an entity declaration. The first grammar rule states that a declarative sentence (s) consists of a noun phrase (np) and a key phrase (\"is an entity type\"), followed by a full stop (.). The grammar rule contains additional arguments that implement feature structures in the form of attribute:value pairs whereas the value can be a simple term or a complex term (for example in the form of a difference list:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Entity Declaration", |
| "sec_num": "5.1" |
| }, |
| { |
| "text": "[Head|Tail]-Tail). The feature structure mode:M specifies whether the rule is used in the processing or generating mode and the feature structure type:entity specifies the type of the ERM construct. The feature structure sem:L1-L2 is used to build up the semantic representation for an entity. The grammar rule for the noun phrase (np) con-tains a feature structure (num:N) that deals with number agreement (singular or plural), a feature structure (arg:X) that defines the argument of an entity, and one (pos:subj) that specifies the position of the noun. Finally, the feature structure cat:noun specifies a noun and wform:WForm specifies a word form consisting of potentially multiple elements. To extract an entity from the input list, a lexical rule lexical_rule/1 is used that generates lexical entries with their corresponding singular and plural forms (e.g., student and students) for that entity with the help of a morphological component.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Entity Declaration", |
| "sec_num": "5.1" |
| }, |
| { |
| "text": "To process a sentence that is used to declare an attribute, we use similar grammar rules as shown in listing [1] but with a different key phrase (e.g., of integer data type). To process an attribute and its data type, a lexical rule is used that extracts the attribute from the input list by excluding the copula and the key phrase and by identifying the type (e.g., integer, string, date) from the key phrase. After that the lexical rule is used to insert the attribute and its type information into the lexicon.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Attribute Declaration", |
| "sec_num": "5.2" |
| }, |
| { |
| "text": "Listing [2] shows the grammar rules for a relationship declaration. The first grammar rule states again that a declarative sentence (s) consists of a noun phrase (np) and a verb phrase (vp), followed by a full stop (.). The feature structures for the mode declaration and the semantic representation are similar to the entity declaration whereas the feature structure type:fact specifies the ERM construct relationship.", |
| "cite_spans": [ |
| { |
| "start": 8, |
| "end": 11, |
| "text": "[2]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Relationship Declaration", |
| "sec_num": "5.3" |
| }, |
| { |
| "text": "The second grammar rule states that a verb phrase (vp) consists of a verb (verb) and a noun phrase (np). In the case of processing, the grammar rule for the verb consists of a lexical rule (lexi-cal_rule/1) that extracts a relationship from the input list by identifying the noun phrases in the subject and object position. After that, the lexical rule adds the extracted relationship to the lexicon and adds the semantic representation (L0) for that relationship to the outgoing part ([[L0|L1]|L2]) of the difference list. In the case of generating, the grammar rule for a verb removes the semantic representation (L0) from the incoming part ([[L0|L1]|L2]) of the difference list and tries to find this representation in the lexicon in order to return the corresponding lexical entry. Figure 3: ERD of the example scenario (Frantiska, 2018 ) generated by the proposed CNL based conceptual modelling framework.", |
| "cite_spans": [ |
| { |
| "start": 824, |
| "end": 840, |
| "text": "(Frantiska, 2018", |
| "ref_id": "BIBREF7" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Relationship Declaration", |
| "sec_num": "5.3" |
| }, |
| { |
| "text": "To process a sentence that declares a cardinality constraint over a relationship, we use a grammar rule that is quite similar to the grammar rule in listing [2] with an additional quantifier (qnt) in subject position and a constraint (cst) in the object position. Note that the grammar rules for a quantifier and a cardinality constraint play an important role because they provide the relevant structure for the internal representation. For example, the grammar rule for the universal quantifier (every) results in a pattern of the form sem:forall(X, Res ==> Sco) that takes a restrictor (Res) that contains the information derived from the noun phrase in sub- ject position and the scope (Sco) that contains the information derived from the verb phrase and returns a pattern for an implication. In the case of a cardinality constraint that pattern might have the following form: exists(X, Res & min(L) : Sco : max(U)). Note also that the restrictor and scope are built up in these grammar rules with the help of specific feature structures.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Constraint Declaration", |
| "sec_num": "5.4" |
| }, |
| { |
| "text": "Listing [3] shows an excerpt of the grammar rules that are used to process and generate sentences for an associative entity. The first rule reuses the rule for a relationship and uses a key verb word (associates) to process an associative entity declaration. The first rule states that a sentence consists of a noun phrase (np) in subject position, a verb (verb) and a sentence in object position that refers to a particular relationship in the lexicon.", |
| "cite_spans": [ |
| { |
| "start": 8, |
| "end": 11, |
| "text": "[3]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Associative Entity Declaration", |
| "sec_num": "5.5" |
| }, |
| { |
| "text": "The grammar rule for np is the same as we used for the relationship declaration (see listing [2] ) and for the ease of understanding we keep it in listing [3] . The feature structure rel:R in the sentence rule in object position states that this is a \"reified\" relationship available in the lexicon and unlike the relationship rule stated in listing [2], it does not need to be processed by the lexical rule (lexical_rule/1).", |
| "cite_spans": [ |
| { |
| "start": 93, |
| "end": 96, |
| "text": "[2]", |
| "ref_id": null |
| }, |
| { |
| "start": 155, |
| "end": 158, |
| "text": "[3]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Associative Entity Declaration", |
| "sec_num": "5.5" |
| }, |
| { |
| "text": "This relationship could be a binary relationship or a ternary relationship. This grammar rule is used to link an entity to a relationship that makes the entity an associative entity.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Associative Entity Declaration", |
| "sec_num": "5.5" |
| }, |
| { |
| "text": "We took an example scenario from the ER paper (Frantiska, 2018) , extended the scenario and expressed the scenario in CNL ER (see table [1] ). After that we translated the CNL ER specification into an internal DL representation and translated the resulting ERM constructs into a RuleML (Boley et al., 2010) JSON 1 representation (see figure 4) . This JSON representation is used by our conceptual modelling tool for building an interactive diagram. The implementation of our conceptual modelling tool is based on the GoJS 2.0 frame-{\"And\": {\"Atom\": [{ \"Rel\": \"entity\", \"Ind\": \"department\", \"Var\": \"X\" }, { \"Rel\": \"relation\", \"Ind\": \"employ\", \"Var\": [\"X\",\"Y\"] }, { \"Rel\": \"entity\", \"Ind\": \"teacher\", \"Var\": \"Y\" }] } } The JSON representation is parsed to identify the entities, attributes and relationships for the resulting diagram. Unique entity names and relationship names are identified and added to a node array. Relationships are assessed individually to identify the links and added to a link array. These constructs are then translated into the internal GoJS representation that is used by the GoJS engine to render the diagram in a web browser (see figure 3) . New entities, attributes and relationships can be added to a diagram and existing components can be modified or deleted by the user. Building a new diagram from scratch is also possible, since we designed the graphical editor for conceptual modelling as a standalone tool. When a diagram is saved, its internal GoJS representation is produced from which the internal JSON representation can be derived to generate the CNL ER specification again.", |
| "cite_spans": [ |
| { |
| "start": 46, |
| "end": 63, |
| "text": "(Frantiska, 2018)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 136, |
| "end": 139, |
| "text": "[1]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 334, |
| "end": 344, |
| "text": "figure 4)", |
| "ref_id": "FIGREF3" |
| }, |
| { |
| "start": 1159, |
| "end": 1168, |
| "text": "figure 3)", |
| "ref_id": "FIGREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Evaluation", |
| "sec_num": "6" |
| }, |
| { |
| "text": "To evaluate the controlled natural language CNL ER , we then checked the expressiveness of the language in terms of ERM constructs. We compared the constructed diagram with the textual CNL ER specification of the scenario and found that the diagram correctly represented all corresponding entities, attributes and relationships. Furthermore, it is possible to generate a semantically equivalent CNL ER specification from the diagram in a round-tripping fashion.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation", |
| "sec_num": "6" |
| }, |
| { |
| "text": "In this paper we presented CNL ER , a controlled natural language that can be used to specify and verbalise ER models. Our main objective is to develop a controlled natural language based universal conceptual modelling framework where a domain expert can actively participate in the conceptual modelling process with a knowledge engineer. CNL ER is a controlled natural language that can express ERM constructs in natural language and the language processor can translate it into a formal language (e.g., any serialization of DL AL-CQI (Lutz, 2002; Berardi et al., 2005; ). This formal representation can be further used for verification and validation. After that the formal representation can be processed to generate an ERD.", |
| "cite_spans": [ |
| { |
| "start": 536, |
| "end": 548, |
| "text": "(Lutz, 2002;", |
| "ref_id": "BIBREF18" |
| }, |
| { |
| "start": 549, |
| "end": 570, |
| "text": "Berardi et al., 2005;", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Discussion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "The goal of this work is to improve the current conceptual modelling process and enable domain domain experts to express their knowledge in a well defined subset of natural language that can be used as high-level interface language to construct conceptual models. Future work will investigate the scalability of CNL ER by extending the coverage of the language so that also UML class diagrams (Calvanese, 2013) and ORM diagrams can be expressed in the same grammatical framework. These extensions involve parametrising and modularising the existing grammar to support additional modelling constructs.", |
| "cite_spans": [ |
| { |
| "start": 393, |
| "end": 410, |
| "text": "(Calvanese, 2013)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Discussion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "CNL ER is a high-level specification and verbalisation language for ER models that supports a controlled natural language based conceptual modelling approach. A textual specification of a conceptual model in CNL ER can be translated via an internal representation into a JSON representation that is then used to generate an ER diagram. The translation works also in the other direction and supports the verbalisation of ER diagrams in CNL ER . Because of these properties, CNL ER has the potential to bridge the communication gap between a domain expert and a knowledge engineer in the domain of entity relationship modelling and makes the modelling process at the same time formal in a seemingly informal way.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "8" |
| }, |
| { |
| "text": "https://wiki.ruleml.org/index.php/RuleML_in_JSON", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "https://gojs.net/latest/index.html", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "On the systematic analysis of natural language requirements with circe", |
| "authors": [ |
| { |
| "first": "Vincenzo", |
| "middle": [], |
| "last": "Ambriola", |
| "suffix": "" |
| }, |
| { |
| "first": "Vincenzo", |
| "middle": [], |
| "last": "Gervasi", |
| "suffix": "" |
| } |
| ], |
| "year": 2006, |
| "venue": "Automated Software Engineering", |
| "volume": "13", |
| "issue": "1", |
| "pages": "107--167", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Vincenzo Ambriola and Vincenzo Gervasi. 2006. On the systematic analysis of natural language require- ments with circe. Automated Software Engineering, 13(1):107-167.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Reasoning on uml class diagrams", |
| "authors": [ |
| { |
| "first": "Daniela", |
| "middle": [], |
| "last": "Berardi", |
| "suffix": "" |
| }, |
| { |
| "first": "Diego", |
| "middle": [], |
| "last": "Calvanese", |
| "suffix": "" |
| }, |
| { |
| "first": "Giuseppe", |
| "middle": [ |
| "De" |
| ], |
| "last": "Giacomo", |
| "suffix": "" |
| } |
| ], |
| "year": 2005, |
| "venue": "Artificial Intelligence", |
| "volume": "168", |
| "issue": "1", |
| "pages": "70--118", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Daniela Berardi, Diego Calvanese, and Giuseppe De Giacomo. 2005. Reasoning on uml class diagrams. Artificial Intelligence, 168(1):70-118.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Ruleml 1.0: the overarching specification of web rules", |
| "authors": [ |
| { |
| "first": "Harold", |
| "middle": [], |
| "last": "Boley", |
| "suffix": "" |
| }, |
| { |
| "first": "Adrian", |
| "middle": [], |
| "last": "Paschke", |
| "suffix": "" |
| }, |
| { |
| "first": "Omair", |
| "middle": [], |
| "last": "Shafiq", |
| "suffix": "" |
| } |
| ], |
| "year": 2010, |
| "venue": "International Workshop on Rules and Rule Markup Languages for the Semantic Web", |
| "volume": "", |
| "issue": "", |
| "pages": "162--178", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Harold Boley, Adrian Paschke, and Omair Shafiq. 2010. Ruleml 1.0: the overarching specification of web rules. In International Workshop on Rules and Rule Markup Languages for the Semantic Web, pages 162-178. Springer.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Information systems for business and beyond. The Saylor Foundation", |
| "authors": [ |
| { |
| "first": "David", |
| "middle": [], |
| "last": "Bourgeois", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "David Bourgeois. 2014. Information systems for busi- ness and beyond. The Saylor Foundation.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Description Logics for Conceptual Modeling Forms of reasoning on UML Class Diagrams. EPCL Basic Training Camp", |
| "authors": [ |
| { |
| "first": "Diego", |
| "middle": [], |
| "last": "Calvanese", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Diego Calvanese. 2013. Description Logics for Con- ceptual Modeling Forms of reasoning on UML Class Diagrams. EPCL Basic Training Camp.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "The icom 3.0 intelligent conceptual modelling tool and methodology", |
| "authors": [ |
| { |
| "first": "Enrico", |
| "middle": [], |
| "last": "Pablo R Fillottrani", |
| "suffix": "" |
| }, |
| { |
| "first": "Sergio", |
| "middle": [], |
| "last": "Franconi", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Tessaris", |
| "suffix": "" |
| } |
| ], |
| "year": 2012, |
| "venue": "Semantic Web", |
| "volume": "3", |
| "issue": "3", |
| "pages": "293--306", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Pablo R Fillottrani, Enrico Franconi, and Sergio Tes- saris. 2012. The icom 3.0 intelligent conceptual modelling tool and methodology. Semantic Web, 3(3):293-306.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "Orm2: formalisation and encoding in owl2", |
| "authors": [ |
| { |
| "first": "Enrico", |
| "middle": [], |
| "last": "Franconi", |
| "suffix": "" |
| }, |
| { |
| "first": "Alessandro", |
| "middle": [], |
| "last": "Mosca", |
| "suffix": "" |
| }, |
| { |
| "first": "Dmitry", |
| "middle": [], |
| "last": "Solomakhin", |
| "suffix": "" |
| } |
| ], |
| "year": 2012, |
| "venue": "OTM Confederated International Conferences\" On the Move to Meaningful Internet Systems", |
| "volume": "", |
| "issue": "", |
| "pages": "368--378", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Enrico Franconi, Alessandro Mosca, and Dmitry Solo- makhin. 2012. Orm2: formalisation and encoding in owl2. In OTM Confederated International Con- ferences\" On the Move to Meaningful Internet Sys- tems\", pages 368-378. Springer.", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Entity-relationship diagrams", |
| "authors": [ |
| { |
| "first": "Joseph", |
| "middle": [], |
| "last": "Frantiska", |
| "suffix": "" |
| } |
| ], |
| "year": 2018, |
| "venue": "Visualization Tools for Learning Environment Development", |
| "volume": "", |
| "issue": "", |
| "pages": "21--30", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joseph Frantiska. 2018. Entity-relationship diagrams. In Visualization Tools for Learning Environment De- velopment, pages 21-30. Springer.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "ORM/NIAM Object-Role Modeling", |
| "authors": [ |
| { |
| "first": "Terry", |
| "middle": [], |
| "last": "Halpin", |
| "suffix": "" |
| } |
| ], |
| "year": 1998, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": { |
| "DOI": [ |
| "10.1007/978-3-662-03526-9_4" |
| ] |
| }, |
| "num": null, |
| "urls": [], |
| "raw_text": "Terry Halpin. 1998. ORM/NIAM Object-Role Model- ing. Springer Berlin Heidelberg, Berlin, Heidelberg.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "Object-role modeling", |
| "authors": [ |
| { |
| "first": "Terry", |
| "middle": [], |
| "last": "Halpin", |
| "suffix": "" |
| } |
| ], |
| "year": 2009, |
| "venue": "Encyclopedia of Database Systems", |
| "volume": "", |
| "issue": "", |
| "pages": "1941--1946", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Terry Halpin. 2009. Object-role modeling. In Ency- clopedia of Database Systems, pages 1941-1946. Springer.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "Cmbuilder: A natural language-based case tool for object-oriented analysis", |
| "authors": [ |
| { |
| "first": "Robert", |
| "middle": [], |
| "last": "Hm Harmain", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Gaizauskas", |
| "suffix": "" |
| } |
| ], |
| "year": 2003, |
| "venue": "Automated Software Engineering", |
| "volume": "10", |
| "issue": "2", |
| "pages": "157--181", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "HM Harmain and Robert Gaizauskas. 2003. Cm- builder: A natural language-based case tool for object-oriented analysis. Automated Software En- gineering, 10(2):157-181.", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Specifying conceptual models using restricted natural language", |
| "authors": [ |
| { |
| "first": "Rolf", |
| "middle": [], |
| "last": "Bayzid Ashik Hossain", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Schwitter", |
| "suffix": "" |
| } |
| ], |
| "year": 2018, |
| "venue": "Proceedings of the Australasian Language Technology Association", |
| "volume": "", |
| "issue": "", |
| "pages": "44--52", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Bayzid Ashik Hossain and Rolf Schwitter. 2018. Spec- ifying conceptual models using restricted natural language. In Proceedings of the Australasian Language Technology Association Workshop 2018, pages 44-52, Dunedin, New Zealand.", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Class diagram extraction from textual requirements using natural language processing (nlp) techniques", |
| "authors": [ |
| { |
| "first": "Mohd", |
| "middle": [], |
| "last": "Ibrahim", |
| "suffix": "" |
| }, |
| { |
| "first": "Rodina", |
| "middle": [], |
| "last": "Ahmad", |
| "suffix": "" |
| } |
| ], |
| "year": 2010, |
| "venue": "2010 Second International Conference on Computer Research and Development", |
| "volume": "", |
| "issue": "", |
| "pages": "200--204", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Mohd Ibrahim and Rodina Ahmad. 2010. Class di- agram extraction from textual requirements using natural language processing (nlp) techniques. In 2010 Second International Conference on Computer Research and Development, pages 200-204. IEEE.", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "Multilingual verbalization of orm conceptual models and axiomatized ontologies", |
| "authors": [ |
| { |
| "first": "Mustafa", |
| "middle": [], |
| "last": "Jarrar", |
| "suffix": "" |
| }, |
| { |
| "first": "Keet Paolo", |
| "middle": [], |
| "last": "Maria", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Dongilli", |
| "suffix": "" |
| } |
| ], |
| "year": 2006, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Mustafa Jarrar, C Maria, and Keet Paolo Dongilli. 2006. Multilingual verbalization of orm conceptual models and axiomatized ontologies.", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "Management Information Systems: Managing the Digital Firm Plus MyMISLab with Pearson eText -Access Card Package", |
| "authors": [ |
| { |
| "first": "C", |
| "middle": [], |
| "last": "Kenneth", |
| "suffix": "" |
| }, |
| { |
| "first": "Jane", |
| "middle": [ |
| "P" |
| ], |
| "last": "Laudon", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Laudon", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kenneth C. Laudon and Jane P. Laudon. 2015. Man- agement Information Systems: Managing the Digi- tal Firm Plus MyMISLab with Pearson eText -Ac- cess Card Package, 14th edition. Prentice Hall Press, Upper Saddle River, NJ, USA.", |
| "links": null |
| }, |
| "BIBREF15": { |
| "ref_id": "b15", |
| "title": "Easy owl drawing with the graphol visual ontology language", |
| "authors": [ |
| { |
| "first": "Domenico", |
| "middle": [], |
| "last": "Lembo", |
| "suffix": "" |
| }, |
| { |
| "first": "Daniele", |
| "middle": [], |
| "last": "Pantaleone", |
| "suffix": "" |
| }, |
| { |
| "first": "Valerio", |
| "middle": [], |
| "last": "Santarelli", |
| "suffix": "" |
| }, |
| { |
| "first": "Domenico", |
| "middle": [ |
| "Fabio" |
| ], |
| "last": "Savo", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Fifteenth International Conference on the Principles of Knowledge Representation and Reasoning", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Domenico Lembo, Daniele Pantaleone, Valerio Santarelli, and Domenico Fabio Savo. 2016a. Easy owl drawing with the graphol visual ontology language. In Fifteenth International Conference on the Principles of Knowledge Representation and Reasoning.", |
| "links": null |
| }, |
| "BIBREF16": { |
| "ref_id": "b16", |
| "title": "Eddy: A graphical editor for owl 2 ontologies", |
| "authors": [ |
| { |
| "first": "Domenico", |
| "middle": [], |
| "last": "Lembo", |
| "suffix": "" |
| }, |
| { |
| "first": "Daniele", |
| "middle": [], |
| "last": "Pantaleone", |
| "suffix": "" |
| }, |
| { |
| "first": "Valerio", |
| "middle": [], |
| "last": "Santarelli", |
| "suffix": "" |
| }, |
| { |
| "first": "Domenico", |
| "middle": [ |
| "Fabio" |
| ], |
| "last": "Savo", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "IJCAI", |
| "volume": "", |
| "issue": "", |
| "pages": "4252--4253", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Domenico Lembo, Daniele Pantaleone, Valerio Santarelli, and Domenico Fabio Savo. 2016b. Eddy: A graphical editor for owl 2 ontologies. In IJCAI, pages 4252-4253.", |
| "links": null |
| }, |
| "BIBREF17": { |
| "ref_id": "b17", |
| "title": "Entity-Relationship Diagram", |
| "authors": [ |
| { |
| "first": "Qing", |
| "middle": [], |
| "last": "Li", |
| "suffix": "" |
| }, |
| { |
| "first": "Yu-Liu", |
| "middle": [], |
| "last": "Chen", |
| "suffix": "" |
| } |
| ], |
| "year": 2009, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "125--139", |
| "other_ids": { |
| "DOI": [ |
| "10.1007/978-3-540-89556-5_6" |
| ] |
| }, |
| "num": null, |
| "urls": [], |
| "raw_text": "Qing Li and Yu-Liu Chen. 2009. Entity-Relationship Diagram, pages 125-139. Springer Berlin Heidel- berg, Berlin, Heidelberg.", |
| "links": null |
| }, |
| "BIBREF18": { |
| "ref_id": "b18", |
| "title": "Reasoning about entity relationship diagrams with complex attribute dependencies", |
| "authors": [ |
| { |
| "first": "Carsten", |
| "middle": [], |
| "last": "Lutz", |
| "suffix": "" |
| } |
| ], |
| "year": 2002, |
| "venue": "Proceedings of the International Workshop in Description Logics 2002 (DL2002), number 53 in CEUR-WS", |
| "volume": "", |
| "issue": "", |
| "pages": "185--194", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Carsten Lutz. 2002. Reasoning about entity relation- ship diagrams with complex attribute dependencies. In Proceedings of the International Workshop in Description Logics 2002 (DL2002), number 53 in CEUR-WS (http://ceur-ws.org), pages 185-194.", |
| "links": null |
| }, |
| "BIBREF19": { |
| "ref_id": "b19", |
| "title": "Nl-oops: from natural language to object oriented requirements using the natural language processing system lolita", |
| "authors": [ |
| { |
| "first": "Luisa", |
| "middle": [], |
| "last": "Mich", |
| "suffix": "" |
| } |
| ], |
| "year": 1996, |
| "venue": "Natural language engineering", |
| "volume": "2", |
| "issue": "2", |
| "pages": "161--187", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Luisa Mich. 1996. Nl-oops: from natural language to object oriented requirements using the natural lan- guage processing system lolita. Natural language engineering, 2(2):161-187.", |
| "links": null |
| }, |
| "BIBREF20": { |
| "ref_id": "b20", |
| "title": "Conceptual Modeling of Information Systems", |
| "authors": [ |
| { |
| "first": "Antoni", |
| "middle": [], |
| "last": "Oliv\u00e9", |
| "suffix": "" |
| } |
| ], |
| "year": 2007, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Antoni Oliv\u00e9. 2007. Conceptual Modeling of Informa- tion Systems. Springer-Verlag, Berlin, Heidelberg.", |
| "links": null |
| }, |
| "BIBREF21": { |
| "ref_id": "b21", |
| "title": "Unified modelling language", |
| "authors": [ |
| { |
| "first": "O'", |
| "middle": [], |
| "last": "Gerard", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Regan", |
| "suffix": "" |
| } |
| ], |
| "year": 2017, |
| "venue": "Concise Guide to Software Engineering", |
| "volume": "", |
| "issue": "", |
| "pages": "225--238", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Gerard O'Regan. 2017. Unified modelling language. In Concise Guide to Software Engineering, pages 225-238. Springer.", |
| "links": null |
| }, |
| "BIBREF22": { |
| "ref_id": "b22", |
| "title": "Prolog and natural-language analysis", |
| "authors": [ |
| { |
| "first": "C", |
| "middle": [ |
| "N" |
| ], |
| "last": "Fernando", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Pereira", |
| "suffix": "" |
| }, |
| { |
| "first": "M", |
| "middle": [], |
| "last": "Stuart", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Shieber", |
| "suffix": "" |
| } |
| ], |
| "year": 2002, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Fernando CN Pereira and Stuart M Shieber. 2002. Pro- log and natural-language analysis. Microtome Pub- lishing.", |
| "links": null |
| }, |
| "BIBREF23": { |
| "ref_id": "b23", |
| "title": "CASE Method: Entity Relationship Modelling", |
| "authors": [ |
| { |
| "first": "", |
| "middle": [], |
| "last": "Barker Richard", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Barker Richard. 1990. CASE Method: Entity Relation- ship Modelling. Addition-Wesley Publishing Com- pany, ORACLE Corporation UK Limited.", |
| "links": null |
| }, |
| "BIBREF24": { |
| "ref_id": "b24", |
| "title": "Software development process from natural language specification", |
| "authors": [ |
| { |
| "first": "Motoshi", |
| "middle": [], |
| "last": "Saeki", |
| "suffix": "" |
| }, |
| { |
| "first": "Hisayuki", |
| "middle": [], |
| "last": "Horai", |
| "suffix": "" |
| }, |
| { |
| "first": "Hajime", |
| "middle": [], |
| "last": "Enomoto", |
| "suffix": "" |
| } |
| ], |
| "year": 1989, |
| "venue": "11th International Conference on Software Engineering", |
| "volume": "", |
| "issue": "", |
| "pages": "64--73", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Motoshi Saeki, Hisayuki Horai, and Hajime Enomoto. 1989. Software development process from natu- ral language specification. In 11th International Conference on Software Engineering, pages 64-73. IEEE.", |
| "links": null |
| }, |
| "BIBREF25": { |
| "ref_id": "b25", |
| "title": "Controlled natural languages for knowledge representation", |
| "authors": [ |
| { |
| "first": "Rolf", |
| "middle": [], |
| "last": "Schwitter", |
| "suffix": "" |
| } |
| ], |
| "year": 2010, |
| "venue": "Proceedings of the 23rd International Conference on Computational Linguistics: Posters", |
| "volume": "", |
| "issue": "", |
| "pages": "1113--1121", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Rolf Schwitter. 2010. Controlled natural languages for knowledge representation. In Proceedings of the 23rd International Conference on Computational Linguistics: Posters, pages 1113-1121. Association for Computational Linguistics.", |
| "links": null |
| }, |
| "BIBREF26": { |
| "ref_id": "b26", |
| "title": "Entity Relationship Model", |
| "authors": [ |
| { |
| "first": "Yeol", |
| "middle": [], |
| "last": "Il", |
| "suffix": "" |
| }, |
| { |
| "first": "Peter", |
| "middle": [ |
| "P" |
| ], |
| "last": "Song", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Chen", |
| "suffix": "" |
| } |
| ], |
| "year": 2009, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "1003--1009", |
| "other_ids": { |
| "DOI": [ |
| "10.1007/978-0-387-39940-9_148" |
| ] |
| }, |
| "num": null, |
| "urls": [], |
| "raw_text": "Il-Yeol Song and Peter P. Chen. 2009. Entity Relation- ship Model, pages 1003-1009. Springer US, Boston, MA.", |
| "links": null |
| }, |
| "BIBREF27": { |
| "ref_id": "b27", |
| "title": "How are conceptual models used in industrial software development?: A descriptive survey", |
| "authors": [ |
| { |
| "first": "Harald", |
| "middle": [], |
| "last": "St\u00f6rrle", |
| "suffix": "" |
| } |
| ], |
| "year": 2017, |
| "venue": "Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering", |
| "volume": "", |
| "issue": "", |
| "pages": "160--169", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Harald St\u00f6rrle. 2017. How are conceptual models used in industrial software development?: A descriptive survey. In Proceedings of the 21st International Conference on Evaluation and Assessment in Soft- ware Engineering, pages 160-169. ACM.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "num": null, |
| "uris": null, |
| "text": "Figure 2: ERM constructs", |
| "type_str": "figure" |
| }, |
| "FIGREF1": { |
| "num": null, |
| "uris": null, |
| "text": "Grammar rules for relationship declaration % Input: Student is enrolled in program. % Output: [entity(A, student), relation(A, B, is_enrolled_in), entity(B, program)] s([mode:M, type:fact, sem:L1-L3]) --> np([mode:M, num:N, type:fact, pos:subj, arg:X, sem:L1-L2]), vp([mode:M, num:N, type:fact, arg:X, sem:L2-L3]), ['.']. vp([mode:M, num:N, type:fact, arg:X, sem:L1-L3])--> verb([mode:M, num:N, type:fact, arg:X, arg:Y, sem:L1-L2]), np([mode:M, num:_N, type:fact, pos:obj, arg:Y, sem:L2-L3]). np([mode:M, num:N, type:T, pos:P, arg:X, sem:L1-L2) --> noun([mode:M, num:N, type:T, pos:P, arg:X, sem:L1-L2]). noun([mode:proc, num:N, type:fact, pos:P, arg:X, sem:[L1|L2]-[[L0|L1]|L2]]) --> {lexicon([cat:noun, wform:WForm, num:N, type:entity, pos:P, arg:X, sem:L0])}, WForm. noun([mode:gen, num:N, type:fact, pos:P, arg:X, sem:[[L0|L1]|L2]-[L1|L2]]) --> {lexicon([cat:noun, wform:WForm, num:N, type:entity, pos:P, arg:X, sem:L0])}, WForm. verb([mode:proc, num:N, type:fact, arg:X, arg:Y, sem:[L1|L2]-[[L0|L1]|L2]]) --> lexical_rule([cat:verb, num:N, arg:X, arg:Y, sem:L0]). verb([mode:gen, num:N, type:fact, arg:X, arg:Y, sem:[[L0|L1]|L2]-[L1|L2]])--> {lexicon([cat:verb, wform:WForm, num:N, type:brel, arg:X, arg:Y, sem:L0])}, WForm.", |
| "type_str": "figure" |
| }, |
| "FIGREF2": { |
| "num": null, |
| "uris": null, |
| "text": "Grammar rules for associative entity declaration % Fact Type \"Association\" % Input:Enrolment associates \"student is enrolled in program\". % Output: [entity(A, enrollment), associates(A, B), entity(C, student),% B#relation(C, D, is_enrolled_in), entity(D, program)] s([mode:M, type:fact_ob, sem:L1-L4]) --> np([mode:M, num:N, type:fact, pos:subj, arg:X, sem:L1-L2]), verb([mode:M, wform:[associates], num:N, type:fact_ob, arg:X, arg:R, sem:L2-L3]), ['\"'], s([mode:M, type:ob_fact, rel:R, sem:L3-L4]), ['\"', '.']. np([mode:M, num:N, type:T, pos:P, arg:X, sem:L1-L2) --> noun([mode:M, num:N, type:T, pos:P, arg:X, sem:L1-L2]). noun([mode:proc, num:N, type:fact, pos:P, arg:X, sem:[L1|L2]-[[L0|L1]|L2]]) --> {lexicon([cat:noun, wform:WForm, num:N, type:entity, pos:P, arg:X, sem:L0])}, WForm. noun([mode:gen, num:N, type:fact, pos:P, arg:X, sem:[[L0|L1]|L2]-[L1|L2]]) --> {lexicon([cat:noun, wform:WForm, num:N, type:entity, pos:P, arg:X, sem:L0])}, WForm. verb([mode:proc, wform:WForm, num:N, type:fact_ob, arg:X, arg:Y, sem:[L1|L2]-[[L0|L1]|L2]]) --> {lexicon([cat:verb, wform:WForm, num:N, type:ob_rel, arg:X, arg:Y, sem:L0])}, WForm. verb([mode:gen, wform:WForm, num:N, type:fact_ob, arg:X, arg:Y, sem:[[L0|L1]|L2]-[L1|L2]]) --> {lexicon([cat:verb, wform:WForm, num:N, type:ob_rel, arg:X, arg:Y, sem:L0])}, WForm.", |
| "type_str": "figure" |
| }, |
| "FIGREF3": { |
| "num": null, |
| "uris": null, |
| "text": "RuleML JSON representation of the sentence (22) from table [1].", |
| "type_str": "figure" |
| }, |
| "TABREF0": { |
| "html": null, |
| "num": null, |
| "type_str": "table", |
| "text": "Entity Declaration 1. Student is an entity type. 2. Department is an entity type. 3. Course is an entity type. 4. Teacher is an entity type. 5. Enrolment is an entity type. 6. Section is an entity type. Student id is of integer data type. 8. Student name is of string data type. 9. Department number is of integer data type. 10. Department name is of string data type. 11. Teacher id is of integer data type. 12. Teacher name is of string data type. 13. Course id is of integer data type. 14. Course name is of string data type. 15. Enrolment semester is of integer data type. 16. Enrolment grade is of integer data type. 17. Section id is of integer data type. 18. Section name is of string data type. Declaration 19. Student belongs to department. 20. Department contains student. 21. Teacher works in department. 22. Department employs teacher. 23. Course is offered by department. 24. Department offers course. 25. Course is offered in sections. 26. Teacher teaches students in course. 27. Enrolment associates \"Teacher teaches students in course\".", |
| "content": "<table><tr><td>Attribute Declaration</td></tr><tr><td>7. Relationship Constraint Declaration</td></tr><tr><td>28. Every student belongs to exactly 1 department.</td></tr><tr><td>29. Every department contains 1 or more students.</td></tr><tr><td>30. Every teacher works in exactly 1 department.</td></tr><tr><td>31. Every department employs 1 or more teachers.</td></tr><tr><td>32. Every course is offered by exactly 1 department.</td></tr><tr><td>33. Every department offers 1 or more courses.</td></tr><tr><td>34. Every enrolment includes exactly 1 teacher.</td></tr><tr><td>35. Every enrolment includes exactly 1 student.</td></tr><tr><td>36. Every enrolment includes exactly 1 course.</td></tr><tr><td>37. Every student owns exactly 1 student id and owns</td></tr><tr><td>exactly 1 student name.</td></tr><tr><td>38. Every teacher owns exactly 1 teacher id and owns</td></tr><tr><td>exactly 1 teacher name.</td></tr><tr><td>39. Every course owns exactly 1 course id and owns</td></tr><tr><td>exactly 1 course name.</td></tr><tr><td>40. Every department owns exactly 1 department</td></tr><tr><td>number and owns exactly 1 department name.</td></tr><tr><td>41. Every enrolment consists of exactly 1 enrolment</td></tr><tr><td>semester and consists of exactly 1 enrolment</td></tr><tr><td>grade.</td></tr><tr><td>42. Every section is dependent of exactly 1 course.</td></tr></table>" |
| }, |
| "TABREF1": { |
| "html": null, |
| "num": null, |
| "type_str": "table", |
| "text": "Extended example scenario from the ER paper(Frantiska, 2018) expressed using CNL ER Listing 1: Grammar rules for entity declaration % Input: Student is an entity. % Output: entity(A, student) s([mode:M, type:entity, sem:L1-L2]) --> np([mode:M, num:sg, type:entity, pos:subj, sem:L1-L2]), [is, an, entity, type], ['.'].", |
| "content": "<table><tr><td>np([mode:M, num:N, type:T, pos:P, sem:L1-L2]) --></td></tr><tr><td>noun([mode:M, num:N, type:T, pos:P, sem:L1-L2]).</td></tr><tr><td>noun([mode:proc, num:N, type:entity, pos:P, sem:[L1|L2]-[[L0|L1]|L2]]) --></td></tr><tr><td>lexical_rule([cat:noun, num:N, type:entity, pos:P, sem:L0]).</td></tr><tr><td>noun([mode:gen, num:N, type:entity, pos:P, sem:[[L0|L1]|L2]-[L1|L2]]) --></td></tr><tr><td>{lexicon([cat:noun, wform:WForm, num:N, type:entity, pos:P, arg:_X, sem:L0])},</td></tr><tr><td>WForm.</td></tr></table>" |
| } |
| } |
| } |
| } |
