Fluent Editor™ 2015 Help

Thank you for choosing Fluent Editor 2015. Below you will find basic information about this product.

  1. Introduction
  2. Creating a Project
  3. Setting a proxy
  4. Taxonomy Tree
  5. Reference Explorer
  6. Annotation Window
  7. XML Preview Window
  8. CNL Editor Window
  9. Reasoner
  10. Materialization
  11. Working with OWL2 profiles
  12. SPARQL Window
  13. SWRL Built-ins
  14. CNL Diagram
  15. SWRL Debugger
  16. Active Rules
  17. R Plugins and R Output Window
  18. Importing OWL/RDF Ontologies
  19. Referencing External Ontologies
  20. Exporting CNL Document
  21. Ontorion Mode
  22. Interoperability with Protege
  23. Useful Annotations
  24. Using Auto Recovery



Fluent Editor 2015 is an updated and improved version of our previous product, FluentEditor for OWL. In this version we have introduced many changes that will simplify the usage and accessibility of the FluentEditor for our Clients. Fluent Editor 2015 is a comprehensive tool for editing and manipulating complex ontologies that uses Controlled Natural Language. Fluent editor provides one with a more suitable for human users alternative to XML-based OWL editors. It's main feature is the usage of Controlled English as a knowledge modeling language. Supported via Predictive Editor, it prohibits one from entering any sentence that is grammatically or morphologically incorrect and actively helps the user during sentence writing. The Controlled English is a subset of English with restricted grammar and vocabulary in order to reduce the ambiguity and complexity of the language.

Creating a Project

To create a new project, click File menu and then click New on the left side. Then you will have a possibility to either create a new project or open an existing one. There are two model templates that can be used as an example of project structure and one model template that can be used as an example of simple ontology for IT Infrastructure.

Moreover, you can search for an online template and use it.

Setting a proxy

To set an HTTP proxy that will be used by Fluent Editor for all internet connections (for downloading references, the R plugin,...) you need to go to File -> Options -> Proxy

proxy option windows

In this window you have a checkbox 'Use proxy' on top to enable the proxy (by default it is disabled). Once enabled, you can choose whether to use the default system proxy (the one you configured using your browser) or to connect to a specific proxy.

For all proxy options, you can define a username and password that will be used to authenticate to the proxy. If no credentials are defined, your default windows credentials will be used (if authentication is needed).

proxy option windows filled

Taxonomy Tree

Taxonomy tree is displayed for each OWL file being edited and is built upon data from this OWL file and all included ontologies. Selecting element on the Taxonomy tree will filter all expressions in CNL Editor window to those, which are related explicitly to the selected phrase.

Taxonomy tree is divided into four parts:

  • thing:
    shows "is-a" relations between concepts and instances.
  • nothing:
    shows concepts that cannot have instances.
  • relation:
    shows hierarchy of relations between concepts and/or instances.
  • attribute:
    shows hierarchy of attributes.

To show Taxonomy Reasoning with implicit knowledge, click selected button on the left side of the Taxonomy Tree window.

In Ontorion mode, the taxonomy tree is replaced by the Remote taxonomy browser taking entities directly from Ontorion.

Reference Explorer

Reference Explorer shows all the elements in the references. It retrieves the full list of Concepts, Instances, Roles, and Data Attributes from direct references on your CNL ontology as well as from references which the direct ones hold. To open it, press 'Reference Explorer' button on Tools tab.

Then Reference Explorer window will show up on the right side and retrive references defined on your ontology.

Annotation Window

Annotation window shows annotations from both the current file loaded in the editor and the referenced ontologies (if reference exists in the current file) about the user-selected element on CNL window.
Each annotation will be displayed along with its full annotation properties in top left part of the annotation window.

In order to use this window, first click 'Annotations' on the right of the Fluent Editor window.

By clicking on an element defined in a referenced file (in this case "has-author"), the OWL annotation for the selected element will be displayed in Annotation window. If no annotations associated with this element exist, Annotation window will remain blank.
In Annotation window, the type of the selected element will be displayed in parenthesis '()'. Four types are defined : Concepts, Roles, Instances and CNL-keyword.   

It is also possible to select the language in which annotations are written and display only those in that particular language.

To add annotations in a language which is not present in the current ontology or in referenced ontologies, first click the Add button and add a language to the list:

Once you add a new language, you will find the selected language in the combobox on top is automatically changed to the one you just added. This language will stay listed so that you can select it for writing annotations for other elements in the ontology.
Having the desired language selected in the combobox, start writing in the textbox under the type of the annotation you want to add.

Then hitting 'enter' key will save the annotation to the selected element. The annotation will be saved only if not empty.

A couple of remarks:

Annotations from external sources are read-only. If one such annotation is tried to be edited the following warning will pop-up:


XML Preview Window

XML Preview window shows the converted form of the user-selected CNL sentence into XML as a preview.
To open this window, click XML Preview on Home>Tools  ribbon.

After opening the XML Preview window, click a CNL setence of which you would like to see the preview of the conversion.
XML preview is available in two modes : OWL/XML and RDF/XML.

CNL Editor Window

