Home page

Knowledge graphs have come a long way from a simple set of RDF triples to systems for acquiring new knowledge. While in previous years, the primary application of knowledge graphs used to be semantic search, nowadays, knowledge graphs are permeating all areas of modern industry. This paper presents a survey of new knowledge graph variants, such as virtual knowledge graphs, dynamic knowledge graphs, and executable knowledge graphs used in modern industrial applications, as well as their primary application: cognitive digital twins. The paper also briefly examines methods for constructing knowledge graphs using large language models and improving the performance of large language models through the use of knowledge graphs.

The intention of the paper is to present a framework for developing, studying and comparing testing equivalences in interleaving, step, partial-order and combined semantics with reverse, in the context of safe Dense-Time Petri Nets (TPNs). For representation of behavior of TPNs partial-order semantic of time causal processes are used. Reversibility means that single or concurrent actions can be undone only after caused actions are undone or not done yet. As result we establish relationships between testing equivalences under consideration.

Reversible computing, which has been widely studied in recent years, is an unconventional form of computing that can be performed in both directions: forward and backward. Any sequence of actions performed by the system can be later canceled for any reason (for example, in case of an error), allowing one to restore the system to its previous state, as if the canceled actions had never performed. Event structures are a fundamental model in concurrency theory, allowing us to comprehend the behavior of concurrent systems by describing system events and their relations. In the literature, there are two main approaches to constructing the semantics of transition systems for event structure models. One approach is based on configurations, i.e. sets of already executed events, and the other relies on residuals, i.e. model fragments that have not yet been executed. Configuration-based transition systems are mainly used to represent semantics and equivalences of concurrent models. Residual-based transition systems are actively involved to demonstrate the consistency between the operational and denotational semantics of algebraic calculi for concurrent processes, as well as to visualize the behavior of models. This article provides a category-theoretic characterization of these types of transition systems semantics for cause-respecting reversible prime event structures, and establishes the relationship between the semantics, which can be useful in constructing algebraic descriptions of the composition of reversible concurrent processes.

In the last 30 years, neural networks have been one of the most rapidly developing areas of artificial intelligence. They are widely used in sound and image processing, medicine, content analysis, generation problems and others. Significant increase in computing power, the ability to process large amounts of data, and the development of neural network theory itself made the advancement possible. The paper provides an analysis of the development of learning algorithms and neural network architectures from their emergence to the state-of-the-art. The most actively developing areas were reviewed including large language models, giant networks and multimodal models. Kolmogorov-Arnold networks were also indicated as perspective research area.

This paper presents an algorithm for recovering positions of expressions in source code Cloud Sisal programs. The relevance of this study is due to the importance of accurately mapping abstract nodes of the syntax tree to corresponding fragments of source code for creating development tools such as a source code editor, a visual debugger, and error diagnostic utilities. The proposed approach addresses the problem of incomplete positional information in the output of syntactic parsers, when it is difficult to modify existing tools. The paper describes a developed three-phase algorithm, which includes the stages of token sequence reconstruction, token position calculation, and abstract syntax tree node position calculation. The algorithm's asymptotic time complexity is linear relative to the input size and does not exceed O(n), where n is the number of characters in the source program.

This paper presents ABML (Attribute-Based Modeling Language), a language for the specification and prototyping of discrete dynamic systems grounded in ontologically structured knowledge. ABML supports the formal definition of both system ontologies and the rules that govern system behavior, including dynamic evolution of knowledge structures and object states. ABML is implemented as a lexical extension of a Common Lisp dialect (SBCL) and is built on a compact yet expressive conceptual foundation consisting of objects, attributes, and object types. The language emphasizes a clear distinction between mutable and immutable objects and provides flexible attribute-based typing mechanisms. The paper describes in detail the language constructs for type definition, object creation and modification, pattern matching, and attribute evaluation. A central feature of ABML is its attribute closure mechanism, which enables context-sensitive attribute computation and supports the modeling of system dynamics in discrete time. The practical applicability of ABML is illustrated by a case study involving a hand dryer. An ontology for the system is developed, along with rules governing system initialization and operation. The results demonstrate that ABML is a practical and effective tool for ontological modeling of intelligent, information, and software systems.

- This paper presents an ontological approach to specifying the operational semantics of jump statements in the C programming language. The approach is based on ABML, a domain-specific language previously introduced for modeling discrete dynamic systems grounded in ontologically structured knowledge. We show that the operational semantics of programming language fragments, traditionally expressed as transition systems, can be viewed as dynamic systems and naturally formalized within the ABML framework. An ontology of C control-flow statements is introduced, covering goto, break, continue, and return, along with ontologies of constructs that respond to control transfer, including labeled statements, blocks, and the switch statement. The operational semantics of these ontological models is defined in terms of attribute closures computed with respect to agents and the execution environment. Particular attention is devoted to adapting ABML for the specification of operational semantics. This includes refining the concept of attribute closure, introducing explicit computation stages, and modeling the execution context explicitly. The resulting approach provides modularity, extensibility, and clarity in semantic specification. The results demonstrate the effectiveness of ontological modeling for the formal description of programming language semantics and establish a basis for extending the approach to additional C language constructs, as well as to program analysis and verification tasks.

The article provides a formal specification of the operational semantics of Rust expressions using the domain-specific modeling language ABML. It emphasizes the dynamic aspects of computation, including memory management, ownership, borrowing, and runtime verification of access conflicts. The approach relies on an ontological representation of Rust’s syntactic and semantic constructs, allowing expressions, blocks, and data structures to be described uniformly within a single computational model. Unlike traditional formalizations, this model explicitly integrates the safety metadata necessary to replicate Rust’s ownership and borrow checking mechanisms. A central contribution of this work is the use of a hierarchical memory model, which enables precise representation of partial borrows and access to individual fields within structures. This approach offers more accurate dynamic semantics than flat memory models and ensures consistency between formal rules and the actual behavior of Rust programs. The resulting operational semantics is executable and provides a foundation for program analysis, interpreter prototyping, and further research in the formal verification of languages with managed memory safety.