nach oben

Erschienen in:

2013 | OriginalPaper | Buchkapitel

1. Introduction

verfasst von : Iliano Cervesato

Erschienen in: The Deductive Spreadsheet

Verlag: Springer Berlin Heidelberg

Einloggen

Aktivieren Sie unsere intelligente Suche, um passende Fachinhalte oder Patente zu finden.

search-config

KI-gestützte Suche

Aus

Abstract

This introductory chapter motivates the deductive spreadsheet and outlines our approach. In Sect. 1.1 we identify three useful classes of reasoning problems that the deductive spreadsheet should support. In Sect. 1.2, we characterize the target audience of this tool. In Sect. 1.3 we review existing deductive technology, pointing out drawbacks and taking note of useful features in the spreadsheet context. We sketch our approach in Sect. 1.4 and demonstrate it on an extended example in Sect. 1.5. We discuss related work in Sect. 1.6. The concluding Sect. 1.7 outlines the organization of the remainder of this book.

Sie haben noch keine Lizenz? Dann Informieren Sie sich jetzt über unsere Produkte:

Springer Professional "Wirtschaft+Technik"

Online-Abonnement

Mit Springer Professional "Wirtschaft+Technik" erhalten Sie Zugriff auf:

über 102.000 Bücher
über 537 Zeitschriften

aus folgenden Fachgebieten:

Automobil + Motoren
Bauwesen + Immobilien
Business IT + Informatik
Elektrotechnik + Elektronik
Energie + Nachhaltigkeit
Finance + Banking
Management + Führung
Marketing + Vertrieb
Maschinenbau + Werkstoffe
Versicherung + Risiko

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Technik"

Online-Abonnement

Mit Springer Professional "Technik" erhalten Sie Zugriff auf:

über 67.000 Bücher
über 390 Zeitschriften

aus folgenden Fachgebieten:

Automobil + Motoren
Bauwesen + Immobilien
Business IT + Informatik
Elektrotechnik + Elektronik
Energie + Nachhaltigkeit
Maschinenbau + Werkstoffe

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Wirtschaft"

Online-Abonnement

Mit Springer Professional "Wirtschaft" erhalten Sie Zugriff auf:

über 67.000 Bücher
über 340 Zeitschriften

aus folgenden Fachgebieten:

Bauwesen + Immobilien
Business IT + Informatik
Finance + Banking
Management + Führung
Marketing + Vertrieb
Versicherung + Risiko

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Nächstes Kapitel Requirements

I cannot pass on the following anecdote: A friend of mine, a physician by trade, discovered the personal computer and Excel a few years ago. Within a month, he had entered several years of financial data for all the stocks he owned, together with various formulas to predict their trend. He never found the silver bullet that would allow him to beat the market, but he eventually turned his self-taught Excel skills to medicine and built a sophisticated application to track the cardiac history of his patients. It is believed that several lives were saved in that way.

The language underlying Prolog differs from Datalog by removing all restrictions on the structure of values: this enables very powerful forms of reasoning, but also the possibility of non-termination.

This mockup screenshot was produced by inputting the displayed values in Microsoft Excel 2010. We will base illustrations throughout the book on this and other versions of Excel, and occasionally of other spreadsheet applications.

The inference rules are displayed using Prolog syntax as Excel comments. In Chap. 9, we will develop a more polished user interface and a concrete syntax for the deductive spreadsheet.

This interest was evident in the Workshop on Logical Spreadsheets (WOLS’05) held at Stanford University in the summer of 2005. The presented systems fell into two clear classes: proposals which allowed the Prolog-style computation of new values from existing values, and systems which provided support for bidirectional constraints. The design discussed in this book falls into the first class.

This “lessons-learned” paper describes LDL++, a deductive database system that incorporates many of the standard features found in the commercial relational database management systems of the time. As it does so, it pays particular attention to the foundational aspects, in particular its model and fixpoint theory, but also to its architecture as a system and the operational support within.

This paper describes Meld, a variant of Datalog designed to program modular ensembles of millions of cyber-physical agents capable of sensing, actuation and computation. Using Meld, these ensembles are programmed as if they were a single entity.