CNL Editor window is the main part of FluentEditor where you can actually view and edit ontology files. It shows all the CNL phrases, both from the edited file and from the reference ontologies, that correspond to every OWL statement.  You can click on any phrase from the edited OWL file to modify it, or can also add new phrases.

Entering Sentences

When you start typing words in the CNL Editor window, FluentEditor will automatically help you in several ways:

 CNL Window

You can also open the CNL hint box by entering a blank line and clicking Intelisense button, or by using Ctrl + Space shortcut.

Home menu has all of the basic options available in Microsoft Word, such as Replace, Paste, Format Painter etc. What is more, it has Modal and Complex Expressions buttons that provide the user with a possibility of choosing if he wants to use modal verbs or complex, experimental expressions.

One of the newest features of Fluent Editor 2015 is that, on the left-hand side of the bottom of the window, each CNL statement can be shown in a DL(Discription Logic) format. For the CNL sentence you select by placing the cursor on it, Fluent Editor will convert the selected sentence into the DL and and display it as below.
Morever, when you click the DL sentence you can copy it, so that you can paste it somewhere just as using copy&paste function.  

After writing your ontology, you can reformat selected lines or entire lines by clicking Reformat button or Ctrl+U after selecting the sentences.  Reformat performs parsing and serializing CNLs which results in cleaning up the sentences briefly according to the English grammar. For example, if you reformat this CNL "If something is cat then it is a animal."  you will get "If something is a cat then it is an animal." 

To use a more advanced feature, press Ctrl+D. This performs a deep parsing of CNL in sequence of [CNL->DL->CNL], as well as CNL serialization. It converts CNLs into its canonical form which may even lead to simplification of the sentences.
For example, if you convert the identical CNL above, you will get "Every cat is an animal.".

Using Modal Expressions

Modal Expressions is an advanced feature that allows user to express "knowledge about the knowledge" with CNL. This is usefull when running deployment with Ontorion server as a knowledge database to enforce fulfilling several properties of lidesc the knowledge. They do not have direct representation with OWL.

There are six modal words that can be used:

To enable modal expressions click Modal Expressions button on Expressiveness tab on the Home ribbon.

After enabling modal expressions, you will find modal words appearing on Hint box as below.

Modal expressions are a nice way to express requirements for the knowledge. We express a requirement that every application must be-hosted-on a server:

X is-hosted-on Y if-and-only-if Y hosts X.
Every application must be-hosted-on server.

The ontology (or its part) is validated, e.g. before committing changes to the knowledge server. Fluent Editor has built-in validator for the ontology being edited. To perform validation, click green tick on the left side of the query statement.

Validating the below example will show these results:

Ontology (validated):
Comment: 'Sample IT ontology'.

Server-1 is a server and hosts Application-1.
Server-2 is a server and hosts Application-2.

Application-1 is an application that serves Customer-1 and serves Customer-2.
Application-3 is an application that serves Customer-3.

Customer-1 is a customer and has-severity critical.
Customer-2 is a customer and has-severity medium.
Customer-3 is a customer and has-severity low.

X is-hosted-on Y if-and-only-if Y hosts X.
Every application must be-hosted-on server.

All instances that were subject to validation (Modal expressions with “must”, “can”, “should”, "must-not", "can-not", or "should-not" – they differ by the interpretation by the end-user application. Fluent Editor differentiate them by color of the warning) are highlighted. Green means all requirements are fulfilled. Red means some requirements are not fulfilled. Yellow means warning. It appears when requirements with “should” expression is not fulfilled. Light yellow means there is nothing wrong but it is marked just for informing the users. For example, regarding the statement Every man can have a wife. - there is nothing wrong if there is some man that does not have a wife.
For each modal expression different colors will appear as below:


End-user application may forbid committing changes to the database, when some requirements are not met.

In the above example:

 You can check exactly which modal expressions are not fulfilled for the instances by clicking a small button appeared under the instance names as below.

When you click it, it displays the list of modal expressions which are not fulfilled for the selected instance.

To fulfill our requirement we shall express somehow that Application-3 is hosted on some server, e.g.:

Application-3 is-hosted-on Server-2.


Server-2 hosts Application-3.

or even indirectly (with SWRL rules in this particular example):

If X hosts something that contains Y then X hosts Y.

Group-A contains Application-3.
Server-2 hosts Group-A.

After correction and validation, all is highlighted in green:

Ontology (validated):
Comment: 'Sample IT ontology'.

Server-1 is a server and hosts Application-1.
Server-2 is a server and hosts Application-2.

Application-1 is an application that serves Customer-1 and serves Customer-2.
Application-3 is an application that serves Customer-3.

Customer-1 is a customer and has-severity critical.
Customer-2 is a customer and has-severity medium.
Customer-3 is a customer and has-severity low.

X is-hosted-on Y if-and-only-if Y hosts X.
Every application must be-hosted-on server.
Server-2 hosts Application-3.

If you want to erase highlights on your window, press eraser button on the Home ribbon.


Using Complex Expressions

Complex Expressions is an experimental feature that allows users to build complex, more expressive sentences, that can be expresses as well with several simple sentences. This feature is using concepts like ValuePartition, DisjointConcepts, HasKey.

