Vibes: A visual language for specifying behavioral requirements of algorithms

Many temporal and modal logic languages can be regarded as subsets of first order logic, i.e. the semantics of a temporal logic formula is given as a first order condition on points of the underlying models (Kripke structures). Often the set of possible models is restricted to models which are trees. A temporal logic language is (first order) expressively complete, if for every first order condition for a node of a tree there exists an equivalent temporal formula which expresses the same condition. In this paper expressive completeness of the temporal logic language with the set of operators U (until), S (since), and X k (k-next) is proved, and the result is extended to various other tree-like structures.

As a defacto industry standard, UML has been more and more widely used in software development. However, with the increase of software scale and complexity, deficiencies of UML are increasingly obvious. As the latest version of UML, UML2.0 has been improved and refined base on UML1.x. Whereas UML still lacks precise semantics which is difficult to analyze and validate the described model. In a unified temporal logic framework, temporal logic language XYZ/E can represent both static semantics and dynamic semantics. In addition, it supports stepwise refinement, model checking, as well as executable code automatically converted. Based on these, a practical scheme is proposed for modeling software with combining UML2.0 and XYZ/E, which also provides a formal basis for analysis and validation of the model.

This article is written in support of the academic discipline “Nonclassical logics”. The objects of study within this discipline are the basic principles and constructive elements used in formal construction of various nonclassical propositional logics. Despite the abstract nature of the theory of nonclassical logics, which is mainly focused on strict mathematical formalization of logical reasoning, there are real practical applications for its theoretical results. In particular, languages of temporal modal logics are widely used for modeling, specification, and verification (correctness analysis) of logic control program systems. This article demonstrates, based on the example of linear temporal logic (LTL), how abstract concepts of nonclassical logics can be applied in practice in the area of information technology and programming. It is shown that the behavior of a software system can be represented as a set of LTL formulas, which can then be used to check the satisfiability of the properties of that software system via the procedure for proving the validity of logical inferences expressed in terms of linear temporal logic (LTL). The approach to using LTL to specify the behavior of software systems is demonstrated based on Minsky counter machines. Minsky machines are one of the ways of formalizing the intuitive concept of an algorithm. Their computational power is equivalent to that of Turing machines. A counter machine is a computer program written in a high-level language, since it contains variables called counters and conditional and unconditional jump operators used for loop construction. It is known that any algorithm can (hypothetically) be implemented as a three-counter Minsky machine.

Recently, software verification using model checkers has achieved widespread success. It can locate hard-to-find bugs in software by exhaustively searching executing paths. In this paper, we propose a new software design method that enables the evaluation of the fault tolerance of software behavior at the specification level: we can check software behavior, not only when the hardware and network are in good order, but also when they are out of order; we can then improve fault tolerance of the target software using the model checker. We can test software under environments in which we destroy hardware and/or networks intentionally, not in situ, but in silico (in computer simulation).

In temporal-logic model checking, we verify the correctness of a program with respect to a desired behavior by checking whether a structure that models the program satisfies a temporal-logic formula that specifies the behavior. The model-checking problem for the branching-time temporal logic CTL can be solved in linear running time, and model-checking tools for CTL are used successfully in industrial applications. The development of programs that must meet rigid real-time constraints has brought with it a need for real-time temporal logics that enable quantitative reference to time. Early research on real-time temporal logics uses the discrete domain of the integers to model time. Present research on real-time temporal logics focuses on continuous time and uses the dense domain of the reals to model time. There, model checking becomes significantly more complicated. For example, the model-checking problem for TCTL, a continuous-time extension of the logic CTL, is PSPACE-complete.In this paper we suggest a reduction from TCTL model checking to CTL model checking. The contribution of such a reduction is twofold. Theoretically, while it has long been known that model-checking methods for untimed temporal logics can be extended quite easily to handle discrete time, it was not clear whether and how untimed methods can handle the reset quantifier of TCTL, which resets a realvalued clock. Practically, our reduction enables anyone who has a tool for CTL model checking to use it for TCTL model checking. The TCTL model-checking algorithm that follows from our reduction is in PSPACE, matching the known bound for this problem. In addition, it enjoys the wide distribution of CTL model-checking tools and the extensive and fruitful research efforts and heuristics that have been put into these tools.KeywordsModel CheckTemporal LogicAtomic PropositionKripke StructureTemporal ReasoningThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In the context of higher education strongly transforming itself under the impact of technology, Artificial Intelligence (AI) has become an important support tool in the learning process, especially for Computer Science (CS) students. Integrating a structured literature review and conceptual analysis, this paper evaluates the role of AI as a self-learning assistant, focusing on outstanding benefits such as personalized learning, source code debugging, and explaining complex algorithms, as well as challenges related to academic integrity, ethics, and independent thinking skills of students. Through analysis, the paper proposes a comprehensive recommendation framework, including: (1) an in-depth analysis of the five most effective AI tools; (2) smart strategies for AI-use through Prompt Engineering; (3) new pedagogical approaches for instructors; and (4) support policies from institutions. The results indicate that although AI cannot substitute human instructors completely, it can act as a powerful lever to enhance self-learning capabilities. When applied appropriately, it contributes to elevating the quality of Computer Science education in universities. Keywords: AI-assisted learning, Artificial Intelligence, Computer Science students, higher education, self-learning assistant.