This book describes the COCOMO framework for accurately estimating software cost and schedules, and for supporting trade-off, risk, sensitivity, and business case analyses for software decisions. It expands older versions of COCOMO to today’s software engineering approaches, which are more evolutionary, risk-driven and collaborative, and less focused on developing systems from the scratch.

This paper describes Forms/3, a conservative extension of the traditional spreadsheet with procedural abstractions such as recursion, data abstractions such as graphical values, and graphic time-based output. As it does so, it strives to maintain the usability characteristics that have made the spreadsheet popular with end-users.

This paper explores an approach to defining an effective fixpoint semantics for a fragment of first-order linear logic. This semantics yields a decision procedure akin to symbolic model checking for some classes of concurrent systems.

In this early study of how people use spreadsheets, the authors monitored nine experienced users building three predefined spreadsheets. They found that nearly half of the spreadsheets they wrote contained errors. They also found that very little time was dedicated to planning or to debugging.

This is the original paper on the attention investment model. It focuses on the initial attitude of non-professional end-users when given tasks that have a programming component (e.g., writing spreadsheet formulas or programming a VCR). In particular, the attention investment model examines the first steps these users take and tries to understand their actions based on task and system at hand.

This paper applies ideas explored in [ARLG + 09] to the problem of executing traditional algorithms in a multi-core setting. This is the first attempt at using a Datalog-like language for this purpose.

This paper observes that spreadsheets, as built by regular users, contain both a “surface” and a “deep” structure, and that many errors stem from the latter. It proposes a method for visualizing the deep structure and therefore helping users debug their spreadsheets.

This is the original article on the relational data model and the use of relational algebra as a query mechanism for databases. This article offers a rare glimpse of what it was like to use computers in the 1960s and of a vision that is still with us today (in a very prominent way).

This paper presents LLF, a logical framework based on the first instance of a linear dependent type theory. Linearity enables it to represent object formalisms with state, such as imperative programming languages. It also supports an operational semantics in the style of top-down logic programming that allows us to execute some of these specifications.

This work extends [vEOT86] to tables in the sense of relational algebra. It is still heavily based on incremental queries but now supports the display of multiple solutions in a tabular way. The implementation is based on the recently introduced graphical display. Several windows show different views of the system. However the basic input mode is still essentially through the command lines, with other windows used only for displaying results in a tabular way.

This paper attempts to rein in the high error rate found in spreadsheets by relying on “units” implicitly inferred from a spreadsheet rather than a rigid system of types. Such units are classified and correlated into dependent units, multiplicities and generalizations, with the aim to capture the user’s intention and fend off mistakes.

This paper discusses the design and prototype implementation of Knowledgesheet, an extension of the traditional spreadsheet paradigm with bidirectional constraints, so that any number of cells linked by a system of constraints can be evaluated as soon as a sufficient number of them has been assigned a value. This allows us to use the spreadsheet metaphor to solve two-dimensional constraint satisfaction problems such as scheduling and building time tables.

This paper is concerned with the problem of propagating the effect of fact updates in a Datalog program. To this effect, it associates a counter to inferred facts, thereby counting in how many ways a fact can be derived. Relevant counters are increased or decreased whenever an assertion or deletion changes the provability of inferred atoms.

This paper applies the cognitive dimensions of notation framework to the evaluation for visual programming environments, finding it particularly effective and a good complement for other techniques.

This call-for-proposals fueled a revival in interest in extending spreadsheets with deductive capabilities. As a result, many researchers reconsidered the problem and devised new and innovative solutions to it.

This papers describes NetLog, an extension of Datalog with communication primitives and aggregation for the purpose of describing communication protocols, peer-to-peer applications, and other distributed systems. A distributed fixpoint semantics is devised, as well as syntactic restrictions aimed at limiting the cost of network communications.

This paper describes Curry, a functional-logic programming language for the research, teaching, and applications, as well as the foundations of this paradigm.