To enable complex expressions click Complex Expressions button on Expressiveness tab on the Home ribbon.

Then you can find the new expressions appearing on Hint box, such as the keyword Something and Anything.

Samples of complex expressions:

Something is a human if-and-only-if-it-either is a man or is a woman.

Anything either is a cat or is a dog or is a human or-something-else.


FE questions to ontology are submitted to Reasoner (HermiT). At the bottom you can enable a reasoner interface that is dedicated to ask questions regarding ontology written (or opened) in FE. The answers are shown into three panels corresponding to three kinds of sentences.

History of the queries you entered on Reasoner window will be saved. You can view it as below by pressing 'Down' key (↓) on your keyboard. Besides, you can pin the queries to make them visible on top of the list by clicking 'Pin' icon on the right side of each query row.

If you want to erase the history, go to File > Options > General, click 'Clear History of CNL Queries' button and click 'Apply' on the bottom. This deletes the history of queries you entered on both Reasoner window and Materialized Graph window.


The materialized ontology contains all the reasoned relations between entities deducted from currently loaded ontology. Materialization is performed by tandem of the Reasoner (HermiT) and Rule Engine(Jena), and can be done in two modes: OWL-DL (Full) and OWL2 RL+ profile (Hybrid). The materialization is performed with the following steps:

  1. TBox:
    1. calculate the taxonomy of concepts and relations

  2. ABox:
    1. assign all instances to concepts
    2. calculate innerinstance relations
    3. calculate values of attributes for all instances

In case of OWL-DL (Full) materialization, all the calculations are performed by the Reasoner (Hermit). This always gives the sound and complete results, however it may suffer from computational complexity of the underlying, tableau based [Horrocks, Kutz, Sattler 2006] reasoner for the SROIQ description logic.

Fluent Editor allows to use incomplete, but fast, OWL2 RL+ profile (Hybrid) materialization mode. In Hybrid mode TBox (1) is also calculated using the Reasoner, however ABox (2) are calculated by applying OWL RL rules by fast, forward chaining, rule engine that implements RETE algorithm [Forgy 1979]. This rule engine is implemented Jena with RL specific RuleSet. It allows for fast calculation when we deal with large ontology. It is limited in terms of complexity to OWL RL profile. This limitation in expressivity has impact on ABox only.

When is the OWL2 RL+ profile (Hybrid) materialization expected not to reproduce all the results given by OWL-DL (Full) materialization? You should check if the sentence in your ontology are contained within OWL2 RL+ profile profile - it can be done by clicking Validate RL+. If any sentence is outside the profile, theoretically results may be incomplete. However, it is not always the case. Thanks to the clever combination of full and fast reasoning, the materialized ontology will be most probably correct in most user-defined ontologies.

Additionally Fluent Editor supports OWL2 EL++ profile fro materialization. Every time any materialization is performed, the ontology is validated for being within OWL2 EL++. If so, special ELK reasoning is used instead of HermiT reasoner. It allows for faster reasoning. Using OWL2-EL++ is automated in Fluent Editor. However, you can always check if your ontology is valid with OWL2 EL++ profile by clicking "Validate EL++" button.

CNL Queries to Materialized Ontology

Materlized Graph window allows the user to perform CNL queries both to a database in Ontorion Server (when in Ontorion mode) or to the materialized ontology (see Materlilization) The result can be copied to the clipboard from the resulting table right clicking over the selected rows in the control, this content can be pasted to any spreadsheet software such as Excel.

As mentioned above, materialization is performed in one of two modes : OWL-DL and OWL-RL+. By default the mode is set to OWL-RL+. To change it, click a combo box on the ribbon in Home tab> Expressiveness menu as shown below and select the mode you want. The mode set with the toggle buttons affects both materialized graph and SPARQL.

In OWL-RL+ mode, if there are sentences that are not contained within OWL2 RL+ profile a warning message will pop up.

History of the queries you entered on Materialized Graph window will be saved. You can manipulate it in the same way as for the queries on Reasoner Window.

Warning messages of CNL sentences can be turned off permanently. Just go to File > Options > Reasoners and untick Show warning when materialization graph may be incomplete.

Working with OWL2 profiles

OWL2 (the standard underlying our custom Controlled Natural Language) is a language with great expressive power. It makes reasoning and materialization a time-consuming task. On the contrary, quite often existing ontologies use only a specific subset of OWL2 statements. Therefore three OWL2 profiles have been defined: OWL2-RL, OWL2-EL and OWL2-QL. If you want to use such a profile, you have to restrict your ontology to some very specific types of sentences. In exchange for using less expressive language you will gain an increase of reasoner performance. Quite often the reasoning is done in polynomial time with respect to the number of facts in the ontology or the size of the ontology.

The image below explains the relations between various sublanguages.

Validating OWL2 profiles

By clicking "Validate RL" button, you can check which sentences violate OWL2 RL and which are within the profile. There are three possible outcomes of validation. Each outcome is highlighted appropriately.

To validate OWL2 RL mode click Validate RL button on Expressiveness tab on the Home ribbon.

