scholarly journals Specifying Hyperdocuments with Algebraic Methods

10.29007/3bwg ◽  
2018 ◽  
Author(s):  
Volker Mattick
Keyword(s):  
Programming Languages ◽  
Algebraic Methods ◽  
Algebraic Specification ◽  
Free Term ◽  
Functional Language ◽  
Markup Language ◽  
Abstract Syntax ◽  
Markup Languages ◽  
Compiler Construction ◽  
Graphical Presentation

Algebraic specification methods, well-known in the area of programming languages, are adapted to present a tailored framework for hyperdocuments and hyperdocument systems. In this framework, a hyperdocument is defined via its abstract syntax, which is a variable-free term of a suitable constructor-based signature. Both the representation in a markup language and the graphical presentation on the screen as well as further representations are elements of particular algebraic interpretations of the same signature. This technique allows the application of well-known methods from the field of compiler construction to the development of hyperdocument systems. Ideas for its implementation in the functional language Haskell are roughly drafted. It is shown how XML-based markup languages with schemas and stylesheets can be defined in terms of this framework and how this framework can be extended so that it can deal with partially specified documents, called semi documents. These semi documents can be automatically adapted to the users' needs, which e.g. is helpful to ensure accessibility.

Modular Rule-Based Promgramming in 2APL

2010 ◽  
pp. 25-49 ◽  
Author(s):  
Medhi Dastani
Keyword(s):  
Markup Language ◽  
Abstract Syntax ◽  
Narrow Sense ◽  
Design Issues ◽  
Markup Languages ◽  
Rule Based ◽  
Common Basis ◽  
Rule Languages ◽  
The Web

Rule markup languages will be the vehicle for using rules on the Web and in other distributed systems. They allow publishing, deploying, executing and communicating rules in a network. They may also play the role of a lingua franca for exchanging rules between different systems and tools. In a narrow sense, a rule markup language is a concrete (XML-based) rule syntax for the Web. In a broader sense, it should have an abstract syntax as a common basis for defining various concrete languages addressing different consumers. The main purposes of a rule markup language are to permit the publication, interchange and reuse of rules. This chapter introduces important requirements and design issues for general Web rule languages to fulfill these tasks. Characteristics of several important general standardization or standards-proposing efforts for (XML-based) rule markup languages including W3C RIF, RuleML, R2ML, SWRL as well as (human-readable) Semantic Web rule languages such as TRIPLE, N3, Jena, and Prova are discussed with respect to these identified issues.

scholarly journals Rule Markup Languages and Semantic Web Rule Languages

2010 ◽  
pp. 1-24 ◽  
Author(s):  
Adrian Paschke ◽  
Harold Boley
Keyword(s):  
Semantic Web ◽  
Markup Language ◽  
Abstract Syntax ◽  
Narrow Sense ◽  
Design Issues ◽  
Markup Languages ◽  
Common Basis ◽  
Rule Languages ◽  
The Web

Rule markup languages will be the vehicle for using rules on the Web and in other distributed systems. They allow publishing, deploying, executing and communicating rules in a network. They may also play the role of a lingua franca for exchanging rules between different systems and tools. In a narrow sense, a rule markup language is a concrete (XML-based) rule syntax for the Web. In a broader sense, it should have an abstract syntax as a common basis for defining various concrete languages addressing different consumers. The main purposes of a rule markup language are to permit the publication, interchange and reuse of rules. This chapter introduces important requirements and design issues for general Web rule languages to fulfill these tasks. Characteristics of several important general standardization or standards-proposing efforts for (XML-based) rule markup languages including W3C RIF, RuleML, R2ML, SWRL as well as (human-readable) Semantic Web rule languages such as TRIPLE, N3, Jena, and Prova are discussed with respect to these identified issues.

scholarly journals Unified Algebras and Abstract Syntax

1994 ◽  
Vol 1 (5) ◽  
Author(s):  
Peter D. Mosses
Keyword(s):  
Programming Languages ◽  
Full Scale ◽  
Algebraic Specification ◽  
Abstract Syntax ◽  
Algebraic Specifications

We consider the algebraic specification of abstract syntax in the framework of unified algebras. We illustrate the expressiveness of unified algebraic specifications, and provide a grammar-like notation for specifying abstract syntax, particularly attractive for use in semantic descriptions of full-scale programming languages.

scholarly journals Rule Markup Languages and Semantic Web Rule Languages

2011 ◽  
pp. 623-647 ◽  
Author(s):  
Adrian Paschke ◽  
Harold Boley
Keyword(s):  
Semantic Web ◽  
Markup Language ◽  
Abstract Syntax ◽  
Narrow Sense ◽  
Design Issues ◽  
Markup Languages ◽  
Common Basis ◽  
Rule Languages ◽  
The Web

