Mira Balaban

Understanding music with AI: perspectives on music cognition

Part 1 Two views on cognitive musicology: artificial intelligence and music - cornerstone of cognitive musicology, O. Laske beyond computational musicology, P. Kugel. Part 2 General problems in modeling musical activities: representing listening behaviour - problems and prospects, S.W. Smoliar symbolic and sonic representations of sound-object structures, B. Bel music structures - interleaving the temporal and hierarchical aspects in music, B. Balaban on designing a typed music language, E.B. Blevis, et al logical representation and induction for computer assisted composition, F. Courtot. Part 3 Music composition: cybernetic composer - an overview, C. Ames and M. Domino Wolfgang - a system using emoting potentials to manage musical design, R.D. Riecken on the application of problem reduction search to automated composition, S.C. Marsella and C.F. Schmidt the observer tradition of knowledge acquisition, O. Laske. Part 4 Analysis: an expert system for harmonizing chorales in the style of J.S. Bach, K. Ebcioglu an expert system for harmonic analysis of tonal music, H.J. Maxwell on the algorithmic representation of musical style, D. Cope. Part 5 Performance: Bol processor grammars, B. Bel and J. Kippen a new approach to music through vision, S. Ohteru and S. Hashimoto. Part 6 Perception: analyzing and representing musical rhythm, C. Linster on the perception of metre, B.O. Miller, et al the quantization problem - traditional and connectionist approaches, P. Desain and H. Honing. Part 7 Learning and tutoring: an architecture for an intelligent tutoring system, M.J. Baker a knowledge intensive approach to mcachine learning in tonal music, G. Widmer.

Efficient reasoning about finite satisfiability of UML class diagrams with constrained generalization sets

UML class diagrams play a central role in the design and specification of software, databases and ontologies. The model driven architecture approach emphasizes the central role that models play, towards achieving reliable software. It is important that models are correct and that problems are detected as early as possible in the software design process. However, current case tools do not support reasoning tasks about class diagrams and enable the construction of erroneous models. There is an urgent need for methods for detecting analysis and design problems. In this paper, we present a linear programming based method for reasoning about finite satisfiability of UML class diagrams with constrained generalization sets. The method is simple and efficient and can be easily added to a case tool. It improves over existing methods that require exponential resources and extends them to new elements of class diagrams.

The F-logic approach for description languages

The Frame-logic (F-logic) approach of [20] is suggested as an underlying framework for description languages. F-logic is shown to provide a full account for description languages without losing the direct semantics and the descriptive nature. It can support such desirable features as high-order role fillers, collective entities, intensions, roles as first-class objects, andn-ary relationships. Yet, its semantics is first order. In an F-logic based description language, few description constructs are built in, and concepts, roles,and terminological operators are definable. The discussion of desirable features in descriptions is made possible within a single, uniform framework that also coherently integrates with logic programming and deductive, object-oriented database technology. Typical descriptive operators can be defined in the language, thereby yielding a flexible description language in which not all operators must be built in.

The Music Structures Approach to Knowledge Representation for Music Processing

ion i Music Structures: Music Structure

Finite satisfiability of UML class diagrams with constrained class hierarchy

Models lie at the heart of the emerging model-driven engineering approach. In order to guarantee precise, consistent, and correct models, there is a need for efficient powerful methods for verifying model correctness. Class diagram is the central language within UML. Its correctness problems involve issues of contradiction, namely the consistency problem, and issues of finite instantiation, namely the finite satisfiability problem. This article analyzes the problem of finite satisfiability of class diagrams with class hierarchy constraints and generalization-set constraints. The article introduces the FiniteSat algorithm for efficient detection of finite satisfiability in such class diagrams, and analyzes its limitations in terms of complex hierarchy structures. FiniteSat is strengthened in two directions. First, an algorithm for identification of the cause for a finite satisfiability problem is introduced. Second, a method for propagation of generalization-set constraints in a class diagram is introduced. The propagation method serves as a preprocessing step that improves FiniteSat performance, and helps developers in clarifying intended constraints. These algorithms are implemented in the FiniteSatUSE tool [BGU Modeling Group 2011b], as part of our ongoing effort for constructing a model-level integrated development environment [BGU Modeling Group 2010a].

MEER—An EER model enhanced with structure methods