This paper proposes SWRL, a semantic web rule language based on a combination of two fragments of the OWL web ontology language with a sublanguage of RuleML, a variant of Datalog. It gives a model-theoretic semantics of SWRL ontologies and demonstrates it on a number of examples.

This paper describes PrediCalc, an extension of the traditional spreadsheet with bidirectional constraints that blurs the distinction between input data and computed values. Its bidirectional propagation mechanism automatically makes values available for further computation as soon as constraints are solvable. It also embeds an approach for handling the inconsistencies that may arise while solving constraints.

This master’s thesis is regarded as the first attempt ever to combine spreadsheets and logic programming. See the discussion in the polished version [Kri88].

This work refines [Kri82] and implements its design as a system called LogiCalc. Its initial goal was to “reconstruct logically, in micro-Prolog, a typical spreadsheet program”. Besides capturing most of the functionalities of early spreadsheets, it provides powerful extensions such as relational manipulations, integrity constraints, bidirectional variables, symbolic reasoning, and complex objects (e.g., lists, graphics and spreadsheets themselves). It is based on the limited teletype interface that predated the widespread availability of graphical user interfaces with windows. LogiCalc relies a lot on user input, even for non-essential tasks.

This paper models the propagation of the assertion of new facts or the retraction of old facts in the Datalog system by means of inference in linear logic. To this effect, it translates Datalog clauses into linear logic formulas that also contain specifications about how to propagate updates.

This paper proposes a variant of Datalog as a language for declarative specifications in computer networks. To this effect, it adapts the semi-naïve evaluation strategy to operate efficiently in asynchronous distributed settings and to account for bursts of updates. It also explores optimization opportunities in network applications.

This paper shows how Datalog can fruitfully be used to specify access control and trust management policies in order to decide authorization and access in a distributed system of computers. To this effect, it extends Datalog with constraints over signed messages. The paper explores the theoretical properties of the resulting language and relates it to other authorization and trust management languages.

This paper presents a general description classifier for first-order logic extended with sets, equality and scalar inequality. A description classifier is a method to organize concepts and relations into a taxonomy based on subsumption.

This now classic paper was the first to establish top-down logic programming on solid proof-theoretic grounds. The methodology it embraced, based on the notion of uniform proofs, identified fragments of logic larger than Prolog’s Horn clauses that could be used for programming. Specifically, it shows that hereditary Harrop formulas, which extend Horn clauses with embedded implication, fit into this pattern, and so do higher-order variants of both languages.

This paper explores an efficient asynchronous algorithm to incrementally compute the changes to the states of a distributed Datalog system, as proposed in some network protocols and multi-agent systems, in response to the insertions and deletions of base facts.

This very influential article carried out a systematic study of the number and type of errors found in spreadsheets. At the outset, the results are surprisingly high, which should limit our confidence about decisions made on the basis of spreadsheet calculations. This research also finds that this type and number is similar to programming in general, except that software engineering has developed methods to curb this error rate, while spreadsheet users take a more informal approach.

This paper proposes a method for extending the traditional spreadsheet with user-defined functions without the expectation that an everyday user will acquire the sophistication of an addon programmer. This work relies on cognitive psychology techniques such as the cognitive dimension of notations and the attention investment model to retain the usability that characterizes the traditional spreadsheet. This work was extremely influential in the development of the deductive spreadsheet.

This web site gives a fascinating description of how the modern spreadsheet came about, how it evolved from the “books” that accountants have used for millennia and how a Harvard Business School student, Dan Bricklin, envisioned and then realized an electronic version of it. This is a good complement to Bricklin’s own account of the invention of the spreadsheet [Bri09].

This paper describes the XcelLog deductive spreadsheet system [RRW07] with particular emphasis on using the spreadsheet metaphor for the purpose of taming the rule interactions. It also discusses the details of its implementation as an Excel addon powered by the XSB tabled logic programming system [War98] as a back-end.

This paper describes the design and implementation of XcelLog, an extension of the traditional spreadsheet with deductive capabilities. Like the proposal in this book, XcelLog is meant to retain the usability of the spreadsheet while enabling end-users to use it to draw logical consequences. The approach treats sets as the fundamental data type and inference rules as specifying among sets. The spreadsheet metaphor is used to create and view the materialized sets. The implementation relies on the XSB system [War98].