Rule markup languages will be the vehicle for using rules on the Web and in other distributed systems. They allow publishing, deploying, executing and communicating rules in a network. They may also play the role of a lingua franca for exchanging rules between different systems and tools. In a narrow sense, a rule markup language is a concrete (XMLbased) rule syntax for the Web. In a broader sense, it should have an abstract syntax as a common basis for defining various concrete languages addressing different consumers. The main purposes of a rule markup language are to permit the publication, interchange and reuse of rules. This chapter introduces important requirements and design issues for general Web rule languages to fulfill these tasks. Characteristics of several important general standardization or standards-proposing efforts for (XML-based) rule markup languages including W3C RIF, RuleML, R2ML, SWRL as well as (human-readable) Semantic Web rule languages such as TRIPLE, N3, Jena, and Prova are discussed with respect to these identified issues.

scholarly journals Translating Higher-Order Specifications to Coq Libraries Supporting Hybrid Proofs

10.29007/jqtz ◽  
2018 ◽  
Author(s):  
Nada Habli ◽  
Amy P. Felty
Keyword(s):  
Programming Languages ◽  
Automatic Generation ◽  
Higher Order ◽  
Specification Language ◽  
Proof Assistants ◽  
Abstract Syntax ◽  
Formal Systems ◽  
Ongoing Work ◽  
General Specification ◽  
Automated Proof

We describe ongoing work on building an environment to support reasoning in proof assistants that represent formal systems using higher-order abstract syntax (HOAS). We use a simple and general specification language whose syntax supports HOAS. Using this language, we can encode the syntax and inference rules of a variety of formal systems, such as programming languages and logics. We describe our tool, implemented in OCaml, which parses this syntax, and translates it to a Coq library that includes definitions and hints for aiding automated proof in the Hybrid system. Hybrid itself is implemented in Coq, and designed specifically to reason about such formal systems. Given an input specification, the library that is automatically generated by our tool imports the general Hybrid library and adds definitions and hints for aiding automated proof in Hybrid about the specific programming language or logic defined in the specification. This work is part of a larger project to compare reasoning in systems supporting HOAS. Our current work focuses on Hybrid, Abella, Twelf, and Beluga, and the specification language is designed to be general enough to allow the automatic generation of libraries for all of these systems from a single specification.

scholarly journals xml2jupyter: Mapping parameters between XML and Jupyter widgets

2019 ◽  
Author(s):  
Randy Heiland ◽  
Daniel Mishler ◽  
Tyler Zhang ◽  
Eric Bower ◽  
Paul Macklin
Keyword(s):  
Programming Languages ◽  
Markup Language ◽  
Command Line ◽  
Graphical Interface ◽  
Web Browser ◽  
Agent Based ◽  
Mapping Parameters ◽  
Extensible Markup ◽  
Parameter Values ◽  
Python Package

AbstractJupyter Notebooks [4, 6] provide executable documents (in a variety of programming languages) that can be run in a web browser. When a notebook contains graphical widgets, it becomes an easy-to-use graphical user interface (GUI). Many scientific simulation packages use text-based configuration files to provide parameter values and run at the command line without a graphical interface. Manually editing these files to explore how different values affect a simulation can be burdensome for technical users, and impossible to use for those with other scientific backgrounds. xml2jupyter is a Python package that addresses these scientific bottlenecks. It provides a mapping between configuration files, formatted in the Extensible Markup Language (XML), and Jupyter widgets. Widgets are automatically generated from the XML file and these can, optionally, be incorporated into a larger GUI for a simulation package, and optionally hosted on cloud resources. Users modify parameter values via the widgets, and the values are written to the XML configuration file which is input to the simulation’s command-line interface. xml2jupyter has been tested using PhysiCell [1], an open source, agent-based simulator for biology, and it is being used by students for classroom and research projects. In addition, we use xml2jupyter to help create Jupyter GUIs for PhysiCell-related applications running on nanoHUB [5].

What is a purely functional language?

1998 ◽  
Vol 8 (1) ◽  
pp. 1-22 ◽  
Author(s):  
AMR SABRY
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Denotational Semantics ◽  
Functional Language ◽  
Formal Definition ◽  
Functional Programming Languages ◽  
Precise Meaning ◽  
Definition Of ◽  
Parameter Passing