Abstract Entity relationship (ER) schemas include cardinality constraints, that restrict the dependencies among entities within a relationship type. The cardinality constraints have direct impact on the application maintenance, since insertions or deletions of entities or relationships might affect related entities. Indeed, maintenance of a system or of a database can be strengthened to enforce consistency with respect to the cardinality constraints in a schema. Yet, once an ER schema is translated into a logical database schema, or translated within a system, the direct correlation between the cardinality constraints and maintenance transactions is lost, since the components of the ER schema might be decomposed among those of the logical database schema or the target system. In this paper, a full solution to the enforcement of cardinality constraints in EER schemas is given. We extend the enhanced ER (EER) data model with structure-based update methods that are fully defined by the cardinality constraints. The structure methods are provably terminating and cardinality faithful , i.e., they do not insert new inconsistencies and can only decrease existing ones. A refined approach towards measuring the cardinality consistency of a database is introduced. The contribution of this paper is in the automatic creation of update methods, and in building the formal basis for proving their correctness.

Abstraction as a means for end-user computing in creative applications

End-user computing is needed in creative artistic applications or integrated editing environments, where the activity cannot be planned in advance. Following the paper by Orlarey et al., concrete abstractions (abstractions from examples) are suggested as a new mode for function definition, appropriate for end-user editor programmability. For certain applications, the direct, associative, not planned in advance character of concrete abstraction plays a qualitative role in the mere ability to specify abstractions. In this paper, we propose to use concrete abstraction as a general tool for end-user programmability in editors. We distinguish two kinds of abstractions: value abstraction and structure abstraction, and explain how they can be combined. We describe a framework of historical editing that is based on a double view, in which the two abstraction kinds are combined. Finally, BOOMS, an implemented prototype for such an editing framework, is described. BOOMS is a domain-independent toolkit, with three sample instantiations. We believe that the proposed framework captures the conceptualization operation that characterizes creative, associative work types and addresses the needs for end-user computing in integrated environments.

DFL -a dialog based integration of concept and rule reasoners

Abstract Description logics (DLs) are subsets of first-order logic (FOL), designed for reasoning about class-based knowledge. Their expressive power is deliberately restricted, so as to enable efficient inference. A DL reasoner or knowledge base is intended to be embedded as a special purpose component in a heterogeneous knowledge base. Therefore, the development of integration frameworks of DLs and other forms of reasoning is essentially important. In this paper, we introduce a formal scheme for the integration of information sources for which a combined declarative semantics is not available. The integration is defined by a syntactic compositional semantics, and implemented by a dialog process in which the independent reasoners make their failures public. This scheme is used to formalize the integration of a DL reasoner with an expressive rule reasoner (for which a combined declarative semantics is not known). It is implemented in the DFL system, that integrates a DL reasoner and an F-Logic rule reasoner. The integrated system gives rise to a rich dialog between its components, since the DL inferences can trigger new rule inferences, and rule inferences can trigger new DL inferences. The DFL system is the first to support a true dialog between a DL and a rule reasoners, that operate under different semantical policies, e.g., the open world assumption (OWA) for the DL reasoner, and the closed world assumption (CWA) for the rule reasoner. This architecture generalizes all existing hybrids of descriptions and rules.

Logic-based model-level software development with F-OML

Models are at the heart of the emerging Model-driven Engineering (MDE) approach in which software is developed by repeated transformations of models. Intensive efforts in the modeling community in the past two decades have produced an impressive variety of tool support for models. Nonetheless, models are still not widely used throughout the software evolution life cycle and, in many cases, they are neglected in later stages of software development. To make models more useful, one needs a powerful model-level IDE that supports a wide range of object modeling tasks. Such IDEs must have a consistent formal foundation. This paper introduces F-OML, a language intended as an expressive, executable formal basis for model-level IDEs. F-OML supports a wide variety of model-level activities, such as extending UML diagrams, defining design patterns, reasoning about UML diagrams, testing UML diagrams, specification of Domain Specific Modeling Languages, and meta-modeling. F-OML is a semantic layer on top of an elegant logic programming language of guarded path expressions, called PathLP. We believe that a combination of current object technology with F-OML as an underlying language can lay the basis for a powerful model-level IDE.

Hierarchical ER Diagrams (HERD) – The Method and Experimental Evaluation

HERD (Hierarchical Entity-Relationship Diagram) is a semi-algorithmic, bot-tom-up method for creating hierarchical ER diagrams (ERD) from a given ”flat“ diagram. The method is based on three packaging operations, which group entity and relationship types according to certain criteria. The packaging opera-tions are applied in several steps on a given (presumably large) ERD. The result is a hierarchy of simple and interrelated diagrams – ER structures – with external relationships to other structures. We conduct an experimental comparison of HERD and flat ERD from the point of view of user comprehension; time to complete comprehension tasks, and user preference of models. Results of the comparison reveal that there is no significant difference in comprehension of the two diagram types and in the time it takes to complete the comprehension tasks, but we found that users prefer HERD diagrams.