Mapping Fusion and Synchronized Hyperedge Replacement into logic programming

Lanese, Ivan; Montanari, Ugo

doi:10.1017/s147106840600281x

Cited by 4 publications

(4 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our construction could be adapted to simulate other models of computation which are structurally similar to LP, importing the well known properties of coalgebras regarding congruence, logic semantics and higher order. For instance, in [19] two process calculi, Fusion Calculus (a variant of pi-calculus) and Synchronized Hyperedge Replacement with Hoare Synchronization (a graph rewriting calculus with synchronization and mobility) are mapped into LP. Implementation efficiency can also get involved: constraint problems may be described by networks of constraints with an algebraic specification similar to our substitutive monoids; interestingly, an additional operation of restriction [24] allows to equip the networks with a hierarchical structure, which allows often to decompose the constraint problem and to solve it by means of an efficient dynamic programming algorithm.…”

Section: Resultsmentioning

confidence: 99%

See 1 more Smart Citation

A Coalgebraic Approach to Unification Semantics of Logic Programming

Bruni

Montanari

Mossa

2019

The Art of Modelling Computational Systems: A Journey From Logic and Concurrency to Security and Privacy

Self Cite

View full text Add to dashboard Cite

In the version of logic programming (LP) based on interpretations where variables occur in atoms, a goal reduction via unification can be seen as a transition labelled by the most general unifier. Categorically, it is thus natural to model a logic program as a coalgebra. In the paper we represent: (i) goals as the substitutive monoid freely generated by the predicate symbols; (ii) the LTS as the structured coalgebra defined by the SOS rules implicit in the LP semantics; (iii) the bisimulation semantics of a logic program as its image on the final coalgebra.

show abstract

Section: Resultsmentioning

confidence: 99%

“…We consider logic subgoals as concurrent communicating processes that evolve according to the rules defined by the clauses and that use unification as the fundamental interaction primitive. A presentation of this kind of use of logic programming can be found in [7,19].…”

Section: Introductionmentioning

confidence: 99%

A Coalgebraic Approach to Unification Semantics of Logic Programming

Bruni

Montanari

Mossa

2019

The Art of Modelling Computational Systems: A Journey From Logic and Concurrency to Security and Privacy

Self Cite

View full text Add to dashboard Cite

show abstract

“…Relation with SHR. The graph manipulation capabilities embedded in the G-Kells framework are reminiscent of synchronized hyperdege replacement (SHR) systems [18]. In SHR, multiple hyperedge replacements can be synchronized to yield an atomic transformation of the underlying hypergraph in conjunction with information exchange.…”

Section: Discussionmentioning

confidence: 99%

Components as Location Graphs

Stefani

2015

Formal Aspects of Component Software

View full text Add to dashboard Cite

This paper presents a process calculus framework for modeling ubiquitous computing systems and dynamic component-based structures as location graphs. A key aspect of the framework is its ability to model nested locations with sharing, while allowing the dynamic reconfiguration of the location graph, and the dynamic update of located processes. database is destroyed so are its subcomponents). The cache component CC in this example is thus part of two wholes, the database DB and the virtual machine V 1. Surprisingly, most formal models of computation and software architecture do not provide support for a direct modelling of containment structures with sharing. On the one hand, one finds numerous formal models of computation and of component software with strictly hierarchic structures, such as Mobile Ambients and their different variants [7, 6], the Kell calculus [25], BIP [4], Ptolemy [26], or, at more abstract level, Milner's bigraphs [20]. In bigraphs, for instance, it would be natural to model the containment relationships in our database example as instances of sub-node relationships in bigraphs, because nodes correspond to agents in a bigraph. Yet this is not possible because the sub-node relation in a bigraph is restricted to form a forest. To model the above example as a bigraph would require choosing which containment relation (placement in a virtual machine or being a subcomponent of the database) to represent by means of the sub-node relation, and to model the other relation by means of bigraph edges. This asymetry in modelling is hard to justify for both containment relations are proper examples of whole-part relationships. On the other hand, one finds formal component models such as Reo [1], π-ADL [22], Synchronized Hyperedge Replacement (SHR) systems [14], SRM-Light [15], that represent only interaction structures among components, and not containment relationships, and models that support the modeling of nonhierarchical containment structures, but with other limitations. Our own work on the Kell calculus with sharing [16] allows to model non-hierarchical containment structures but places constraints on the dependencies that can be modelled. For instance, the lifetime dependency constraints associated with the virtual machines and the database in our example above (if the aggregate or composite dies so do its sub-components) cannot be both easily modeled. The reason is that the calculus still enforces an ownership tree between components for the purpose of passivation: components can only passivate components lower down in the tree (i.e. suspend their execution and capture their state). The formal model which comes closer to supporting non strictly hierarchical containment structures is probably CommUnity [28], where component containment is modelled as a form of superposition, and can be organized as an arbitrary graph. However, in CommUnity, possible reconfigurations in a component assemblage are described as graph transformation rules that are separate from the behavior of components, making it dif...

show abstract

“…Example 5 Consider the following "ring-to-star" graph rewriting rule, inspired from an example in [17]:…”

Section: Graph Rewritingmentioning

confidence: 99%

Primitives for Contract-based Synchronization

Bartoletti

Zunino

2010

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

We investigate how contracts can be used to regulate the interaction between processes. To do that, we study a variant of the concurrent constraints calculus presented in [1], featuring primitives for multi-party synchronization via contracts. We proceed in two directions. First, we exploit our primitives to model some contract-based interactions. Then, we discuss how several models for concurrency can be expressed through our primitives. In particular, we encode the pi-calculus and graph rewriting

show abstract

Mapping Fusion and Synchronized Hyperedge Replacement into logic programming

Cited by 4 publications

References 17 publications

A Coalgebraic Approach to Unification Semantics of Logic Programming

A Coalgebraic Approach to Unification Semantics of Logic Programming

Components as Location Graphs

Primitives for Contract-based Synchronization

Contact Info

Product

Resources

About