This paper reviews the state of the art of bottom-up evaluation and proposes a transformation on Datalog programs to speed up that semi-naïve evaluation. It also discusses extensions to negation, set terms, constraints and quantitative reasoning. Comparisons with numerous systems are included.

This paper describes CORAL, an advanced deductive database system featuring optimized queries, modularity, and extensibility.

This brief but excellent survey of the development of deductive databases up to 1993 contains very little theory, but gives a clear intuition of what deductive databases are good for. It describes the major projects and their contributions to the field. The references are particularly useful.

This paper explores approaches to curbing the error rate in spreadsheets observed by [Pan98]. It does so through two auditing modalities for visualizing the flow of information, both based on the underlying dependencies and on how people actually use spreadsheets.

This work proposes to combine logic programming and spreadsheets under the umbrella of the PERPLEX system. It does so by making heavy use of integrity constraints in a way that is clearly expressive, but likely to be unnatural for an entry-level user. PERPLEX supports exploratory programming and the paradigm of “query-by-example” to perform many programming tasks. While very powerful, it is not clear that this blends smoothly in the spreadsheet mindset. This is the first logical spreadsheet extension to make use of graphical input and not just output.

This is another classic introductory textbook on programming in Prolog that has been used by generations of students.

This paper explores an extension of the traditional spreadsheet with logical reasoning capabilities aimed at capturing the semantics of a binary relation by using spreadsheet artifacts to specify its image. This model is internally translated into a system of clauses. A prototype has been implemented as an Excel addon.

This paper describes a logic-based application that extends Microsoft Excel with mechanisms to flag a range or a cell as part of a relation. These relations are automatically copied into a deductive logic engine implementing the OWL+SWRL ontology language [HPSB + 04]. The extension also contains mechanisms to populate a range with values deduced by evaluating logic rules.

This two-volume set reviews the theory and practice of databases as of the late 1980s, with an eye towards then-emerging technologies such as object-oriented databases, deductive databases and security issues. It also explores their application to reasoning tasks, especially in the area of knowledge management.

This paper describes an implementation of the concept of incremental query, by which a standard Prolog query can be refined interactively, and its application for solving spreadsheet-like problems. The output takes the form of the rudimentary, teletype-based, spreadsheets of the time; the input is however still given from the command line. While taking limited advantage of the input facilities of a spreadsheet, this extends their typical functionalities with forms of symbolic reasoning. Multiple solutions are however shown one at a time. The whole system is implemented in Prolog, and efficiently realizes top-down search with intelligent backtracking. The claims to target relatively smart users rather than expert programmers is hardly met.

This paper combines the traditional spreadsheet and an expressive knowledge representation and reasoning system into LESS, a logic-based extension of the spreadsheet. LESS supports reasoning with arbitrary first-order logic formulas, subsumption, classifications, higher-order constructs and much more. This expressiveness is brokered to the user by offering four modalities requiring increasing levels of sophistication for users to interact with the system.

XSB is Prolog with a form of memoization called tabling. Declaratively, it does not differ substantially from Prolog. Procedurally, however, it substantially improves on the standard top-down SLDNF resolution strategy of this language by nearly eradicating control-induced infinite loops. In particular, an XSB query always terminates against a Datalog program. Tabling can also have a positive effect on efficiency, although this may depend on how the user writes his programs. This makes XSB a promising candidate as the underlying explanation engine of a deductive spreadsheet.

This paper describes the foundations of a language where top-down and bottom-up execution work together toward modeling concurrent and distributed problems. This language is based on linear logic and takes a type-theoretic approach. Distinct fragments support top-down and bottom-up execution, and they are mediated by means of a monad.

In just three pages, this precious little overview describes deductive databases, recalls their history, and outlines the main open research problems. It is followed by a much longer set of references to the main papers that led to their development.

[AOT + 03].

Arni, F., Ong, K., Tsur, S., Wang, H., & Zaniolo, C. (2003). The deductive database system LDL++. Theory and Practice of Logic Programming, 1, 61–94. ⁶

