The paradigm of constructive-synthesizing modelling is based on the idea of the world as a collection of different structures. The development of constructive-synthesizing modelling provides an opportunity to automate the formation of structures. Automation possibilities depend on the degree of formalization and the quality of the corresponding models. In this work, the formalization of constructive-synthesizing models is enriched by the ontological representation of knowledge. This approach is demonstrated in the formation and display of geometric fractals. The developed models are implemented by software tools using Java and Apache Jena framework. It is possible to change the basic elements of fractals based on their ontological representation.
program model.
One of the important stages of the software life cycle is design, namely, the development of a
If software engineers, customers and users participate in the development of the model, then the
models can be represented using standardized languages, such as XML, Entity Relationship Diagram
(ERD), and others. They differ in the semantic richness. So far, several attempts have been made to
analyze and organize them [
Ontology is an explicit specification of conceptualization [
The authors previously modelled fractals using databases [
In this research the ontology is developed using the OWL Full language profile since the set of properties of data and objects overlap in the ontology.
We will adhere to the definition of a fractal as a set that has the property of self-similarity. These
structures are used e.g. to develop maps in computer games [
Many tools designed for developing computer games use fractals to form fragments of background textures of the Earth's surface and the plant world. This allows for significant reducing the amount of data to be stored while increasing the realism of images.
To use fractals in software development, there is a need to somehow represent them. One such
method is L-systems in JSXGRaph [
The JSXGRaph library is currently actively used, for example, in statistical analysis [
XML is also used for serialization domain-specific language the Fractal Architecture Description
Language (Fractal ADL) in the context of representing fractals [
To represent the restrictions for Fractal ADL, add-ons are developed [
From the point of view of semantic richness, the next logical step after XML is UML and ontology
models. Ontologies are actively used in the domains of transport, medicine, construction, etc.
However, the formalization of fractal models using ontologies is an underexplored area. A simple
example of using ontologies is the representation of fractals in RDF or JSON format. Here, RDF also
allows checking by the Shapes Constraint Language (SHACL) the data for compliance with the
developed Halcyon model pathology imaging analysis and feature management system [
Components of the "Fractal" system [
The GeoHilbert RDF dictionary [
The presented analysis shows that fractal structures are used in information systems and software i.e. representation models (languages) are being developed for fractals. It was determined that there is a need for methods of representing constraints for fractal systems. A logical way to represent constraints is an ontology. But at the moment, they are not fully used in the domain of fractal systems.
One of the examples of the use of description logic in the domain related to fractal structures is
the Collections ontology of data structures [
In the end, it is worth mentioning that usually, developers are dissatisfied with OWL Full
ontologies and try to "fix" them [
development. geometric fractals.
The purpose of the work is to improve constructive-synthesizing modelling by increasing formalization (enrichment of semantics) with the formal representation of knowledge by ontological means as soon as the more formalized the model, the more suitable it is for automating software
The work lays the foundation for such automation using the example of formal models of
To formalize the process of forming fractals, we will use the apparatus of constructive-synthesizing
modelling [
Let's consider the ontology of the medium and represent it using OWL Full (Figure 1). The set of terminals includes elements of two classes that correspond to the graphic representation of fractals: basic Line_type and Fractal are the constructed elements that have the property of self-similarity. The set of attributes of a terminal is determined by its belonging to a class. Line_type has derived classes: Curve, Ellipse, Line, Rectangle, Triangle. The individuals of Line_type class can be described with the property has_width. Rectangle individuals can be described using the property has_height.
The set of constructed elements (fractals) is determined by their class. The Fractal class is basic. Its individuals can be described using the following object properties: available constants (hasConstant) and variables (hasVariable), line type (hasLineType), and starting terminal (hasStart). Their domain is individuals of the corresponding Constant, Variable, and Line_type ontology classes. The Fractal class individuals can be described with the following data properties: the tilt angle when constructing the fractal image, and the number of iterations during construction.
Subclasses of Fractal are Dragon_curve, Koch_curve, Sierpinsky_triangle. The subclass implicitly defines the structure of a fractal, which is described by the substitution rules 1 → 2, where 1, 2 are forms that may contain terminal symbolic elements, "→" is the substitution relation. The Variable and Constant ontology classes can be used to describe the terminal elements of the substitution relation. hasMeaning_Koch_curve and hasMeaning_Sierpinsky_triangle are description of actions done when constructing an image of the Koch curve and Sierpinsky triangle, respectively, if the current symbol in the sequence of symbols formed by the constructor is an individual of the Variable class; hasRule_Koch_curve and hasRule_Sierpinsky_triangle represent the right part of the substitution rule for constructing the image of the Koch curve and Sierpinsky triangle, respectively, the left part is an individual of the Variable class.
The data properties describing individuals of the Constant class are hasMeaning_Koch_curve and hasMeaning_Sierpinsky_triangle. They are the descriptions of actions when constructing the image of the Koch curve and Sierpinsky triangle, respectively, if the current symbol in the sequence of symbols formed by the constructor is an individual of the Constant class.
Some individuals of the Variable and Constant classes may have attributes that are not described in the class.
The medium ontology includes a basic set of individuals that is used as the values of object properties or used to construct new fractal individuals. Let's consider these individuals in more detail.
F1, F10 are individuals of the Koch_curve class. They are Koch curves, with different angles of inclination, the number of iterations and the type of line. The F1 individual is used as a base for forming other individuals. That is, new individuals of the Koch_curve class are built using data of the hasConstant, hasVariable, and hasStart properties of this individual. The structure of the F1 individual is shown in Figure 2. Rectangles with a purple contour are individuals and blue ones are ontology classes. Solid yellow lines are a class-subclass relationship. Dashed yellow lines indicate that individuals are of a certain class. So, for example, F is an individual of the Variable class, and F1 is a Koch_curve. Solid blue lines are properties. For example, the individual F is the value of the
Individuals F2 and F3 are base for all new individuals of classes Sierpinsky_triangle and Dragon_curve, respectively. Their structure is like one of F1.
When forming a new individual of one of the Fractal subclasses based on individuals existing in the ontology, the following procedure is used:
To set the line type, the ontology has individuals: C1 of the Curve class, E1 Ellipse, L1 Line, T1 Triangle, and R1 Rectangle. This list can be updated.
Individuals of the Constant class present in the ontology are "+", "-". They have data properties defined by the Constant class.
Individuals of the Variable class present in the ontology are F, and G. They have data properties defined by the Variable class. Individual F has additional properties: • • hasMeaning_Dragon_curve is description of the actions to be done during the construction of the dragon curve image, if this variable is processed in the rule; hasRule_Dragon_curve represents the right side of the substitution rule for drawing the dragon curve image, the left side is the given variable.
Such a difference in the attributes of the variables F and G is caused by the type of fractals they are used to construct.
Individuals of the Fractal class and its subclasses can have the hasStart property as a data property or an object property. This is due to the conceptualization of the property. If the derivation of the chain that describes the fractal according to the rules of substitution starts with a variable, then hasStart takes the value of the individual from the basic set of individuals of the ontology. If the output starts with a construction (chain) of variables and constants, then hasStart is represented by a string. So, for example, the derivation of the chain that describes the constructions of the fractal of chain that describes the fractal constructions of the Sierpinski_triangle class begins with F-G-G. Elements of the given chain are individuals present in the ontology.
Operations like concatenation, partial and complete derivation, as well as substitution relations, are defined on the medium elements.
The concatenation operation ⨂( 1, 2) is the operation of linking form elements. If 1 and 2 are forms, then the form 1, 2 is called a concatenation of forms 1, 2. Any sequence of medium elements on which the binding operation has been performed will be called a form.
A substitution relation is a binary relation with attributes → . For the form = ⨂( 1, 2, … , ℎ, … , ) and an available substitution relation ( ℎ, ) (can be written as ℎ → ) such that ℎ ≺ ( ℎ is part of ), the result of the ternary substitution operation ∗ = ⟹ ( ℎ, , ) will be of the form ∗ = ⨂( 1, 2, … , , … , ).
Partial derivation operation (| ⇒ (Ψ, l )), Ψ is the set of production rules consists of choosing one of the available substitution rules : 〈 , 〉 ∈ Ψ with substitution relations sr and performing substitution operations on its basis, gr
operations on attributes, they are not used in this paper.
The binary operation of complete derivation or simple derivation (|| ⇒ (Ψ, l )consists of a stepby-step transformation of forms, starting from the initial non-terminal and ending with a construction that satisfies the derivation termination condition, which involves the cyclic execution of partial derivation operations. The derivation termination condition is the completion of a certain number of cycle iterations.
The purpose of construction is to form a sequence of symbols for further transformation into a sequence of graphic primitives of the Line_type class, forming a geometric fractal.
Restrictions of the fractal constructor are set by the executor of the model, which affects the number and complexity of the constructed structures and the time of their formation.
The initial conditions for the construction of fractals are the presence of individuals of the Variable and Constant classes, which are used as the value of the hasStart property. The value of the has_n property is defined.
The construction completion condition is the execution of a specified number of iterations in the full derivation operation, which is determined by the value of the has_n attribute of the Fractal class.
We interpret the constructor using the algorithmic constructor [
〈 , , = 〈Μ , , , , Σ , , Λ , 〉〉 ⟼ 〈 , = 〈Μ1, Σ1, Λ1, 〉〉 , where Λ1 ⊃ Λ , , = { 0| } is the set of basic algorithms, , are the set of definitions and values of the algorithm 0| . Λ , = {Μ , ⊃ ⋃ 0∈ , ( ( 0)⋃ ( 0)) ∪ Ω( )} nonhomogeneous medium, Ω( ) is set of algorithms implemented by the constructor; Λ1 = {( 10 ,∙ ↲ " ∙ "), ( 2 | , | ∙ ↲ "⨂"), ( 3 | ℎ , , ↲ ⟹), ( 4 | ,∙Ψ ↲ ⟹), ( 5 |Ω̅,∙Ψ ↲ ⟹), Λ1 ⊃ Λ ; Z is the set of possible executors (actors) that can implement algorithms . The result of the actor's work is a constructed chain of symbols that describes the construction of fractals using the symbols of constants and variables.
The constructor includes algorithms for performing operations: (2) algorithm ; 2 | ,
∙ 3 | ℎ , , 4 | ,∙Ψ, 5 |Ω̅,∙Ψ a set of formed constructions.
partial and complete derivation, where , are forms, is an axiom, Ω̅ is
algorithm compositions, ∙
sequential execution of algorithm after concatenations of medium elements, ,
forms; substitutions, ℎ, ,
forms; By construction, we mean the form formed by multiple substitution and subtraction operations.
As a result of the interpretation, we get a constructive system, which consists of a construction model and a model of the internal executor.
To clarify the entered operations, we will concretize the constructor : 〈 , , = 〈Μ1, Σ1, Λ1, 〉〉 ⟼ 〈 , , , = 〈Μ1, Σ1, Λ2, 〉〉 , where Λ2 = Λ1 ∪ Λ3, Λ3 ⊃ { 1 ⊃ ,
= { , , +, −}}, is a set of terminals, is the initial terminal for constructing fractals of the Koch_curve, Dragon_curve classes. For fractals of the Sierpinski triangle class, the FGG form is the initial terminal.
ISC: rules of substitutions. Let us consider the rules of substitutions, which allow us to formalize the process of building a chain of instructions for building a fractal image.
To construct a fractal of the Koch Curve class we apply the following rule: where the symbols are commands: "element (the type of the element is specified by the hasLineType property of the Fractal class).
To build a fractal of the Dragon's Curve class we apply the following rules: where the symbols are commands: G
go up and draw a graphic element (the type of the element is specified by the hasLineType property of the Fractal class), the meaning of the other symbols is similar to Koch's curve.
To construct a fractal of the Sierpinski triangle class we apply the following rules: where symbols are commands with meanings given above.
The developed constructor model (3) is the basis of the program for constructing images of geometric fractals. The program is written in Java using the Jena framework.
In the process of forming graphic representations of fractals, external and internal actors are involved (Figure 3). (3) (4) (5) (6) (7) (8) the developer of the constructive-synthesizing model including the ontology (U1); the user is the customer of constructions and the supplier of data for construction (U2); hardware-software system (U3), for the interaction of external actors: the user (U2) with Jena; a converter of chain structures (software and hardware, as in this case (part of U3), or an internal executor of another constructive-synthesizing model).
The internal actor (Z) forms fractal sequences of symbols based on the developed constructivesynthesizing model.
Let's consider the details of the internal actor. The implementation of the interpreted constructor consists of the formation of chains of symbols that satisfy the rules (4 algorithms related to signature operations according to the rules of axiomatics:
⟼ Ω̅( ), (9) where Ω̅( ) ⊂ Ω( ), Ω̅ is the set of formed chains of symbols that describe fractals, Ω( ) is the set of constructions that satisfy and can potentially be formed.
Let's consider the details of external actors. The formation of a graphic representation of a chain of symbols Ω̅ is performed by an external actor using the program. For this, it uses chains formed by the internal executor of the constructor (Z) according to the rules and parameters (number of iterations, angle), which are presented in the ontology. The construction of the chain is performed by separate methods (functions) of the program. The input data (medium elements) describing the fractal are read programmatically from the OWL file using a SPARQL query:
PREFIX f:<http://www.semanticweb.org/... # > PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> SELECT ?subject WHERE { ?subject rdfs:subClassOf f:Fractal}.
Thus, the developed program represents an internal actor that implements the algorithms of the constructor (2), and an external one that uses the results of the work of the internal (chain of symbols) to form images.
For the elements, Ω̅( ) we will construct an image of a geometric fractal that corresponds to the description chain. 0 and 0 show images of basic fractals. These individuals are in the input data. The value of the properties of the individual F1 of the Koch curve is shown in the information panel of the program window on the left (Figure 4). Fractal F2, the graphic representation of which is shown in Figure 5a, has the following property values: angle 120, number of iterations 4, start ellipse.
Let's consider the construction of a graphic representation of the F2 individual in more detail. Rules (7) and (8) were applied for its construction.
The initial condition of vision is the string (axiom): F-G-G.
As a result of performing the substitution operation on each iteration (there are 4 iterations), we get a new chain (line).
To build a chain, in the first step, we choose a symbol to replace. Let's start with the first F. Apply the substitution rule F to it: F-G- -G-G.
-G-G.
Step 3: choose another F symbol to replace and apply the F replacement rule to it. The following steps are similar to the previous ones. As a result, we will get a chain of symbols, which is interpreted by the developed program as follows: F command for drawing the graphic element horizontally, G is for vertically, plus and minus signs indicate the angles of rotation after the image by the F or G command. The type of the element is determined by an individual of one of the subclasses of the LineType class.
Fractal F3, the graphic representation of which is shown in Figure 5b, has the following property values: angle 90, number of iterations 8, start terminal S, line type ellipse. All rules used during construction correspond to those described in section 4.4. These and other given images of geometric fractals were obtained analogously to the construction of the F2 fractal image.
According to the scheme in Figure 3, the functionality of the program allows for the addition of new individuals, which is done by an external actor. An example of implementation is shown in Figure 6. Other examples of images of individuals added through the user interface are shown in Figure 7. The signature of drawing elements is given in the format "class - number of iterations angle - line type".
The construction of fractal images for individuals, which are created during the operation of the program, is similar to basic fractals. Chain derivation uses a set of rules that was defined in the base fractal that was used as a basis for the current one. The number of iterations, angle and type of graphic element for new individuals is set by the user during creation. In the future, these parameters are used in the construction of the chain and its interpretation - construction of the image.
The developed ontology of fractals (as part of the constructive-synthesizing model) can be classified as a lightweight ontology. The language of the ontology is OWL Full profile, that is, the descriptive logic was not used.
The definition of data types is a component of the model. Types impose restrictions on the set of valid values and operations on them. Such restrictions could be represented by constructs of the rdfs:domain type. Verification of the consistency of the schema and data can be performed by reasoners. Data types are currently checked by Java's built-in type conversion functions. setting the parameters of a new individual, b a graphic
Setting fractal parameters and checking their correctness is carried out with the help of a
graphical user interface implemented by Java tools. At the same time, there is a practice of validating
data of similar forms by ontological means and is implemented using SHACL [
The properties of a new fractal are determined by copying them from existing individual fractals. In the future, to remove limitations of OWL Full, this can be implemented by OWL or SHACL SPARQL rules. In this case, they will be explicitly represented as part of the model.
In the future, the ontology of fractals can be extended by the presentation of other known fractals.
There are several alternative approaches to the formation of fractals: algorithmic, functionalalgorithmic using a system of iterated functions based on a set of contracting mappings , L-systems, contracting affine automata.
Constructive-synthesizing modeling allows for creating a more types of fractals [
In this paper, the use of ontologies in constructive-synthesizing modeling extends the possibilities of generating fractals with a variable element base and initial conditions. fractals and a universal constructively synthesizing modeled structure based on ontologies.
As part of the pilot project, constructive-synthesizing models were improved with formal ontologies on the example of formalizing the processes of forming geometric fractals.
The results of separation of the automation of formation and conceptual modelling of fractals are given. It will be appropriate to enrich the ontology with rules and restrictions to ensure the verification of the consistency of the model by ontological means. For this, a further redistribution of the model constructions from the software code to the ontology must be performed.