Functional programming languages are informally classified into pure and impure languages. The precise meaning of this distinction has been a matter of controversy. We therefore investigate a formal definition of purity. We begin by showing that some proposed definitions which rely on confluence, soundness of the beta axiom, preservation of pure observational equivalences and independence of the order of evaluation, do not withstand close scrutiny. We propose instead a definition based on parameter-passing independence. Intuitively, the definition implies that functions are pure mappings from arguments to results; the operational decision of how to pass the arguments is irrelevant. In the context of Haskell, our definition is consistent with the fact that the traditional call-by-name denotational semantics coincides with the traditional call-by-need implementation. Furthermore, our definition is compatible with the stream-based, continuation-based and monad-based integration of computational effects in Haskell. Finally, we observe that call-by-name reasoning principles are unsound in compilers for monadic Haskell.

scholarly journals OpinionML—Opinion Markup Language for Sentiment Representation

Symmetry ◽  
2019 ◽  
Vol 11 (4) ◽  
pp. 545 ◽  
Author(s):  
Mohammed Attik ◽  
Malik Missen ◽  
Mickaël Coustaty ◽  
Gyu Choi ◽  
Fahd Alotaibi ◽  
...  
Keyword(s):  
Semantic Annotation ◽  
Social Web ◽  
Markup Language ◽  
Basic Definition ◽  
Markup Languages ◽  
Political Issues ◽  
The Social ◽  
Temporal Expressions ◽  
Comprehensive Comparison ◽  
Definition Of

It is the age of the social web, where people express themselves by giving their opinions about various issues, from their personal life to the world’s political issues. This process generates a lot of opinion data on the web that can be processed for valuable information, and therefore, semantic annotation of opinions becomes an important task. Unfortunately, existing opinion annotation schemes have failed to satisfy annotation challenges and cannot even adhere to the basic definition of opinion. Opinion holders, topical features and temporal expressions are major components of an opinion that remain ignored in existing annotation schemes. In this work, we propose OpinionML, a new Markup Language, that aims to compensate for the issues that existing typical opinion markup languages fail to resolve. We present a detailed discussion about existing annotation schemes and their associated problems. We argue that OpinionML is more robust, flexible and easier for annotating opinion data. Its modular approach while implementing a logical model provides us with a flexible and easier model of annotation. OpinionML can be considered a step towards “information symmetry”. It is an effort for consistent sentiment annotations across the research community. We perform experiments to prove robustness of the proposed OpinionML and the results demonstrate its capability of retrieving significant components of opinion segments. We also propose OpinionML ontology in an effort to make OpinionML more inter-operable. The ontology proposed is more complete than existing opinion ontologies like Marl and Onyx. A comprehensive comparison of the proposed ontology with existing sentiment ontologies Marl and Onyx proves its worth.

Combinators for program generation

1999 ◽  
Vol 9 (5) ◽  
pp. 483-525 ◽  
Author(s):  
PETER THIEMANN
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Domain Specific Language ◽  
Functional Language ◽  
Abstract Syntax ◽  
Specific Language ◽  
Program Generation ◽  
Domain Specific ◽  
Meta Programming ◽  
General Method

We present a general method to transform a compositional specification of a specializer for a functional programming language into a set of combinators that can be used to perform the same specialization more efficiently. The main transformation steps are the transition to higher-order abstract syntax and untagging. All transformation steps are proved correct. The resulting combinators can be implemented in any functional language, typed or untyped, pure or impure. They may also be considered as forming a domain-specific language for meta-programming. We demonstrate the generality of the method by applying it to several specializers of increasing strength. We demonstrate its efficiency by comparing it with a traditional specialization system based on self-application.

scholarly journals A Modal Proof Theory for Polynomial Coalgebras

2021 ◽  
Author(s):  
◽  
David Friggens
Keyword(s):  
Modal Logic ◽  
Computer Science ◽  
Programming Languages ◽  
Data Structures ◽  
Proof Theory ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Algebraic Methods ◽  
Mathematical Structures ◽  
Finite Constant

<p>The abstract mathematical structures known as coalgebras are of increasing interest in computer science for their use in modelling certain types of data structures and programs. Traditional algebraic methods describe objects in terms of their construction, whilst coalgebraic methods describe objects in terms of their decomposition, or observational behaviour. The latter techniques are particularly useful for modelling infinite data structures and providing semantics for object-oriented programming languages, such as Java. There have been many different logics developed for reasoning about coalgebras of particular functors, most involving modal logic. We define a modal logic for coalgebras of polynomial functors, extending Rößiger’s logic [33], whose proof theory was limited to using finite constant sets, by adding an operator from Goldblatt [11]. From the semantics we define a canonical coalgebra that provides a natural construction of a final coalgebra for the relevant functor. We then give an infinitary axiomatization and syntactic proof relation that is sound and complete for functors constructed from countable constant sets.</p>

Sign in / Sign up

Export Citation Format

Share Document