Lisp Programs Research Articles

GEOMETRIC SIMULATION OF THE MOVEMENT PROCESS OF THE EXCAVATOR’S MILLING WORKING EQUIPMENT

The simulation of the process of movement of the milling working equipment of an excavator when digging a pipeline is discussed. The parameters of the repair and construction strip are calculated, the position of the coordinate systems of the excavator manipulator mechanism is established. A hypothesis has been put forward that the position of the excavator on the strip affects the volume of movement during digging, which increases energy consumption and reduces economic efficiency. The excavator manipulator is considered as a five-link mechanism. A kinematic scheme of the mechanism is given, on the basis of which a program based on the synthesis of movements along the velocity vector is created. The construction of the movement trajectory was carried out in such a way, that the output link was in a horizontal position throughout the entire movement process. The program was created using the Visual Lisp programming language built into the AutoCAD environment. The program made it possible to obtain graphic models of the movement of the excavator manipulator mechanism in its various positions, as well as to calculate the amount of movement. Based on the data obtained, a drawing by Radishchev was constructed, which reflected the dependence of the generalized coordinates of the excavator manipulator mechanism and the amount of movement on the depth of lowering of the working equipment. As a result, it was concluded that with the middle position of the excavator on the traffic lane, a smaller amount of traffic is provided, which means less energy consumption and a higher speed of work. The results of the conducted research can be used in the design of software and hardware systems for controlling moving objects, in particular, control systems for the motion of an excavator manipulator.

NeuroLISP: High-level symbolic programming with attractor neural networks

Despite significant improvements in contemporary machine learning, symbolic methods currently outperform artificial neural networks on tasks that involve compositional reasoning, such as goal-directed planning and logical inference. This illustrates a computational explanatory gap between cognitive and neurocomputational algorithms that obscures the neurobiological mechanisms underlying cognition and impedes progress toward human-level artificial intelligence. Because of the strong relationship between cognition and working memory control, we suggest that the cognitive abilities of contemporary neural networks are limited by biologically-implausible working memory systems that rely on persistent activity maintenance and/or temporal nonlocality. Here we present NeuroLISP, an attractor neural network that can represent and execute programs written in the LISP programming language. Unlike previous approaches to high-level programming with neural networks, NeuroLISP features a temporally-local working memory based on itinerant attractor dynamics, top-down gating, and fast associative learning, and implements several high-level programming constructs such as compositional data structures, scoped variable binding, and the ability to manipulate and execute programmatic expressions in working memory (i.e., programs can be treated as data). Our computational experiments demonstrate the correctness of the NeuroLISP interpreter, and show that it can learn non-trivial programs that manipulate complex derived data structures (multiway trees), perform compositional string manipulation operations (PCFG SET task), and implement high-level symbolic AI algorithms (first-order unification). We conclude that NeuroLISP is an effective neurocognitive controller that can replace the symbolic components of hybrid models, and serves as a proof of concept for further development of high-level symbolic programming in neural networks.

An Automatic Drawing Spur Gears Based on AutoCAD Program

In this research, a computer-aided drawing system of spur gear was developed. An auto LISP programming language embedded within the AutoCAD design package was used to develop a new program to create a 3D model of a spur gear in two main stages. In the first stage, the developed program of spur gear allows automatic 2D spur gear drawing generation using the technique that depends on the half tooth thickness at the pitch diameter. In the second stage, inner profiles of a 2D spur gear views are used to create a 3D model of a spur gear. The developed program helpful for the user in drawing the spur gear modelling, due to less work and time to be spent when compared with the conventional approach, and it also improves a high degree of accuracy of spur gear modelling. The spur gear resulting from the prepared gear drawing system can also work with other popular CAD software.

Reducing the detection of genuine entanglement of n qubits to two qubits