By clicking "Validate RL+" button, you can check which sentences violate RL+ and which are within the profile. OWL2 RL+ is Fluent Editor custom extension of OWL2 RL profile allowing for efficient materialization. There are three possible outcomes of validation. Each outcome is highlighted appropriately.

To validate OWL2 RL+ mode click Validate OWL2 RL+ button on Expressiveness tab on the Home ribbon.

By clicking "Validate EL++" button, you can check which sentences violate EL++ and which are within the profile. There are three possible outcomes of validation. Each outcome is highlighted appropriately.

To validate OWL2 EL++ mode click Validate OWL2 EL++ button on Expressiveness tab on the Home ribbon.

To erase the highlights click rubber (eraser) button on Font tab on the Home ribbon.

Using OWL2 RL+ mode

OWL2 RL+ mode is a feature that allows the user to have better control of how fast the materialization works and to determine bottlenecks of the ontology.

The CNL and corresponding OWL2 (Web Ontology Language) are highly expressive. You can easily write complex rules, so that the reasoner will automatically infer additional knowledge. However, reasoning in ontologies can be computationally complex (NP-hard). If there are too many rules in the ontology, it can take for reasoner extremely long to process all the connections between data. Therefore various sublanguages of OWL2 were defined, which guarantee to have better performance. This is done in exchange for expressiveness. You restrict yourself not to use certain types of sentences, that make reasoning harder. One of such sublanguages is OWL2 RL. [OWL2 RL standard specification].

OWL2 RL+ profile is FluendEditor's custom profile. It is a little bit more than OWL RL. All sentences which are within OWL2 RL profile are also within OWL2 RL+ profile. There are also some extra types of sentences included.

Note that modal expressions are an advanced feature of CNL and do not have direct representation with OWL2. Therefore, they by default are not a part of OWL2 RL sublanguage. However, modal sentences are not expected to slow down the reasoning substantially. Therefore modal sentences are included in custom OWL2 RL+ profile.

Semantic Web Rule Language allows to introduce SWRL rules [SWRL standard specification]. In CNL they are represented by sentences of the form "If... then ...". SWRL rules are also not part of OWL2 and therefore are not part of OWL2 RL. However, some SWRL sentences are not expected to slow down the reasoning process substantially, so the user should not be discouraged from using them. Such SWRL sentences are included in custom OWL2 RL+ profile. Still, there might be some SWRL sentences which will make the reasoning harder. Such SWRL sentences are excluded from the OWL2 RL+ profile.

You can always check if your ontology is valid with OWL2 RL+ profile by clicking "Validate RL+" button.

Instead of choosing OWL2-RL+ profile you can choose OWL-DL. Thus you will ensure complete results for ontologies violating OWL2-RL+ profile in exchange for time performance. You can switch the options with OWL2 RL+/OWL2 DL toggle buttons.

Using OWL2 EL++ mode

Fluent Editor supports OWL2 EL++ profile. Every time any reasoning or materialization is performed, the ontology is validated for being within OWL2 EL++. If so, special ELK reasoning is used. It allows for faster reasoning. Using OWL2-EL++ is automated in Fluent Editor. However, you can always check if your ontology is valid with OWL2 EL++ profile by clicking "Validate EL++" button.


SPARQL window allows users to perform SPARQL queries both to a database in Ontorion Server (when in Ontorion mode) or to the materialized ontology (see Materialization) The result can be copied to the clipboard from the resulting table right clicking over the selected rows in the control, this content can be pasted to any spreadsheet software as Excel.

When in Ontorion mode (see Ontorion Mode), the SPARQL window will also reflect this change indicating the new querying location:

SPARQL queries are performed in one of two modes : OWL-DL and OWL-RL+. By default the mode is set to OWL-RL+. To change it, click a combo box on the ribbon in Home tab > Expressiveness menu as shown below and select the mode you want. Note that the mode set in this combo box affects both materialized graph and SPARQL.

Managing SPARQL Queries

If the entered SPARQL query is something you frequently use, you can save it by clicking 'Save' button. Saved queries can be viewed and re-used by clicking 'Saved queries..' button.

After clicking 'Saved queries..', SPARQL Query Manager window will pop up as below which shows the list of saved queries as well as a preview of the selected query. You can also select one query from the list and directly execute it by clicking 'Execute query' button.

If you want you delete all the saved SPARQL queries, go to File > Options > General, click 'Delete all saved Sparql Queries' button and click 'Apply' on the bottom.

Example of SPARQL Queries

To properly query SPARQL on your ontology, the names of your concepts, individuals and relations are not enough. You will also need to know the namespace that identifies your entities. If you are not sure what it is exactly, you can just query SPARQL about all available statements and check it out.


Now you can define a namespace (to make further part of the query shorter) and ask a query. Without the prefixes the query would have < http://uri.net#Craig > instead of ab:Craig . In the question you define the variable ?x (all variables start with a question mark) that satisfies the condition: it must be something that Craig has as an e-mail. You can see, there are two possible answers. Please note the change of the convention for naming. has-email changes to hasEmail (see here for the naming convention).


You can ask more complex queries, for example ask everything what is known about Craig (below). Note that here you use an extra variable ?p, which is not displayed in the results.