Informal and graphical modeling techniques enable developers to construct abstract representations of systems. Object-oriented modeling techniques further facilitate the development process. The Unified Modeling Language (UML), an object-oriented modeling approach, could be broad enough in scope to represent a variety of domains and gain widespread use. Currently, UML comprises several different notations with no formal semantics attached to the individual diagrams. Therefore, it is not possible to apply rigorous automated analysis or to execute a UML model in order to test its behavior, short of writing code and performing exhaustive testing. We introduce a general framework for formalizing a subset of UML diagrams in terms of different formal languages based on a homomorphic mapping between metamodels describing UML and the formal language. This framework enables the construction of a consistent set of rules for transforming UML models into specifications in the formal language. The resulting specifications derived from UML diagrams enable either execution through simulation or analysis through model checking, using existing tools. This paper describes the use of this framework for formalizing UML to model and analyze embedded systems. A prototype system for generating the formal specifications and results from an industrial case study are also described.

We asked all of the liberal arts faculty who advise undergraduates on course selection at the 14 colleges in the Associated Colleges of the Midwest a series of questions regarding their perceptions of the personality traits of Computer Science (CS) students, topics they think are covered in CS classes, and their overall impressions of CS. Our goal was to assess empirically the hypotheses that (1) many non-CS faculty do not really know what computer science is, and (2) many non-CS faculty are unaware of the differences between CS and Information Technology (IT). We received over 250 survey responses, which revealed that, among non-CS faculty, only 9% disagree or are neutral that CS should even be part of a liberal arts curriculum, but 32% think CS students learn to administer computers and computer networks, while 34% believe that CS students are taught to use Microsoft products in the classroom. However, over 95% of non-CS faculty also recognize the importance of both programming and algorithms to the study of computer science. The overall data suggests that a majority of non-CS faculty in the Associated Colleges of the Midwest have a a basic understanding of CS, while the remainder have an overly broad definition of CS (i.e. they think that CS includes IT).

This study investigates gender differences in attitudes toward mathematics among first-year Computer Science (CS) students, focusing on three key dimensions: self-confidence, enjoyment, and value. Understanding students’ affective orientations toward mathematics is crucial, as these attitudes can influence their engagement, persistence, and performance in mathematics-related courses. The study aims to determine whether male and female students differ significantly in their levels of self-confidence, the value they place on mathematics, and the degree of enjoyment they derive from the subject. A total of 114 first-year CS students participated in the study and completed a structured questionnaire designed to measure the three attitude dimensions. The instrument’s reliability was confirmed through internal consistency analysis, while the Mann–Whitney U test was employed to assess gender differences in the responses. The findings revealed no statistically significant gender differences in self-confidence and enjoyment, suggesting that male and female students hold similar levels of belief in their mathematical abilities and experience comparable levels of positive affect toward the subject. However, the analysis identified a small but significant difference in perceived value, with female students reporting a stronger recognition of mathematics as valuable in their academic and professional pursuits than their male counterparts. These results suggest that while self-confidence and enjoyment in mathematics appear unaffected by gender among CS students, female students may place greater importance on the role of mathematics in their studies and future careers. The study contributes to the growing body of literature on gender and mathematics attitudes, highlighting the need for educators to acknowledge and leverage these perceptions to foster equitable and supportive learning environments.

Nowadays, Computer Science (CS) students must cope with continuous challenges related to programming skill acquisition. In some occasions, they have to deal with the internals of memory management (pointers, pointer arithmetic, and heap management) facing a vision of programming from the low abstraction level offered by C. Even using C++ and references, not all scenarios where objects or collections of objects need to be managed can be covered. Based on the difficulties identified when dealing with such low‐level abstractions, the C‐Sim application, aimed at learning these concepts in an easy way, has been developed. To support the tool, the C programming language was selected. It allows showing concepts, remaining as close as possible both to the hardware and the operating system. To validate C‐Sim, pre and posttests were filled in by a group of 60 first‐year CS students, who employed the tool to learn about memory management. Grades of students using C‐Sim were also obtained and compared with those that did not use the tool the former academic year. As main outcomes, 82.26% of students indicated that they had improved programming and memory management knowledge, and 83.64% pointed out that the use of this type of tools improves the understanding and quality of the practice lessons. Furthermore, the marks of students have significantly increased. Finally, C‐Sim was designed from the ground up as a learning aid and can be useful for lecturers, who can complement their lessons using interactive demonstrations. Students can also employ it to experiment and learn autonomously.