[ARLG + 09].

Ashley-Rollman, M. P., Lee, P., Goldstein, S. C., Pillai, P., & Campbell, J. D. (2009). A language for large ensembles of independently executing nodes. In Proceedings of ICLP’09, Pasadena (Lecture notes in computer science, Vol. 5649, pp. 265–280). Springer. ⁷

[BAB + 00].

Boehm, B. W., Abts, C., Brown, A. W., Chulani, S., Horowitz, E., Madachy, R., Reifer, D., Clark, B. K., & Steece, B. (2000). Software cost estimation with COCOMO II. Upper Saddle River: Prentice Hall. ⁸

[BAD + 01].

Burnett, M., Atwood, J., Djang, R. W., Reichwein, J., Gottfried, H., & Yang, S. (2001). Forms/3: A first-order visual language to explore the boundaries of the spreadsheet paradigm. Journal of functional programming, 11(2), 155–206. ⁹

[BDM01].

Bozzano, M., Delzanno, G., & Martelli, M. (2001). An effective bottom-up semantics for first order linear logic programs. In Proceedings of FLOPS 2001, Tokyo, Japan (Lecture notes in computer science, Vol. 2024, pp. 138–152). Springer ¹⁰

[BG87].

Brown, P., & Gould, J. (1987). Experimental study of people creating spreadsheets. ACM Transactions on Office Information Systems, 5, 258–272. ¹¹

[Bla02].

Blackwell, A. (2002). First steps in programming: A rationale for attention investment models. In Conference on human-centric computing languages and environments, Arlington (pp. 2–10). IEEE Computer Society. ¹²

[CARG + 12].

Cruz, F., Ashley-Rollman, M. P., Goldstein, S. C., Rocha, R., & Pfenning, F. (2012). Bottom-up logic programming for multicores. In V. S. Costa (Ed.), Proceedings of 7th international workshop on declarative aspects and applications of multicore programming – DAMP’12, Philadelphia. ¹³

[CC00].

Chen, Y., & Chan, H. C. (2000). Visual checking of spreadsheets. In Conference of the European spreadsheet risks interest group – EuSpRIG’00, London, UK (pp. 75–85). ¹⁴

[Cod70].

Codd, E. F. (1970). A relational model of data for large shared data banks. Communication of the ACM, 13(6), 377–387. ¹⁵

[CP02].

Cervesato, I., & Pfenning, F. (2002). A linear logical framework. Information & Computation, 179(1), 19–75. ¹⁶

[CvEL88].

Cheng, M. H. M., van Emden, M. H., & Lee, J. H. -M. (1988). Tables as a user interface for logic programs. In Fifth generation computer systems, Tokyo (pp. 784–791). ¹⁷

[EB02].

Erwig, M., & Burnett, M. (2002). Adding apples and oranges. In Practical aspects of declarative languages, 4th international symposium – PADL’02, Portland (Lecture notes in computer science, Vol. 2257, pp. 173–191). Springer. ¹⁸

[GA00].

Gupta, G., & Akhter, S. (2000). Knowledgesheet: A graphical spreadsheet interface for interactively developing a class of constraint programs. In Proceedings of the second international workshop practical aspects of declarative languages – PADL’00, Boston (Lecture notes in computer science, Vol. 1753, pp. 308–323). Springer. ¹⁹

[GMS93].

Gupta, A., Mumick, I. S., & Subrahmanian, V. S. (1993). Maintaining views incrementally. In Proceedings of the 1993 SIGMOD international conference on management of data – SIGMOD’93, Washington, DC (pp. 157–166). ACM. ²⁰

[GP96].

Green, T., & Petre, M. (1996). Usability analysis of visual programming environments: A “cognitive dimensions” framework. Journal of Visual Languages and Computing, 7, 131–174. ²¹

[Gun04].

Gunning, D. (2004). DARPA SBIR 2004.3, topic sb043-040: Deductive spreadsheets. ²²

[GW10].