SPARQL is a well-established standard. For further learning please refer to external tutorials such as [Apache Jena - SPARQL Tutorial] or [SPARQL by Example - Cambridge Semantics].


SWRL Built-ins

Fluent Editor supports a number of core SWRL built-ins defined by the SWRL Submission, covering built-Ins for comparisons, math, strings, date, time and duration. To learn how to apply them into your ontology further, go to the Grammar page.

One thing to note is that currently the Reasoner 'HermiT' does not support SWRL built-ins. Therefore, reasoning on ontology including built-ins will not retrieve full results and show you this warning message.

So in order to get the complete results, ask on Materialized Graph...

... or on SPARQL...

You can also run SWRL Debugger to retrieve the entire SWRL rules and related entities.


CNL Diagram

CNL diagram can be drawn out of the currently opened CNL ontology. To do this, simply click 'CNL Diagram' button on Tools tab.

As shown below, CNL diagram will be drawn on a new window tab. Moreover, a new green tab 'Diagram' will appear on top which contains the interface to manipulate the diagram.

Each button on Diagram tab does as follows :

For example, if you click 'Materialize' button, the diagram will be redrawn based on the materialized graph.

Note that this materialization will be performed according to which mode you selected in Home tab, either OWL-RL+ or OWL-DL.

SWRL Debugger

SWRL Debugger shows a result of debugging SWRL rules in your ontology.  It performs materialization of the ontology, and based on the generated materialized graph SWRL Debugger displays all the SWRL rules and the relavant elements that are executed by the Rule Engine. Note that materialization in SWRL Debugger is performed only in OWL2-RL+ mode, and OWL-DL mode is not supported.
To debug SWRL rules, click 'Run Debugger' button on Tools tab.

If your ontology includes SWRL rules and there are elements that matches the rules' conditions, they will be displayed as below.

To open this SWRL Debugger window again after visiting other windows, click 'SWRL Debug' button on Tools tab. 


Active Rules

Active rules is the mechanism Fluent Editor provides for executing custom imperative code in C# upon meeting certain criteria described as SWRL rules. Likewise we provide some mechanism to deal with the nature of distributed enviroments through a set of core built-ins. Available functions to use in active rules are as follows:

As in SWRL Debugger, execution of Active Rules is based on materialization, which will be performed only in OWL2-RL+ mode, and OWL-DL mode is not supported.

To illustrate the use of Active Rules, we will use 'Simple IT with Active Rules' template on File > New.

As shown above, there are two active rules defined in this ontology. On the bottom there is one line 'Powernode-1 has-status Inoperable.'. With another line on 76 'Powernode-1 connects Server-1.', this matches the active rule 1. To execute it, click 'Run Active Rules' button.

After the execution of active rule 1, a new knowledge will be added on the bottom and 'Show Active Rules Output' window will show up with the messages.

To open this Active Rules Output window again after visiting other windows, click 'Active Rules' button on Tools tab. 

Since active rules are part of SWRL rules including C# code, you can also debug them with SWRL Debugger.  

R Plugins and R Output Window

Fluent Editor provides the capability of hosting a connection to an existing local R installation. This new feature comes in hand with the ROntorion package that is now available in Cognitum’s website. We provide an interface to code developed using the ROntorion package (see R Plugins development), bringing in turn the R plugins functionality to FluentEditor. Editing ontologies, plotting, and displaying strings from plugin’s results is available, empowering the user with an enhanced editing experience. The host handles all the hassles of installation and initialization of plugins; including dependency packages, provided they are part of an officially supported CRAN repository. The user should have R installed in the system though; if that is not the case, the following screen will pop-up:

And all R plugins will be greyed for the current Fluent Editor session. If you installed R after seen this screen you will have to restart Fluent Editor to test the new functionality. R can be downloaded from: www.r-project.org/.  All installed Plug-ins are listed under the Tools tab:

Plugins have access to the current content of the editor that is to be seized by the offered plugin functionality. Custom plugins can be developed following the guidelines of the R Plugins development help entry. By default two plugins are present in Fluent Editor: the Draw Ontology Graph plugin and the Enumerate Universe plugin.

Draw Ontology Graph

This plugin offers the user a visual overview of the ontology being developed by plotting the underlying graph structure.  To see this new feature in action, open an existing ontology and click the Draw Ontology Graph button

Once clicked, the rplugin mode will be enabled and in case the ROntorion package is not installed in any of the default paths of the R environment, the host will proceed to download the file from Cognitum's website. You will be promped by R for an installation path, it is your choice if install it only for the current system's user or in a system wide installation:

In case you answer yes in the Question window, you will be prompted to accept for the creation of a default path:


After all packages are installed, the changes will be reflected in the Fluent Editor visual interface:

The R Output window will display any textual results from the computation and the status icon in the status bar of Fluent Editor will show the state of the R engine computation. In this moment the request is being performed asynchronously. Once the results of the computation are ready, the graph will be displayed (in this case we are plotting showing the result for the African Wildlife template):