The state explosion problem is the central challenge in automatic verification using model checking. In many cases, representing the state space of a system as a lattice is an effective way of representing very large state spaces. The partial order of the lattice represents an information ordering between states, which can be used as an abstraction mechanism to reduce the computational cost of model checking. The 'traditional' logical framework for model checking finite state systems has serious deficiencies when applied to information-ordered state spaces. Interpreting the truth of a proposition about a state or a sequence of states in a four-valved truth domain is better from a modelling point of view, allowing us to reason about partial and contradictory information. Moreover, it overcomes a serious technical difficulty encountered when using a two-valued truth domain. The paper defines the syntax and semantics of a four-valued temporal logic that can be used for specifying properties of a computer system. This framework has particular relevance to hardware verification. It could be used by several model checking algorithms. Symbolic trajectory evaluation (STE) [33] is a model checking algorithm that has had success in model checking using information orderings to reduce computational cost. Previous work used a two-valued logic though, which limited the expressiveness of the logic. Using the framework presented here, the STE algorithm can be generalised, and then applied in practice to a richer logic. Some examples are shown in this paper. Keywords:Symbolic trajectory evaluation, quarternary logic, model checking, temporal logic, bilattices.

Consensus protocols are widely used in building reliable distributed software systems and their correctness is of vital importance. TLA+ is a lightweight formal specification language which enables precise specification of system design and exhaustive checking of the design without any human effort. The features of TLA+ make it widely used in the specification and model checking of consensus protocols, both in academia and in industry. However, the application of TLA+ is limited by the state explosion problem in model checking. Though compositional model checking is essential to tame the state explosion problem, existing compositional checking techniques do not sufficiently consider the characteristics of TLA+. In this work, we propose the Interaction-Preserving Abstraction (IPA) framework, which leverages the features of TLA+ and enables practical and efficient compositional model checking of consensus protocols specified in TLA+. In the IPA framework, system specification is partitioned into multiple modules, and each module is divided into the internal part and the interaction part. The basic idea of the interaction-preserving abstraction is to omit the internal part of each module, such that another module cannot distinguish whether it is interacting with the original module or the coarsened abstract one. We apply the IPA framework to the compositional checking of the TLA+ specifications of two consensus protocols Raft and ParallelRaft. Raft is a consensus protocol which was originally developed in academia and then widely used in industry. ParallelRaft is the replication protocol in PolarFS, the distributed file system for the commercial database Alibaba PolarDB. We demonstrate that the IPA framework is easy to use in realistic scenarios and at the same time significantly reduces the model checking cost.

The traditional static measurement method based on data integrity measurement can only prove that the software has not been tampered with, and cannot describe the software behavior status. Dynamic measurement can measure the software behavior in real time, but there is no doubt that it requires a lot of computing resources. In this paper, we propose static measurement architecture PMA, which using formal method to abstract and verify software behavior. In PMA, formal language abstracts software behavior, formal specification describes security policy, and software behavior measurement problem is transformed into formal proof. We also have implemented the corresponding code according to the PMA design principle. The experimental test verifies the feasibility of the PMA architecture.

Model checking as an approach to the automatic verification of finite state systems has focussed predominantly on system specifications expressed in temporal logic. In the distributed systems community, logics of knowledge (epistemic logics) have been advocated for expressing desirable properties of protocols and systems. A range of logics combining temporal and epistemic components have been developed for this purpose. However, the model checking problem for temporal logics of knowledge has received (comparatively) little attention. In this paper, we address ourselves to this problem. Following a brief survey of the relevant issues and literature, we introduce a temporal logic of knowledge (Halpern and Vardi’s logic CKL n). We then develop an approach to CKL n model checking that combines ideas from the interpreted systems semantics for knowledge with the logic of local propositions developed by Engelhardt et al. With our approach, local propositions provide a means to reduce CKL n model checking to linear temporal logic model checking. After introducing and exploring the ideas underpinning our approach, we present a case study (the bit transmission problem) in which spin was used to establish temporal epistemic properties of a system implemented in PROMELA.

This study aims to identify the effect of the teaching method using educational software based on artificial intelligence in the academic achievement of 10 th -grade students in computer science in Jordan and their attitudes towards it. To achieve the goal of this study, a computerized software was designed to be applied to a purposefully selected sample consisting of (50) 10 th -grade students at The University of Jordan School. The study sample was randomly distributed into two groups: an experimental sample taught using the educational software, and a control sample taught in the traditional method, where the researcher prepared an achievement test to measure the academic achievement of the 10 th -grade students in the Computer Science Subject, where the validity and reliability of the test has been validated, and the test-retest reliability coefficient was (0.86). A questionnaire was prepared for the attitudes, where their validity and reliability were validated. The reliability factor of the questionnaire based on Cronbach’s alpha equation was (0.01). To analyze the results, an analysis of covariance (ANCOVA) was used, where the results of the study showed that there are statistically significant differences in favor of the experimental group taught using educational software based on artificial intelligence in learning computer science subject. The results also showed that there are medium positive attitudes of the experimental group towards educational software. The study recommended designing and developing computerized software in the field of teaching computer science subject s and training and encouraging teachers to use artificial intelligence-based learning in the field of basic education. Keywords: artificial intelligence software, academic achievement, student attitudes, University of Jordan School DOI: 10.7176/JEP/11-7-10 Publication date: March 31 st 2020