Grumbach, S., & Wang, F. (2010). Netlog, a rule-based language for distributed programming. In Proceedings of 12th international symposium on practical aspects of declarative languages – PADL’10, Madrid (Lecture notes in computer science, Vol. 5937, pp. 88–103). Springer. ²³

[Han94].

Hanus, M. (1994). The integration of functions into logic programming: From theory to practice. Journal of Logic Programming, 19–20, 583–628. ²⁴

[HPSB + 04].

Horrocks, I., Patel-Schneider, P., Boley, H., Tabet, S., Grosof, B., & Dean, M. (2004). SWRL: A semantic web rule language combining OWL and RuleML. Available at http://www.w3.org/Submission/SWRL/. ²⁵

[KG07].

Kassoff, M., & Genesereth, M. (2007). PrediCalc: A logical spreadsheet management system. The Knowledge Engineering Review, 22(03), 281–295. ²⁶

[Kri82].

Kriwaczek, F. (1982). Some applications of Prolog to decision support systems. Master’s thesis, Imperial College, London. ²⁷

[Kri88].

Kriwaczek, F. (1988). Logicalc: A Prolog spreadsheet. Machine intelligence, 11, 193–208. ²⁸

[LC12].

Lam, E. S. L., & Cervesato, I. (2012). Modeling datalog fact assertion and retraction in linear logic. In A. King (Ed.), Proceedings of the 14th international ACM symposium on principles and practice of declarative programming – PPDP’12, Leuven. ²⁹

[LCG + 06].

Loo, B. T., Condie, T., Garofalakis, M., Gay, D. E., Hellerstein, J. M., Maniatis, P., Ramakrishnan, R., Roscoe, T., & Stoica, I. (2006). Declarative networking: Language, execution and optimization. In Proceedings of the 2006 SIGMOD international conference on management of data – SIGMOD’06, Chicago (pp. 97–108). ACM. ³⁰

[LM03].

Li, N., & Mitchell, J. C. (2003). Datalog with constraints: A foundation for trust management languages. In Proceedings of the fifth international symposium on practical aspects of declarative languages (PADL’03), New Orleans. ³¹

[Mac94].

MacGregor, R. (1994). A description classifier for the predicate calculus. In Proceedings of the twelfth national conference on artificial intelligence – AAAI’94, Seattle (pp. 213–220). ³²

[MNPS91].

Miller, D., Nadathur, G., Pfenning, F., & Scedrov, A. (1991). Uniform proofs as a foundation for logic programming. Annals of Pure and Applied Logic, 51, 125–157. ³³

[NJLS11].

Nigam, V., Jia, L., Loo, B. T., & Scedrov, A. (2011). Maintaining distributed logic programs incrementally. In Proceedings of the 13th international ACM symposium on principles and practice of declarative programming – PPDP’11, Odense (pp. 125–136). ACM. ³⁴

[Pan98].

Panko, R. R. (1998). What we know about spreadsheet errors. Journal of End User Computing (Special issue on Scaling Up End User Development), 10(2), 15–21. Available at http://panko.shidler.hawaii.edu/ssr/Mypapers/whatknow.htm. ³⁵

[PBB03].

Peyton-Jones, S., Blackwell, A., & Burnett, M. (2003). A user-centred approach to functions in Excel. In Proceedings of the eighth ACM SIGPLAN international conference on functional programming, Uppsala (pp. 165–176). ACM. ³⁶

[Pow03].

Power, D. J. A brief history of spreadsheets. http://www.dssresources.com/history/sshistory.html, 10/04/2003. DSSResources.Com. ³⁷

[RRW06].

Ramakrishnan, C. R., Ramakrishnan, I. V., & Warren, D. S. (2006). Deductive spreadsheets using tabled logic programming. In Proceedings of the 22nd international conference on logic programming – ICLP’06, Seattle (pp. 391–405). ³⁸

[RRW07].

Ramakrishnan, C. R., Ramakrishnan, I. V., & Warren, D. S. (2007). XcelLog: A deductive spreadsheet system. The Knowledge Engineering Review, 22(03), 269–279. ³⁹

[RSS92].

