Regular Expressions in a CS Formal Languages Course

Regular expressions in an Automata Theory and Formal Languages course are mostly treated as a theoretical topic. That is, to some degree their mathematical properties and their role to describe languages is discussed. This approach fails to capture the interest of most Computer Science students. It is a missed opportunity to engage Computer Science students that are far more motivated by practical applications of theory. To this end, regular expressions may be discussed as the description of an algorithm to generate words in a language that is easily programmed. This article describes a programming-based methodology to introduce students to regular expressions in an Automata Theory and Formal Languages course. The language of instruction is FSM in which there is a regular expression type. Thus, facilitating the study of regular expressions and of algorithms based on regular expressions.Comment: In Proceedings TFPIE 2023, arXiv:2308.0611

Python for education: the exact cover problem

Python implementation of Algorithm X by Knuth is presented. Algorithm X finds all solutions to the exact cover problem. The exemplary results for pentominoes, Latin squares and Sudoku are given.Comment: 13 pages, 4 figures, 3 table

An Introductory Survey of Computational Space Complexity

Using the Understanding by Design pedagogical methodology, this thesis aims to combine, clarify, and contextualize introductory ideas about computational space complexity and package them in an instructional unit. The unit is composed primarily of a Unit Template, series of Lessons, and Performance Assessments. It is intended to present content acknowledged as valuable by ACM that is often missing from undergraduate computer science curricula at peer educational institutions to Trinity University. The unit covers ideas such as the space hierarchy, computational time / space tradeoffs, and completeness, and is designed to promote understanding and inquiry of and beyond its subject matter

Verification in Generalizations of the 2-Handed Assembly Model

Algorithmic Self Assembly is a well studied field in theoretical computer science motivated by the analogous real world phenomenon of DNA self assembly, as well as the emergence of nanoscale technology. Abstract mathematical models of self assembly such as the Two Handed Assembly model (2HAM) allow us to formally study the computational capabilities of self assembly. The 2HAM is one of the most thoroughly studied models of self assembly, and thus in this paper we study generalizations of this model. The Staged Tile Assembly model captures the behavior of being able to separate assembly processes and combine their outputs at a later time. The k-Handed Assembly Model relaxes the restriction of the 2HAM that only two assemblies can combine in one assembly step. The 2HAM with prebuilt assemblies considers the idea that you can start your assembly process with some prebuilt structures. These generalizations relax some rules of the 2HAM, in ways which reflect real world self assembly mechanics and capabilities. We investigate the complexity of verification problems in these new models, such as the problem of verifying whether a system produces a specified assembly (Producibility), and verifying whether a system uniquely assembles a specified assembly (Unique Assembly Verification). We show that these generalizations introduce a high amount of intractability to these verification problems

An assessment of DREAM, appendix E

The design realization, evaluation and modelling (DREAM) system is evaluated. A short history of the DREAM research project is given as well as the significant characteristics of DREAM as a development environment. The design notation which is the basis for the DREAM system is reviewed, and the development tools envisioned as part of DREAM are discussed. Insights into development environments and their production are presented and used to make suggestions for future work in the area of development environments

Python for Education: The Exact Cover Problem

Python implementation of Algorithm X by Knuth is presented.Algorithm X finds all solutions to the exact cover problem.The exemplary results for pentominoes, Latin squares and Sudokuare given

Improving the Cybersecurity of Cyber-Physical Systems Through Behavioral Game Theory and Model Checking in Practice and in Education

This dissertation presents automated methods based on behavioral game theory and model checking to improve the cybersecurity of cyber-physical systems (CPSs) and advocates teaching certain foundational principles of these methods to cybersecurity students. First, it encodes behavioral game theory\u27s concept of level-k reasoning into an integer linear program that models a newly defined security Colonel Blotto game. This approach is designed to achieve an efficient allocation of scarce protection resources by anticipating attack allocations. A human subjects experiment based on a CPS infrastructure demonstrates its effectiveness. Next, it rigorously defines the term adversarial thinking, one of cybersecurity educations most important and elusive learning objectives, but for which no proper definition exists. It spells out what it means to think like a hacker by examining the characteristic thought processes of hackers through the lens of Sternberg\u27s triarchic theory of intelligence. Next, a classroom experiment demonstrates that teaching basic game theory concepts to cybersecurity students significantly improves their strategic reasoning abilities. Finally, this dissertation applies the SPIN model checker to an electric power protection system and demonstrates a straightforward and effective technique for rigorously characterizing the degree of fault tolerance of complex CPSs, a key step in improving their defensive posture

Language concepts and design patterns

Programming languages aim at the construction of simple but expressive programs. To achieve this, plenty of language concepts have arisen over time. Design patterns aim at the solution of common design problems. To achieve this, plenty of approved design concepts have been collected. We claim that language concepts and design patterns are essentially the same. Indeed, a language may offer a design pattern as a language concept; we call such patterns "language patterns". A design pattern can be implemented in terms of other design or language patterns. Since a concrete programming language only supports a subset of language patterns, every other pattern must be expressed in terms of this subset. We call such an implementation a "workaround". The specification of a workaround imposes proof obligations: it must be shown that a workaround simulates the pattern. Once proved correct, we can collect patterns and their workarounds in a trustworthy catalogue. This helps software developers to correctly apply patterns in any language and helps the language designer to decide which patterns to put into the language core. We demonstrate this pattern integration process with well-known design patterns and concepts of object-oriented languages. Additionally, we list important language patterns together with their workarounds

Games, puzzles, and computation

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2006.Includes bibliographical references (p. 147-153).There is a fundamental connection between the notions of game and of computation. At its most basic level, this is implied by any game complexity result, but the connection is deeper than this. One example is the concept of alternating nondeterminism, which is intimately connected with two-player games. In the first half of this thesis, I develop the idea of game as computation to a greater degree than has been done previously. I present a general family of games, called Constraint Logic, which is both mathematically simple and ideally suited for reductions to many actual board games. A deterministic version of Constraint Logic corresponds to a novel kind of logic circuit which is monotone and reversible. At the other end of the spectrum, I show that a multiplayer version of Constraint Logic is undecidable. That there are undecidable games using finite physical resources is philosophically important, and raises issues related to the Church-Turing thesis. In the second half of this thesis, I apply the Constraint Logic formalism to many actual games and puzzles, providing new hardness proofs. These applications include sliding-block puzzles, sliding-coin puzzles, plank puzzles, hinged polygon dissections, Amazons, Kohane, Cross Purposes, Tip over, and others.(cont.) Some of these have been well-known open problems for some time. For other games, including Minesweeper, the Warehouseman's Problem, Sokoban, and Rush Hour, I either strengthen existing results, or provide new, simpler hardness proofs than the original proofs.by Robert Aubrey Hearn.Ph.D