Prabhaker Mateti

On Algorithms for Enumerating All Circuits of a Graph

A brief description and comparison of all known algorithms for enumerating all circuits of a graph is provided, and upper bounds on computation time of many algorithms are derived. The vector space...

A laboratory-based course on internet security

We developed a laboratory-based course on Internet Security. The course is aimed at the senior undergraduate. This paper discusses the course and explains how others can set up their own labs to teach this course. All the laboratory work is conducted in a laboratory of PCs running Linux. We developed lecture notes for the course, and a web site to widely disseminate these materials.

A framework for the automated drawing of data structure diagrams

Data structure diagrams are two-dimensional figures made up of lines that aim to pictorially indicate the interrelationships of the elements of a data structure. The various rules and factors of aesthetics that go into the way data structure diagrams are drawn are collected together. The various subjective factors are formulated into computable objectives and numeric parameters. These are distilled from a large number of data structure drawings found in various textbooks. The rules used have not reached a level of acceptance comparable to that of the relevant rules in engineering graphics. The internal architecture of a (sub)system that helps draw data structure diagrams is outlined. >

Parallel algorithms for the single source shortest path problem

We present several parallel algorithms for the problem of finding shortest paths from a specified vertex (called the source) to all others in a weighted directed graph. The algorithms are for machines ranging from array processors, multipleinstruction multiple-data stream machines to a special network of processors. These algorithms have been designed by “parallelizing” two classic sequential algorithms — one due to Dijkstra (1959), the other due to Moore (1957). Our interest is not only in obtaining speeded-up parallel versions of the algorithms but also in exploring the design principles, the commonality of correctness proofs of the different versions, and the subjective complexity of explaining and understanding these versions.ZusammenfassungWir geben parallele Algorithmen an, die in einem gerichteten, bewerteten Graphen die kürzesten Wege von einem Knoten (der Quelle) zu allen anderen Knoten liefern. Die Algorithmen sind für verschiedene Maschinentypen entworfen, die von Feldrechnern (Array-Prozessoren) über Vielfach-Befehle, Vielfach-Daten-Strom-Maschinen (MIMD) bis zu einem speziellen Netz von Prozessoren reichen Die Algorithmen sind durch “Paralleiisierung” von zwei klassischen sequentiellen Algorithmen entstanden — dem von Dijkstra (1959) und dem von Moore (1957). Unser Interesse besteht nicht nur in der Konstruktion schnell laufender paralleler Versionen. Wir untersuchen auch die Entwurfsprinzipien, die Gemeinsamkeiten der Korrektheitsbeweise in den verschiedenen Versionen und die subjektive Komplexität, die verschiedenen Fassungen zu verstehen und zu erklären.

A Decision Procedure for the Correctness of a Class of Programs

Verification of certain properties of a class of programs is considered. The programs are written In a miniprogrammmg language that has variables of only two data types, a linear array of elements, and pomters to these elements. The array elements can only be exchanged; pointers can only be incremented or decremented by one Program properties to be venfied are expressed in a severely restricted assertion language which contains essentially Boolean expressions of comparisons among pointers and among array elements Several in-place sorting algorithms can be readily written and asserted m these languages A decision procedure for the truthhood of the verification conditions generated for the above class of asserted programs is presented An algorithm for generating counterexamples for false verification conditions is also given The theorem prover can be readily implemented using simple graph algorithms The objective of this exercise is to use problem knowledge to design simple and efficient verifiers. The techmques developed seem applicable to wider classes of programs mampulatmg data structures.

Distributed and Scalable OWL EL Reasoning

OWL 2 EL is one of the tractable profiles of the Web Ontology Language OWL which is a W3C-recommended standard. OWL 2 EL provides sufficient expressivity to model large biomedical ontologies as well as streaming data such as traffic, while at the same time allows for efficient reasoning services. Existing reasoners for OWL 2 EL, however, use only a single machine and are thus constrained by memory and computational power. At the same time, the automated generation of ontological information from streaming data and text can lead to very large ontologies which can exceed the capacities of these reasoners. We thus describe a distributed reasoning system that scales well using a cluster of commodity machines. We also apply our system to a use case on city traffic data and show that it can handle volumes which cannot be handled by current single machine reasoners.

Security Issues in the TCP/IP Suite

Some of these are protocol design weaknesses per se, whereas the rest are defects in the software that implements the protocols. IP, UDP, TCP and the infrastructure protocols were designed at a time when security concerns were almost non-existing and trust was assumed. While this paper summarizes design weaknesses in the TCP/IP suite from a security point of view, it is important to remember that many implementations have ”fixed” these weaknesses, but are not described in RFCs. We assume that the reader is fluent in TCP and IP details.

Pascal Verus C: A Subjective Comparison

The two programming languages Pascal and C are subjectively compared. While the two languages have comparable data and control structures, the program structure of C appears superior. However, C has many potentially dangerous features, and requires great caution from its programmers. Other psychological effects that the various structures in these languages have on the process of programming are also conjectured.

A specification schema for indenting programs

A two level specification of the functional behaviour of a class of indenting programs for Pascal is presented. The transformation that these programs perform on the input text is a composition of splitting input lines, altering the blank space between lexical tokens and computing the margin required in front of each of the split lines. The high level specification is given as a stylized Pascal grammar in Extended BNF. In contrast, the low level specifications, which are operationally closer to a program, and which define how syntactically invalid text is dealt with, require several mathematical functions that capture the essence of these basic transformations. The specifications of an indenting program for Pascal are then obtained as a further elaboration of these functions. Most indentation styles appearing in the literature can be specified with precision using methods developed in this paper. Our experience in this case study indicates that although specifications for real‐life programs can be given using simple mathematics, the effort required is still considerable.

A correctness proof of an indenting program

The correctness of an indenting program for Pascal is proved at an intermediate level of rigour. The specifications of the program are given in the companion paper.1 The program is approximately 330 lines long and consists of four modules: io, lex, stack and indent. We prove first that the individual procedures contained in these modules meet their specifications as given by the entry and exit assertions. A global proof of the main routine then establishes that the interaction between modules is such that the main routine meets the specification of the entire program. We argue that correctness proofs at the level of rigour used here serve very well to transfer ones understanding of a program to others. We believe proofs at this level should become commonplace before more formal proofs can take over to reduce traditional testing to an inconsequential place.