The results of the computation are in this particular case, both graphical and textual. The R output shows a message printed to the internally hosted R console device. Asynchronous updating of the console output is not yet supported; all contents of the device are dumped into the R Output once all R-side computing is finished.  The graph uses three distinct arrow colors to distinguish the different relations between any two literals in the ontology:

In this new release of Fluent Editor we have implemented our own graphical device that gets installed into the R Engine: this allows us to bring set of new features:

Enumerate Universe

Enumerate universe provides a textual enumeration of concepts and instances in the ontology, together with a description of all instances including a list of the concepts from which each instance inherits its properties from.  This plugin is also a sample of R editing functionality as shown in the screenshot below where the plugin has added a comment hightlighted in red to the current editor.

Importing OWL/RDF Ontologies

The CNL used inside FluentEditor is fully compatible with the OWL/RDF W3C standard. It is thus possible to import OWL/RDF ontologies from your computer or from the internet.

Importing Ontologies

In order to include an external ontology (from the Internet, or from another OWL file) in your project, you can use External menu which is located in the upper left corner of the FluentEditor.

OWL files from the project are identified by their URI, but are not located at this address. If you enter URI of local OWL file from the open project, FluentEditor will use its local copy.

For external OWL files from the Internet, FluentEditor will look for them at the URI address.

When you click Import item, in the middle of the screen will appear Enter the ontology URI box.

To import an OWL file, enter the ontology URI in the provided space and then click the Import button.

You can choose the OWL naming convention (the convention that is used in imported OWL) in the pull-down menu on the left. It is very important to chose the correct one in order to obtain correct wordings in CNL.

You have two possibilities to choose from:

Naming convention has impact when exporting back to OWL. After Smart-import and export you can not have the same OWL, while with the CamelCaseNames you will have exactly the same one.

Another option in this window is Import Ontology annotations as comments. By ticking this options, all the annotations about the ontology that you are importing will be included in FluentEditor as comments at the beginning of the file.

After clicking the "Import" button, the following dialog box will pop-up:

Import Strategy

During the import, FluentEditor will also download all the owl:imports inside the given ontology. In the current Fluent Editor import strategy we are first searching for the ontologies locally and then remotely. The steps done by Fluent Editor during import are in this order:

  1. In the current folder

  2. In all subfolders (from the current folder)

  3. Checking if the remote link is available

In each step we check for the base url (something/) or for the rdf file (something.rdf). When the import is finished, the ontology will be loaded in FluentEditor and you will see a section in the bottom of the file "References" that contains all the references inside the imported ontology (the standard namespaces: owl,rdf, rdf-schema,... are not listed here).

If the ontology to import has been imported correctly but some referenced ontologies have not been found, a message box will inform you of that and you will see a reference warning symbol on the bottom left corner of FluentEditor.

For further information about references, please check this section

Reference External Ontologies

It is possible to include external ontologies as references inside a CNL file. You can choose between references to OWL/RDF files or to CNL files. All references are listed at the end of the file in a References section. In this section you will find each reference written as: [FE-Nsp] 'Ont-Nsp' ('Ont-Loc'), where:

At least one between Ont-Nsp and Ont-Loc must be non empty, but it is possible to refer to an ontology by giving only the namespace or only the location.

Then in the file, you can refer to elements of this ontology by writing concept/role/attribute/instance[FE-Nsp]. Furthermore all imported files (CNL or OWL/RDF) and owl:import files content will be autocompleted after the import.