We propose a criterion for the detection of genuine entanglement of pure multiqubit states. To this aim, we define an operator called the losing one qubit operator, which is different from the reduced density operator. The states obtained from a multiqubit state by applying the losing one qubit operator are referred to as its projected states. We show that all of the projected states of a pure product n-qubit state are pure product states provided that it cannot be written as a product of a single qubit state and a genuinely entangled (\(n-1\))-qubit state. We also show that a pure n-qubit state is genuinely entangled provided that the state has at least two genuinely entangled (\(n-1\))-qubit projected states. By repeating the losing process, we reduce the detection of entanglement of pure n-qubit states to the one of pure two-qubit states. Also we write a LISP program for the reduction process.

Some preliminaries to the study of traces in linguistics

The present paper constitutes a brief advance of much longer and more detailed ongoing work on the concept of “trace” in contemporary linguistic theory, particularly in syntax. It is commonly believed that the idea was coined by Noam Chomsky. However, we already detect its use, with a very accurate value, in the early work of Zellig Harris on mathematical linguistics or, to be more precise, on mathematical structures of language. In its origins, rather than being an index responsible for marking the location occupied by a unit previous to its syntactic movement (which always takes the form of fronting ), the trace was the result of a matrix product between n-adic functions. Thus, in Harris the trace is primarily a concept anchored in matrix calculus, or, put it differently, an algebraic notion. Chomsky’s notion, on its turn, is closely related with the LISP programming language. This text seeks to provide a preliminary analysis of the conceptual complexity implied in the concept of trace, which linguists should become aware of, for otherwise they will be doomed to be entangled in misunderstandings unfruitful to our discipline for decades to come.

Some preliminaries to the study of traces in linguistics

The present paper constitutes a brief advance of much longer and more detailed ongoing work on the concept of “trace” in contemporary linguistic theory, particularly in syntax. It is commonly believed that the idea was coined by Noam Chomsky. However, we already detect its use, with a very accurate value, in the early work of Zellig Harris on mathematical linguistics or, to be more precise, on mathematical structures of language. In its origins, rather than being an index responsible for marking the location occupied by a unit previous to its syntactic movement (which always takes the form of fronting ), the trace was the result of a matrix product between n-adic functions. Thus, in Harris the trace is primarily a concept anchored in matrix calculus, or, put it differently, an algebraic notion. Chomsky’s notion, on its turn, is closely related with the LISP programming language. This text seeks to provide a preliminary analysis of the conceptual complexity implied in the concept of trace, which linguists should become aware of, for otherwise they will be doomed to be entangled in misunderstandings unfruitful to our discipline for decades to come.

Incorporating quotation and evaluation into Church's type theory

▪ is a version of Church's type theory that includes quotation and evaluation operators that are similar to quote and eval in the Lisp programming language. With quotation and evaluation it is possible to reason in ▪ about the interplay of the syntax and semantics of expressions and, as a result, to formalize syntax-based mathematical algorithms. We present the syntax and semantics of ▪ as well as a proof system for ▪. The proof system is shown to be sound for all formulas and complete for formulas that do not contain evaluations. We give several examples that illustrate the usefulness of having quotation and evaluation in ▪.

Lisp, Jazz, Aikido – Three Expressions of a Single Essence