Ramakrishnan, R., Srivastava, D., & Sudarshan, S. (1992). Efficient bottom-up evaluation of logic programs. In P. Dewilde & J. Vandewalle (Eds.), The state of the art in computer systems and software engineering. Kluwer Academic. ⁴⁰

[RSSS94].

Ramakrishnan, R., Srivastava, D., Sudarshan, S., & Seshadri, P. (1994). The CORAL deductive system. Journal of Very Large Databases, 3(2), 161–210. ⁴¹

[RU95].

Ramakrishnan, R., & Ullman, J. D. (1995). A survey of deductive database systems. Journal of Logic Programming, 23(2), 125–149. ⁴²

[Saj00].

Sajaniemi, J. (2000). Modeling spreadsheet audit: A rigorous approach to automatic visualization. Journal of Visual Languages and Computing, 11, 49–82. ⁴³

[SB89].

Spenke, M., & Beilken, C. (1989). A spreadsheet interface for logic programming. In CHI’89: Proceedings of the SIGCHI conference on human factors in computing systems, Austin (pp. 75–80). ACM. ⁴⁴

[SS94].

Sterling, L., & Shapiro, E. (1994). The art of Prolog (2nd ed.). Cambridge: MIT. ⁴⁵

[TB08].

Tallis, M., & Balzer, R. M. (2008). A functional spreadsheet framework for authoring logic implication rules. In N. Bassiliades, G. Governatori, & A. Paschke (Eds.), Proceedings of the seventh international symposium on rule interchange and applications – RuleML’08, Orlando (Lecture notes in computer science, Vol. 5321, pp. 219–226). Springer. ⁴⁶

[TWB07].

Tallis, M., Waltzman, R., & Balzer, R. (2007). Adding deductive logic to a COTS spreadsheet. The Knowledge Engineering Review, 22(03), 255–268. ⁴⁷

[Ull88].

Ullman, J. D. (1988). Principles of database and knowledge-base systems (Vol. 3). Rockville: Computer Science Press. ⁴⁸

[vEOT86].

van Emden, M. H., Ohki, M., & Takeuchi, A. (1986). Spreadsheets with incremental queries as a user interface for logic programming. New Generation Computing, 4(3), 287–304. ⁴⁹

[VvBCE07].

Valente, A., van Brackle, D., Chalupsky, H., & Edwards, G. (2007). Implementing logic spreadsheets in LESS. The Knowledge Engineering Review, 22(03), 237–253. ⁵⁰

[War98].

Warren, D. S. (1998). Programming with tabling in XSB. In D. Gries & W. P. de Roever (Eds.), Programming concepts and methods, IFIP TC2/WG2.2,2.3 international conference on programming concepts and methods (PROCOMET’98): Vol. 125 of IFIP conference proceedings, Shelter Island (pp. 5–6). Chapman & Hall. ⁵¹

[WCPW03].

Watkins, K., Cervesato, I., Pfenning, F., & Walker, D. (2003). A concurrent logical framework: The propositional fragment. In Types for proofs and programs: Proceedings of the TYPES 2003 international workshop, Torino (Lecture notes in computer science, Vol. 3085, pp. 355–377). Springer. ⁵²

[Zan99].

Zaniolo, C. (1999). A short overview of deductive database systems. In W. Kloesgen & J. Zytkow (Eds.), The handbook of data mining and knowledge discovery. Oxford/New York: Oxford University Press. ⁵³

Titel: Introduction
verfasst von: Iliano Cervesato
Verlag: Springer Berlin Heidelberg
Buch: The Deductive Spreadsheet
Print ISBN: 978-3-642-37746-4

Electronic ISBN: 978-3-642-37747-1

Copyright-Jahr: 2013
DOI: https://doi.org/10.1007/978-3-642-37747-1_1

Springer Professional

Abstract

Bitte loggen Sie sich ein, um Zugang zu Ihrer Lizenz zu erhalten.

Sie haben noch keine Lizenz? Dann Informieren Sie sich jetzt über unsere Produkte:

Springer Professional "Wirtschaft+Technik"

Springer Professional "Technik"

Springer Professional "Wirtschaft"