After adding new references, Fluent Editor automatically checks the validation of the reference and its operation status will be displayed on the bottom as below.

  •    :  Processing the reference validation.
  •                              :  All the references are valid.
  •           :  One or more of references are not valid.

  • Reference CNL Files

    To insert an CNL reference, enter the References menu, then click Insert reference from disk and select the CNL file you want to import. This file will be imported in Fluent Editor and all the elements defined in this file will be autocompleted.

    You can find an example of how to reference local CNL files by opening the Advanced IT example as you can see in this screenshot:

    Reference OWL Ontologies

    To insert an OWL reference, enter the References menu, then click Insert OWL Reference (for recently saved/used ontologies) or Insert reference from disk button and choose reference that you would like to use.

    You can validate each reference by clicking the button located at the end of the reference. And then click on Validate.

    After adding the valid reference, the knowledge that was written in the inserted reference will appear in the hint box.

    Note that in this version of Fluent Editor the CamelCase naming convention is used for referenced OWL ontologies.

    Using Smart Reference Mode

    Smart Reference Mode is an experimental feature. Using it allows you with referencing ontologies in CNL, even if the naming convention in those ontologies are not coherent with our FE rules. When you enable this smart reference mode, FE starts converting different naming conventions in the reference files into the SmartCase rule (For further details of rules, go here.)  we have in FluentEditor and users can directly browse and use all the entities existing in the references in SmartCase. This can be convenient for users while editing ontolgy with consistency of the naming style. 

    For instance, when you open Hintbox before enabling smart reference mode it would look as below, keeping CamelCase naming from the reference without conversion.....

    But after enabling it, Hintbox will display the same entities from reference in SmartCase format, which is a coherent form with FE naming convention.

    Moreover, if you export your ontology which includes these reference entities in SmartCase, the exported ontology will maintain the original naming convention so that the outcome keeps consistency between before and after using smart reference mode. 


    Exporting CNL Document to OWL, HTML or RDF

    When finished with creating a project, you can save your work as a HTML, OWL or RDF file. To do that, click on one of the given options in the Share  & Export submenu…

    …..or in the External menu with Export to OWL , Export to HTML or Export to RDF buttons.


    Exporting CNL Document to Cognitum Ontorion Server

    Ontorion is together with Fluent Editor, part of Cognitum's knowledge management programming framework. It is a distributed knowledge management system that uses the same CNL interface as Fluent Editor, being thus compatible with the same W3C standards of Fluent Editor (OWL, RDF and SWRL) plus SPARQL.

    Ontorion has a set of components equipped with algorithms that allows one to build large, scalable solutions for Semantic Web. The scalability is realized by both – noSQL, symmetric database and Ontology Modularization algorithm. Ontorion is a symmetric cluster of servers, able to perform reasoning on large ontologies. Every single Ontorion Node is able to make the same operations on data. It tries to get the minimal suitable ontology module (part) and perform the desirable task on it. Symmetry of Ontorion cluster provides the ability to run it in the “Computing Cloud” environment, where the total number of nodes can change from time to time, depending on the user needs.

    In Fluent Editor there is the possibility to export the CNL created to an Ontorion Server. This is done by either selecting Export to Ontorion in the Share & Export submenu....

    …..or in the External menu with the Export to Ontorion button.

    Then a window 'Connection to Ontorion' will appear as below.

    Here you have to choose the name of the Database that you want to create/modify in the Ontorion Server.

    There are two ways to connect to Ontorion: via an Ontorion WCF Service or directly through the Ontorion Server. In both cases an endpoint address it required and then it is possible to check if the Ontorion Server is available. At this point, by clicking 'Export' button, the whole ontology you have written in Fluent Editor will be exported to the server.


    Ontorion Mode

    It is possible to connect to Ontorion by going to the File -> Open & Import menu and click on the Connect to Ontorion button.

    You will then see a window similar to the one shown when clicking export to Ontorion in which you need to specify the Ontorion endpoint location, the user name and the password to connect with and the database to which you want to connect.

    The databases to which you can connect will be displayed as soon as you expand the Database combobox. As each user has different access to databases in Ontorion, you can see the databases in Ontorion only after you have entered the right endpoint, username and password.

    Ontorion endpoint should be a URI address to Ontorion Service. Connecting to Ontorion server via Ontorion Service provides secure service transactions between the user and the Ontorion server.

    When everything is set, click connect. After connecting to Ontorion, a new Ontorion tab will appear in the Ribbon and the window title you will get the informations about the current Ontorion connection...

    ... as well as 'Connected' message as below will be displayed on the bottom green bar.

    In the tab you will find all the buttons to manage the connection to Ontorion:

    Furthermore after connecting to Ontorion the Taxonomy tree will be replace with the Remote taxonomy browser...

     ... and a new Server tab will appear on the right.


    Ontorion Module Management

    When in Ontorion mode, it is possible to Save, Download, Refresh and Clear the module regarding the knowledge you are interested in. This is possible because in Ontorion a modularization algorithm has been implemented to efficiently modularize the knowledge stored into Ontorion.

    To download the module relative to entities in Ontorion there are three ways:

    To download the module from the Server window, just start typing in the Server window and the list of possible entities starting with the letters you have written will be autocompleted from Ontorion.

    When selecting the entity, it will be added to the current loaded module and the module for it will be downloaded from Ontorion (here you see an example of New-York).  As shown below, the entity name 'New-York', of which the module is loaded, will be displayed in a square button shape on the Server tab on the right. When you click it, it will highlight the corresponding module name on the CNL window on the left.

    Moreover, in the CNL window each entity will be written in different colors depending on its current status:

    Since the module of the entity 'New-York' is loaded, it is written in black text as well as it appears on the Server tab in a square button shape. The modules of other entities such as 'city', 'belongs-to',.. are not loaded so that they are written in gray text.

    Note that once FE disconnects with the Ontorion all the black text will be re-written in gray, which means all the loaded modules will be unloaded after disconnection.

    If you then click on the button under city for example, you will see the Add to module button. By clicking the button, the entity will be added to the module and if new sentences from knowledge base are needed to have the full module, they will be downloaded.

    When the module is loaded, you can modify the sentences directly in the editor and then clicking Save module, the current sentences are compared to the ones stored in Ontorion and the changes you have made will be displayed

    Here for example I changed the longitude of New-York. By clicking Save you will commit the current changes to Ontorion and the module will be again synced.

    Taxonomy Browsing

    When connected to Ontorion, it is possible to browse the taxonomy of the entire entities currently loaded in this database. To do this, just go to the Remote taxonomy tab and click on the arrow on the left of "thing". This will query Ontorion for the subconcepts of thing and they will be displayed as a taxonomy tree.

    In the Remote taxonomy we are showing entities with different colors depending on their current status:

    When the element is not synchronized, you can click in the arrow in the left of the element and the taxonomy will be build for this element (in this case I have clicked on the arrow in the left of "man")

    By right clicking on one of the elements in the taxonomy, you have the possibility to Add to module of to Show the Annotations for the current element.


    Multi-user Functionalities

    As more than one user can be connected to Ontorion at the same time, it is possible that the knowledge on which you are working can be outdated. In this case, you will see on the bottom left of Fluent Editor the icon telling you that some resync is needed

    In this case you just need to click the Refresh button in the Ontorion tab that will show you the sentences added from the other user to the module you have currently loaded (in this case someone added a new attribute for the instance Eli)

    By clicking Change, this sentence will be added to the knowledge currently loaded into Fluent Editor and you will be again synced with Ontorion.


    Interoperability with Protege

    Fluent Editor(FE) supports interoperability with Protege, which allows FE and Protege to communicate with each other for importing or exporting ontologies. Through this functionality, you can directly import an ontology file opened in Protege window into the FE window in CNL format simply by clicking a button, and vise versa. In the same mechanism, you can also export the opened CNL ontology in your FE to the Protege window, and the other way around.

    Initial Settings

    By default, the functionality of interoperability with Protege is disabled. In order to enable it, first you need to enable the Protege plug-in by the following steps.

    1. Click File Tab>Options. A options window will pop up.

    2. Click "Plug-ins" menu on the left side. You will see the setting menus for Protege as below.

    3. Here you need to set each option as follows :
      • Enable Protege Plug-in :  "Yes"

      • Port Number for Protege :  Set the port number in which you want to allow connection with the Protege application.  By default, it is set to 49152, but you can also change into any other available port in the range between 1 ~ 65535.

        • Note1. If the port you entered is already in use by some other application, FluentEditor will reject to apply it and ask you to enter an available one.

        • Note2. If you changed the port number, you need to restart both FluentEditor and Protege in order to refresh the operation of Protege plug-in.

      • Default Naming Convention :  Set the naming convention is the way in which FluentEditor will convert the received ontology from Protege. By default, it is set to "Smart". Descriptions about each naming option is here.

      • Protege Path :  Set the path to the Protege Desktop folder in your local computer. To download Protege Desktop, visit the official Protege website.

        • Note. For compatibility with the plug-in, your Protege version must be 4.3 or higher, and your Java version must be 7 or higher. However, if you are using Protege 4.3 make sure your Java version is 7 because Java 8 is not supported in Protege 4.3.  Otherwise, the Protege plug-in will not function.

      • Overwrite OWLAPI jar in Protege plugins folder : If this is checked, Fluent Editor will always ask you to overwrite OWLAPI jar in Protege plugins folder if they are not overwritten.
        If unchecked, Fluent Editor will not ask you again. 

    4. Below screenshot shows the example of settings.

    5. Click "Apply" button on the bottom. Now your are ready to use the Protege plug-in. As mentioned above, if you changed the port you need to restart both FluentEditor and Protege.

    Exporting/Importing Ontologies on FluentEditor

    To export your opened CNL ontology on FluentEditor to Protege, simply click External Tab>Export to Protege.

    Note.  If this is your first attempt to use Protege plug-in, Fluent Editor will attempt to install Protege plug-in and related .jar files. Before this process, it will also ask you via below pop-up window if Fluent Editor may modify the OWLAPI .jar on Protege. The modification of OWLAPI .jar will provide you convenience by keeping the order of ontology sentences you work with during interoperation with Protege. This is optional. Click 'Yes' to use this functionality, or 'No' to skip it.
    Whichever choice you make, Fluent Editor will proceed installation of necessary Protege plug-in. 


    Next, if your OS is Windows 8, you may see another pop-up window displayed by Windows User Access Control asking whether you will allow the program "CopyPluginToProtege.exe to make changes to this computer. This application is for installing the Protege plug-in on your given Protege path if it is not present. It also starts Protege application if it is not running. Select "Yes" to allow its execution.

    If Protege is not running, FluentEditor will run Protege first and send a command for exporting. If the exporting has been successfully done, FluendEditor will show you this popup message.

    And you can see the Protege window loaded with the ontology which you exported from FluentEditor.

     When Protege window is loaded with some ontolgy, you can also import it into your FluentEditor window by clicking the button "Import from Protege".

    Exporting/Importing Ontologies on Protege

    Exporting/Importing ontologies on Protege side works in the same way as it does on FluentEditor. If you succeeded in exporting or importing on FluentEditor as demonstrated above, it means that the Protege plug-in is successfully installed that you can utilize the same funtionality on Protege side as well. Protege will have two new buttons as shown below, the machanism of which is equivalent as those in FluentEditor. 


    Useful Annotations

    At the end of every hint box, there are useful annotations which allow you to:



    Using Auto Recovery

    Fluent Editor provides user with standard auto recovery functionality. If Fluent Editor crashes while you were working with unsaved files, you will be able to recover recent changes. FIles for autorecovery are autosaved every minute (60 seconds). Even unsaved documents are autosaved. If you start Fluent Editor after a crash, a list of files available for recovery will appear in an Autorecovery Pane on the left. If you choose to recover a file, it will open as a new unsaved document. It will not overwrite the original file. You can discard files for autorecovery by clicking Discard.