The relation between Science (what we can explain) and Art (what we can't) has long been acknowledged and while every science contains an artistic part, every art form also needs a bit of science. Among all scientific disciplines, programming holds a special place for two reasons. First, the artistic part is not only undeniable but also essential. Second, and much like in a purely artistic discipline, the act of programming is driven partly by the notion of aesthetics: the pleasure we have in creating beautiful things. Even though the importance of aesthetics in the act of programming is now unquestioned, more could still be written on the subject. The field called "psychology of programming" focuses on the cognitive aspects of the activity, with the goal of improving the productivity of programmers. While many scientists have emphasized their concern for aesthetics and the impact it has on their activity, few computer scientists have actually written about their thought process while programming. What makes us like or dislike such and such language or paradigm? Why do we shape our programs the way we do? By answering these questions from the angle of aesthetics, we may be able to shed some new light on the art of programming. Starting from the assumption that aesthetics is an inherently transversal dimension, it should be possible for every programmer to find the same aesthetic driving force in every creative activity they undertake, not just programming, and in doing so, get deeper insight on why and how they do things the way they do. On the other hand, because our aesthetic sensitivities are so personal, all we can really do is relate our own experiences and share it with others, in the hope that it will inspire them to do the same. My personal life has been revolving around three major creative activities, of equal importance: programming in Lisp, playing Jazz music, and practicing Aikido. But why so many of them, why so different ones, and why these specifically? By introspecting my personal aesthetic sensitivities, I eventually realized that my tastes in the scientific, artistic, and physical domains are all motivated by the same driving forces, hence unifying Lisp, Jazz, and Aikido as three expressions of a single essence, not so different after all. Lisp, Jazz, and Aikido are governed by a limited set of rules which remain simple and unobtrusive. Conforming to them is a pleasure. Because Lisp, Jazz, and Aikido are inherently introspective disciplines, they also invite you to transgress the rules in order to find your own. Breaking the rules is fun. Finally, if Lisp, Jazz, and Aikido unify so many paradigms, styles, or techniques, it is not by mere accumulation but because they live at the meta-level and let you reinvent them. Working at the meta-level is an enlightening experience. Understand your aesthetic sensitivities and you may gain considerable insight on your own psychology of programming. Mine is perhaps common to most lispers. Perhaps also common to other programming communities, but that, is for the reader to decide...

Multi-planar detection optimization algorithm for the interval charging structure of large-diameter longhole blasting design based on rock fragmentation aspects

ABSTRACTThe charge structure is an important factor in the adjustment of the energy distribution of explosives and the control of the blasting effect, especially in an underground large-diameter longhole, for interval charge millisecond blasting design. To achieve a reasonable charge structure, a multi-planar detection optimization (MDO) algorithm for charge structures is proposed based on the Harries mathematical model and the superposition method. The vector size of a fragment is transformed into a scalar ruler, and the definition of the spatial non-uniformity evaluation factor is used in the MDO algorithm. A detailed methodology is implemented using a Visual LISP program and validated for a case study of the Fankou lead–zinc mine in China. The results reveal that the MDO algorithm can improve the rock fragmentation and increase the energy utilization rate of explosives in large-diameter longhole blasting operations. This algorithm could be extremely helpful in the process of underground mine blast optimization.

The LISP 2 Project

John McCarthy designed the LISP programming language for the symbolic computation typical of artificial intelligence at the time, and LISP was strongly associated with AI at least through the 1990s. By 1963, a number of ideas had been proposed for how LISP 1.5 could be improved and extended. This lead to the LISP 2 project, which was carried out at System Development Corporation by personnel from SDC and Information International, Inc., using the military AN/FSQ-32 computer. LISP 2 extended LISP 1.5 with ALGOL-like syntax, static type checking, efficient support for arithmetic and arrays, pattern-matching, and more, but the LISP 2 language failed to displace LISP 1.5. Despite this, LISP 2 foreshadowed later languages, such as ECL, Common Lisp, and Java. An online archive of LISP 2 documents and source code exists at the Computer History Museum, providing a snapshot of mid-1960s ARPA-funded research and development.

Industrial hardware and software verification with ACL2.

The ACL2 theorem prover has seen sustained industrial use since the mid-1990s. Companies that have used ACL2 regularly include AMD, Centaur Technology, IBM, Intel, Kestrel Institute, Motorola/Freescale, Oracle and Rockwell Collins. This paper introduces ACL2 and focuses on how and why ACL2 is used in industry. ACL2 is well-suited to its industrial application to numerous software and hardware systems, because it is an integrated programming/proof environment supporting a subset of the ANSI standard Common Lisp programming language. As a programming language ACL2 permits the coding of efficient and robust programs; as a prover ACL2 can be fully automatic but provides many features permitting domain-specific human-supplied guidance at various levels of abstraction. ACL2 specifications and models often serve as efficient execution engines for the modelled artefacts while permitting formal analysis and proof of properties. Crucially, ACL2 also provides support for the development and verification of other formal analysis tools. However, ACL2 did not find its way into industrial use merely because of its technical features. The core ACL2 user/development community has a shared vision of making mechanized verification routine when appropriate and has been committed to this vision for the quarter century since the Computational Logic, Inc., Verified Stack. The community has focused on demonstrating the viability of the tool by taking on industrial projects (often at the expense of not being able to publish much).This article is part of the themed issue 'Verified trustworthy software systems'.

AI and the Origins of the Functional Programming Language Style

The Lisp programming language is often described as the first functional programming language and also as an important early AI language. In the history of functional programming, however, it occupies a rather anomalous position, as the circumstances of its development do not fit well with the widely accepted view that functional languages have been developed through a theoretically-inspired project of deriving practical programming languages from the lambda calculus. This paper examines the origins of Lisp in the early AI programming work of the mid-to-late 1950s, and in particular in the work of Allen Newell, Cliff Shaw and Herbert Simon. Their 1956 program, the Logic Theory Machine, introduced new ideas about data and program structures that were articulated in response to perceived limitations in existing programming technique. Later writers, notably John Backus, have described these features as constituting a "programming language style" distinct from the traditional style that preceded it. The paper examines the origins of the earlier style in practices of manual computation, analyses the key technical differences between it and the style first manifested in the Logic Theory Machine, and concludes that programming practice and experience play a large and underappreciated role in the development of programming styles and languages.

The LISP 2 Project

John McCarthy designed the LISP programming language for the symbolic computation typical of artificial intelligence at the time, and LISP was strongly associated with AI at least through the 1990s. By 1963, a number of ideas had been proposed for how LISP 1.5 could be improved and extended. This lead to the LISP 2 project, which was carried out at System Development Corporation by personnel from SDC and Information International, Inc., using the military AN/FSQ-32 computer. LISP 2 extended LISP 1.5 with ALGOL-like syntax, static type checking, efficient support for arithmetic and arrays, pattern-matching, and more, but the LISP 2 language failed to displace LISP 1.5. Despite this, LISP 2 foreshadowed later languages, such as ECL, Common Lisp, and Java. An online archive of LISP 2 documents and source code exists at the Computer History Museum, providing a snapshot of mid-1960s ARPA-funded research and development.

COMPUTER-AIDED DESIGN, MANUFACTURE AND EXPERIMENTAL ANALYSIS OF A PAIR OF ELLIPTICAL SPUR GEARS

In this study, geometrical equations of elliptical spur gears, which are too difficult to manufacture by traditional methods and which require specific machines equipped with special techniques, are developed using the methods in the literature. Using these equations, a LISP program on AutoLISP is created to model elliptical spur gears on AutoCAD with desired tooth number and modules. Elliptical spur gears are manufactured with 5 different modules by Wire EDM through the above-mentioned package program. The variations in the center distances of elliptical spur gears, the most important parameter for workability of gears, are experimentally determined by a simple test unit designed and manufactured within the context this study. In addition, the surface roughness and hardness of elliptical spur gears are obtained and hydraulic pump and noise analysis results are discussed. The experimental and computer-aided results show that the elliptical spur gears may widely be used in many industrial and mechanical applications in the future.

Digital manufacturing of air-cooled single-cylinder engine block

This paper presents how the manufacturing technologies are designed for the assembly of a single-cylinder engine block, four strokes, air-cooled. It is presented, from the constructive and technological point of view, the design stages of the main element of the core of an engine, respectively, the engine block. This engine is currently used on light vehicle categories such as ATVs, quads, and motorcycles. In the researches, activities are developed such as the following: designing of various digital technologies to achieve virtual prototype, obtaining a prototype using additive manufacturing technologies, and manufacturing the engine block using CNC technologies, under a range of unique products or small series. Many of the designing activities are materialized in an original software system, named GENgine, developed by authors using Open DCL and Visual LISP programming environments.

Algorithm Differentiation in Lisp

Algorithm differentiation (AD) is a technique used to transform a program F computing a numerical function of one argument F(x) into another program G(p) that returns a pair, hF(p), F0(p)i where by F0(p) we mean the derivative of F with respect to its argument x, evaluated at x = p. That is, we have a program AD that takes as input a program, and returns another: G := AD(F). Over the years AD programs have been developed to allow F to be expressed in some specialized variant of a popular programming language L (FORTRAN, C, Matlab, Python) and where G is delivered in that language L or some other. Alternatively, executing F(p) is some environment will deliver hF0(p), F(p)i directly. AD tools have also been incorporated in computer algebra systems (CAS) such as Maple. A CAS is hardly necessary for the task of writing the AD program, since the main requirement is a set of tools for manipulation of an internal (typically tree) form of a program. In Lisp, a normal program is already in this form and so the AD program in Lisp (ADIL), the target F and the product G can all be expressed compactly in Lisp. In spite of the brevity and extensibility of the ADIL program, we can provide features which are unsupported in other AD programs. In particular, recursive functions are easily accommodated. Our perspective here is to point out that for scientists who write programs in Lisp or any language that can be converted to Lisp, AD is easily at hand.

A visual LISP program for voxelizing AutoCAD solid models

AutoCAD solid models are increasingly recognized in geological and geotechnical 3D modeling. In order to bridge the currently existing gap between AutoCAD solid models and the grid modeling realm, a Visual LISP program is presented that converts AutoCAD solid models into voxel arrays. Acad2Vox voxelizer works on a 3d-model that is made up of arbitrary non-overlapping 3D-solids. After definition of the target voxel array geometry, 3D-solids are scanned at grid positions and properties are streamed to an ASCII output file. Acad2Vox has a novel voxelization strategy that combines a hierarchical reduction of sampling dimensionality with an innovative use of AutoCAD-specific methods for a fast and memory-saving operation. Acad2Vox provides georeferenced, voxelized analogs of 3D design data that can act as regions-of-interest in later geostatistical modeling and simulation. The Supplement includes sample geological solid models with instructions for practical work with Acad2Vox.

Practice Research on Design Concept of AutoCAD Based on Auto LISP Programming Language

By applying the Auto LISP programming language to the design concept of AutoCAD, this paper realizes the secondary development of AutoCAD software. Through the Auto LISP design, this paper implements three kinds of constituted artistic effects for the fractal tree of landscape architecture, namely, plane, color and stereo. At the same time, this paper establishes the fractal mathematical models and algorithms for the landscape design. In addition, the entity model of landscape is built through the AutoCAD landscape design library and the fractal tree is established in the entity model. Through the three-dimensional rendering of plane, stereo and color, this paper achieves wonderful digital multimedia visual communication effect. Thus, it provides a technical support and theoretical reference for the computer simulation design of modern landscape.

An Approach for Automatic Generation of Multi-Mode 3D Exploded View

The author presents an approach to assist furniture engineers in generating multi-mode 3D exploded view automatically under the environment of AutoCAD platform. Based on the secondary development of AutoCAD with Visual LISP programming language, the approach proposed in this paper can allow users to generate 3D exploded view interactively, either centring on a fundamental part or just exploding the target parts. The automated procedure for generation of multi-mode 3D exploded view is explained and applied with a wooden armchair taken as example, obtaining feasible solutions.

Mathematical knowledge management in algebraic topology

The work presented in this thesis tries to particularize Mathematical Knowledge Management to Algebraic Topology. Mathematical Knowledge Management is a branch of Computer Science whose main goal consists in developing integral assistants for Mathematics including computation, deduction and powerful user interfaces able to make the daily work of mathematical researchers easier. Our application context is Algebraic Topology using the Kenzo system [1], a Common Lisp program devoted to Algebraic Topology developed by Francis Sergeraert, as an instrumental tool. We can split the work presented in this thesis into three main parts which coincide with the main goals of Mathematical Knowledge Management. Our first task has consisted in developing a system called fKenzo [2], an acronym of friendly Kenzo. This system not only provides a friendly graphical user interface to interact with the Kenzo system (the kernel of our application) but also guides the interaction of the user with the system (avoiding in this way execution errors). Moreover, fKenzo allows one to integrate other symbolic computation systems (such as GAP) and theorem prover tools (for instance, ACL2 ) by means of a plug-in system. The second part of the thesis is focussed on increasing the computational capabilities of the Kenzo system. Three new Kenzo modules have been developed which in turn extend the fKenzo system. The first one allows us to study the pushout of simplicial sets, an important construction