Search

This article tackles the issue of data manipulation in pandemics wherein often the data is manipulated or underreported for various reasons by certain government and public institutions. This problem came to light during the first few months of the COVID-19 pandemic and had a major effect on the public health response in countries around the globe. To solve this issue, a blockchain-based system and implementation is proposed to allow hospitals and testing centres to transmit their data while also minimising the risk of manipulation from government bodies. The article makes use of the United States CDC framework for data reporting by testing labs and hospitals in order to develop this proposal for a blockchain system. Under this framework, certain pieces of data are shared with the other parties in the healthcare system based on their role and position. To accomplish this, the article then delineates the implementation of private data collections and other features of the Hyperledger software. A potential web–app interface is also presented and the transaction logic has been described in detail. Along with this, an evaluation of the risks, limitations and potential extension of the system has been performed.

The automotive value chain comprises a complex manufacturing network, which encompasses several departments, companies, and even countries. In the age of electrification and autonomous driving, the quality and transparency requirements are rising, in particular for electric and electronic components, which contribute to safety-critical functionalities. In this research, we analyze the traceability requirements and liability implications for the automotive manufacturing network. A key component in preventing safety and quality deficiencies in manufacturing processes is a state-of-the-art traceability system. Accordingly, we propose a blockchain-based traceability architecture to achieve the aspired level of transparency and process security. The proposed blockchain architecture processes manufacturing data entries and defines blockchain nodes, access, as well as consensus algorithm and transaction logic. An Ethereum-based blockchain demonstrator validates the architecture by implementing the logic for automotive product configuration and process sequencing based on the semi-fungible ERC 1155 token, the proof of authority consensus, and an automotive product token smart contract.

Configuring intelligent manufacturing systems (IMSs) is significant for manufacturing enterprises to take a step toward Industry 4.0. However, most current IMS is configured based on the Industrial Internet of Things (IIoT) with a centralized architecture, which results in poor flexibility to handle manufacturing disturbances and limits capacity to support security solutions. To solve the above issues, this article combines IIoT with the permissioned blockchain and proposes a novel manufacturing blockchain of things (MBCoT) architecture for the configuration of a secure, traceable, and decentralized IMS. Then, hardware infrastructures and software-defined components of MBCoT are designed to provide an insight into the industrial implementation of IMS. Furthermore, the consensus-oriented transaction logic of MBCoT is presented based on a crash fault-tolerant protocol, which empowers MBCoT with a strong but resource-efficient encryption mechanism to support the autonomous manufacturing process. Finally, the implementation of an MBCoT prototype system and its application examples justify that the proposed approach is practical and sound. The evaluation experiment demonstrates that MBCoT equips IMS with a secure, traceable, stable, and decentralized operating environment while achieving competitive throughput and latency performance.

Ethereum is a distributed blockchain platform, serving as an ecosystem for smart contracts: full-fledged intercommunicating programs that capture the transaction logic of an account. A gas limit caps the execution of an Ethereum smart contract: instructions, when executed, consume gas, and the execution proceeds as long as gas is available. Gas-focused vulnerabilities permit an attacker to force key contract functionality to run out of gas---effectively performing a permanent denial-of-service attack on the contract. Such vulnerabilities are among the hardest for programmers to protect against, as out-of-gas behavior may be uncommon in nonattack scenarios and reasoning about these vulnerabilities is nontrivial. In this paper, we identify gas-focused vulnerabilities and present MadMax: a static program analysis technique that automatically detects gas-focused vulnerabilities with very high confidence. MadMax combines a smart contract decompiler and semantic queries in Datalog. Our approach captures high-level program modeling concepts (such as "dynamic data structure storage" and "safely resumable loops") and delivers high precision and scalability. MadMax analyzes the entirety of smart contracts in the Ethereum blockchain in just 10 hours and flags vulnerabilities in contracts with a monetary value in billions of dollars. Manual inspection of a sample of flagged contracts shows that 81% of the sampled warnings do indeed lead to vulnerabilities.

Purpose Digitalization has transformed several industries during the past two decades. In this paper the authors focus on the retail sector, where new business models help retailers and suppliers meet the ever changing and demanding needs of retail shoppers. One example of this business model innovation is multi-sided digital platforms, which have become popular as they connect consumers with suppliers from around the world with a large ecosystem to support the retail platform. The purpose of this paper is to provide an overview of how multi-sided digital platforms are transforming the retail exchange logic and assess the implications and impact of these platform-based businesses on the retail sector, especially for business managers and consumers. Design/methodology/approach In this paper, the authors employ literature review, conceptual analysis and qualitative case study methodology. The authors provide an overview of how the platform economy is affecting the retail sector through the illustration of four digital multi-sided platforms: Alibaba Group, Amazon.com, eBay and Rakuten Group, and what differentiates them from incumbent business models in retailing. Findings The findings suggest that platforms transform the transaction logic of retailing as they simply intermediate transactions between buyers and suppliers rather than handling the entire supply and logistics chain themselves. The authors highlight the role of consumer understanding and Big Data as one example of how multi-sided digital platforms differentiate from their non-platform competitors. Practical implications The paper highlights how incumbent retailers can compete against new forms of business, such as digital platforms, and the authors demonstrate some of the managerial capabilities needed to remain relevant amidst this new digital competition. Originality/value Very little empirical studies in marketing and retail literature have focused on multi-sided digital platforms and their business models. The present study fills this gap with an overview of how multi-sided digital platforms transform the retail sector.

The linked smart data is coming from various IoT devices are enormous in nature. Therefore, capturing and real-time processing IoT smart data is a challenging task these days. The linked stream Big Data processing mechanisms play a crucial role in capturing and real-time data processing on IoT data. In this paper, calculated the performance analysis of a four processing mechanisms namely - Continuous Simple Protocol and RDF Query Language (C-SPARQL), Continuous Query Evaluation over Linked Streams (CQELS), Event Processing Simple Protocol and RDF Query Language (EP-SPARQL), Event TrAnsaction Logic in Information System (ETALIS) and Scalable Two-Level Index Scheme (STLIS). These are the mainly used mechanisms by researchers for Big Data linked stream processing. Using REFIT Smart home dataset, the experiments are conducted by taking several SPARQL queries. Finally, the STLIS mechanism is outperforms compared to the other streaming mechanisms.

Ethereum is a distributed blockchain platform, serving as an ecosystem for smart contracts: full-fledged inter-communicating programs that capture the transaction logic of an account. Unlike programs in mainstream languages, a gas limit restricts the execution of an Ethereum smart contract: execution proceeds as long as gas is available. Thus, gas is a valuable resource that can be manipulated by an attacker to provoke unwanted behavior in a victim's smart contract (e.g., wasting or blocking funds of said victim). Gas-focused vulnerabilities exploit undesired behavior when a contract (directly or through other interacting contracts) runs out of gas. Such vulnerabilities are among the hardest for programmers to protect against, as out-of-gas behavior may be uncommon in non-attack scenarios and reasoning about it is far from trivial. In this paper, we classify and identify gas-focused vulnerabilities, and present MadMax: a static program analysis technique to automatically detect gas-focused vulnerabilities with very high confidence. Our approach combines a control-flow-analysis-based decompiler and declarative program-structure queries. The combined analysis captures high-level domain-specific concepts (such as "dynamic data structure storage" and "safely resumable loops") and achieves high precision and scalability. MadMax analyzes the entirety of smart contracts in the Ethereum blockchain in just 10 hours (with decompilation timeouts in 8% of the cases) and flags contracts with a (highly volatile) monetary value of over $2.8B as vulnerable. Manual inspection of a sample of flagged contracts shows that 81% of the sampled warnings do indeed lead to vulnerabilities, which we report on in our experiment.

In this paper we develop a novel logic formalism, \({\mathcal{T} \, \mathcal{R}^{PAD}}\) (Transaction Logic with Partially Defined Actions), designed for reasoning about the effects of complex actions. \({\mathcal{T} \, \mathcal{R}^{PAD}}\) is based on a subset of Transaction Logic, but extends it with a new kind of formulas, called premise-formulas, which express information about states and the execution of actions. This makes the formalism more suitable for specifying partial knowledge about actions. We develop a sound and complete proof theory for \({\mathcal{T} \, \mathcal{R}^{PAD}}\) and illustrate the formalism on a number of instructive examples. In addition, we show that an expressive subset of \({\mathcal{T} \, \mathcal{R}^{PAD}}\) is reducible to standard logic programming and define a precise sense in which this reduction is sound and complete.

Now for orthodontists there are no commercial orthodontic EMR systems suitable for their clinical needs in China, so we study orthodontist’s daily workflow, analyze the requirements, and finally develop the orthodontic EMR Cloud for Peking University School of Stomatology. We propose and adopt 2-Tier Cloud-ARchitecture (2TCAR), which contains rich client tier based on Rich Internet Application (RIA) and server-side Cloud tier based on SimpleDB, to develop the orthodontist’s EMR Cloud for orthodontics according to orthodontist’s workflow. In the 2TCAR the rich client tier is maximized to implement almost all functionalities of user interfaces and transaction logic in the EMR. Functionalities in server-side Cloud tier are simplified only to implement data storage and query. Communication between the two Cloud tiers is also simplified via REST. In the article we research corresponding technologies such as Cloud computing, REST, Flex in RIA and SimpleDB Cloud. Further, in the orthodontic EMR Cloud we use Flex to implement UI presentation & interaction, transaction logic, and REST requests & responses in rich client tier; then design SimpleDB Cloud in server-side Cloud tier, and communication between two tiers via REST. And the EMR Cloud is integrated with existing Resister, Ward and Drugstore information systems. The practice shows that the orthodontic EMR Cloud based on the 2TCAR can fit seamlessly into orthodontist’s daily workflow and effectively replace current paper medical records.

Administering and maintaining access control systems is a challenging task, especially in environments with complex and changing authorization requirements. A number of authorization logics have been proposed that aim at simplifying access control by factoring the authorization policy out of the hard-coded resource guard. However, many policies require the authorization state to be updated after a granted access request, for example, to reflect the fact that a user has activated or deactivated a role. Current authorization languages cannot express such state modifications; these still have to be hard-coded into the resource guard. We present a logic for specifying policies where access requests can have effects on the authorization state. The logic is semantically defined by a mapping to Transaction Logic. Using this approach, updates to the state are factored out of the resource guard, thus enhancing maintainability and facilitating more expressive policies that take the history of access requests into account. We also present a sound and complete proof system for reasoning about sequences of access requests. This gives rise to a goal-oriented algorithm for finding minimal sequences that lead to a specified target authorization state.

State space planning algorithms have been considered as one of the main classical planning techniques to solve classical planning problems since 1960. In this paper, we show that Transaction Logic is an appropriate language and framework to study and compare these planning algorithms, which enables one to have more efficient planners in logic programming frameworks. Specifically, we take $$\textit{STRIPS}$$ planning and forward state space planning algorithms, and show that the specification of these algorithms in Transaction Logic lets one implement complicated planning algorithms in declarative programming languages e.g. Prolog. We first provide a formal representation of these planning algorithms in Transaction Logic, which can be used to automatically translate $$ \textit{STRIPS}$$ planning problems in PDDL to Transaction Logic rules. Then, we use the resulting Transaction Logic rules to solve planning problems and compare the performance of those algorithms in our simple interpreter implemented in XSB Prolog. We use several case studies to show how the linear $$ \textit{STRIPS}$$ planning algorithm is faster than forward state space search. Our experiments highlight the fact that a planner implemented by logic programming framework can become faster if an appropriate planning algorithm is applied.

Heuristic search is arguably the most successful paradigm in Automated Planning, which greatly improves the performance of planning strategies. However, adding heuristics usually leads to very complicated planning algorithms. In order to study different properties (e.g. completeness) of those complicated planning algorithms, it is important to use an appropriate formal language and framework. In this paper, we argue that Transaction Logic is just such a specification language, which lets one formally specify both the heuristics, the planning algorithm, and also facilitates the discovery of more general and more efficient algorithms. To illustrate, we take the well-known regression analysis mechanism and show that Transaction Logic lets one specify the concept of regression analysis easily and thus express \(\textit{RSTRIPS}\), a classical and very complicated planning algorithm based on regression analysis. Moreover, we show that extensions to that algorithm that allow indirect effects and action ramification are obtained almost for free. Finally, a compact and clear logical formulation of the algorithm lets us prove the completeness of \(\textit{RSTRIPS}\)—a result that, to the best of our knowledge, has not been known before.

Automated planning has been the subject of intensive research and is at the core of several areas of AI, including intelligent agents and robotics. In this thesis proposal, we argue that Concurrent Transaction Logic (\( \mathcal {CTR}\)) is a natural specification language for planning algorithms, which enables one to see further afield and thus discover better and more general solutions than using one-of-a-kind formalisms. Specifically, we take the well-known \( \textit{STRIPS}\) planning strategy and show that \( \mathcal {CTR}\) lets one specify the \(\textit{STRIPS}\) planning algorithm easily and concisely, and extend it in several respects. For instance, we show that extensions to allow indirect effects and to support action ramifications come almost for free. The original \( \textit{STRIPS}\) planning strategy is also shown to be incomplete. Using concurrency operators in \( \mathcal {CTR}\), we propose a non-linear \( \textit{STRIPS}\) planning algorithm, which is proven to be complete. Moreover, this thesis proposal outlines several extensions of \( \textit{STRIPS}\) planning strategy. All of the extensions show that the use of \( \mathcal {CTR}\) accrues significant benefits in the area of planning.

Event-Condition-Action languages are the commonly accepted paradigm to express and model the behavior of reactive systems. While numerous Event-Condition-Action languages have been proposed in the literature, differing e.g. on the expressivity of the language and on its operational behavior, existing Event-Condition-Action languages do not generally support the action component to be formulated as a transaction. In this paper, sustaining that it is important to execute transactions in reactive languages, we propose an Event-Condition-Transaction language, based on an extension of Transaction Logic. This extension, called Transaction Logic with Events (\(\mathcal {TR}^{ev}\)), combines reasoning about the execution of transactions with the ability to detect complex events. An important characteristic of \(\mathcal {TR}^{ev}\) is that it takes a choice function as a parameter of the theory, leaving open the behavioral decisions of the logic, and thereby allowing it to be suitable for a wide-spectrum of application scenarios like Semantic Web, multi-agent systems, databases, etc. We start by showing how \(\mathcal {TR}^{ev}\) can be used as an Event-Condition-Action language where actions are considered as transactions, and how to differently instantiate this choice function to achieve different operational behaviors. Then, based on a particular operational instantiation of the logic, we present a procedure that is sound and complete w.r.t. the semantics and that is able to execute \(\mathcal {TR}^{ev}\) programs.

Existing database systems employ an \textit{eager} transaction processing scheme---that is, upon receiving a transaction request, the system executes all the operations entailed in running the transaction (which typically includes reading database records, executing user-specified transaction logic, and logging updates and writes) before reporting to the client that the transaction has completed. We introduce a \textit{lazy} transaction execution engine, in which a transaction may be considered durably completed after only partial execution, while the bulk of its operations (notably all reads from the database and all execution of transaction logic) may be deferred until an arbitrary future time, such as when a user attempts to read some element of the transaction's write-set---all without modifying the semantics of the transaction or sacrificing ACID guarantees. Lazy transactions are processed deterministically, so that the final state of the database is guaranteed to be equivalent to what the state would have been had all transactions been executed eagerly. Our prototype of a lazy transaction execution engine improves temporal locality when executing related transactions, reduces peak provisioning requirements by deferring more non-urgent work until off-peak load times, and reduces contention footprint of concurrent transactions. However, we find that certain queries suffer increased latency, and therefore lazy database systems may not be appropriate for read-latency sensitive applications. We introduce a lazy transaction execution engine, in which a transaction may be considered durably completed after only partial execution, while the bulk of its operations (notably all reads from the database and all execution of transaction logic) may be deferred until an arbitrary future time, such as when a user attempts to read some element of the transaction's write-set---all without modifying the semantics of the transaction or sacrificing ACID guarantees. Lazy transactions are processed deterministically, so that the final state of the database is guaranteed to be equivalent to what the state would have been had all transactions been executed eagerly. Our prototype of a lazy transaction execution engine improves temporal locality when executing related transactions, reduces peak provisioning requirements by deferring more non-urgent work until off-peak load times, and reduces contention footprint of concurrent transactions. However, we find that certain queries suffer increased latency, and therefore lazy database systems may not be appropriate for read-latency sensitive applications.

This work stands out the use of Transaction Logic (TR) in case-based planning. The TR provides a correct and complete logical theory based planner that can be computationally implemented keeping the formal theory semantic. The TR is efficient on states treatment besides to create a retriever and cases adaptation easier than others formalized systems. Transaction Logic provides a clean fashion in knowledge representation and its semantic based on path of states is next to planning necessities, making possible the formalization of whole case-based planning system without the existence of the semantic gap between theory and implementation.

In the planning area, the reasoning about action is important, because the plans are made by a sequence of actions. Each action has its effects that need to be treated and fonnalized in some logical framework.The use of Transaction Logic (TR) makes possible a perfect definition of fluents to treat the effects of the ramification problem, because the TR works with database controlled by transition and data oracles. The TR has a powerful set of inference rules that makes possible its implementation in PROLOG, like SLD-resolution, allowing the application of effects in a computational way.

External Transaction Logic $\mathcal{ETR}$ is an extension of logic programming useful to reason about the behavior of agents that have to operate in a two-fold environment in a transactional way: an internal knowledge base defining the agent's internal knowledge and rules of behavior, and an external world where it executes actions and interact with other entities. Actions performed by the agent in the external world may fail, e.g. because their preconditions are not met or because they violate some norm of the external environment. The failure to execute some action must lead, in the internal knowledge base, to its complete rollback, following the standard ACID transaction model. Since it is impossible to rollback external actions performed in the outside world, external consistency must be achieved by executing compensating operations or repairs that revert the effects of the initial executed actions. In $\mathcal{ETR}$ , repairs are stated explicitly in the program. With it, every performed external action is explicitly associated with its corresponding compensation or repair. Such user defined repairs provide no guarantee to revert the effects of the original action. In this paper we define how $\mathcal{ETR}$ can be extended to automatically calculate compensations in case of failure. For this, we start by explaining how the semantics of Action Languages can be used to model the external domain of $\mathcal{ETR}$ , and how we can use it to reason about the reversals of actions.

We find that there are serious problems in Cloud application development such as complex architecture and WS API, highly running cost, poor UI and interaction and so on, and that these problems stem from not fully utilized RIA’s (Rich Internet Application) advantages and inappropriate functionality segmentation between client-side and server-side. That is, Web services, application logic and transaction logic are overly concentrated on the server side; while on the client-side computing power has not been fully utilized. We propose a novel 2-Tier Cloud-ARchitecture (2TCAR), which contains RIA-based rich client tier and SimpleDB-based server-side Cloud tier. The rich client tier is maximized to implement most of functionalities of Cloud application and transaction logic; in contrast, the functionality in server-side Cloud tier is minimized to only implement data storage and query. The communication between these two tiers is also simplified via REST. In the article we researched corresponding technologies such as Cloud computing, Web services, REST, Flex in RIA and SimpleDB storage Cloud. In addition, we proposed how to use Flex to implement UI presentation & interaction, transaction logic, REST requests & responses in rich client tier; and we described how to design SimpleDB Cloud in server-side Cloud tier and communication between two tiers via REST. Last, a Cloud application system, which is called Cloud System of Electronic Health Records (EHR) for Orthodontics, is developed based on the research findings illustrated by the author in this paper. It has been shown that the 2TCAR is effective and valuable for Cloud application development.

This paper presents an overview of Transaction Logic —a new formalism recently introduced in Bonner and Kifer (1992, 1993) and designed to deal with the phenomenon of state changes in logic programming, databases, and AI. Transaction Logic has a natural model theory and a sound and complete proof theory. Unlike many other logics, however, it is suitable for programming procedures that accomplish state transitions in a logically sound manner. Transaction logic amalgamates such features as hypothetical and committed updates, dynamic constraints on transaction execution, nondeterminism, and bulk updates. Transaction Logic also appears to be suitable as a logical model of hitherto nonlogical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects.

Transaction Logic with Partially Defined Actions (TRPAD) is an expressive formalism for reasoning about the effects of actions and for declarative specification of state-changing transactions. The action language L1 is a wellknown formalism to describe changing domains and for reasoning about actions. The purpose of this paper is to compare these two formalisms and identify their similarities and points of divergence in order to better understand their modeling and reasoning capabilities. We provide a sound reduction of a large fragment of L1 to TRPAD, and show that this reduction is complete with respect to the LP embedding of L1. We also explore how action planning is modeled in both languages and discuss the relationship to other languages for representing actions.

Recently, WS-BPEL has gradually become the basis of a standard for web service description and composition. However, WS-BPEL cannot efficiently describe distributed workflow services for lacking of special expressive power and formal semantics. This paper presents a novel method for modeling distributed workflow service composition with Concurrent TRansaction logic (CTR). The syntactic structure of WS-BPEL and CTR are analyzed, and new rules of mapping WS-BPEL into CTR are given. A case study is put forward to show that the proposed method is appropriate for modeling workflow business services under distributed environments.

This paper introduces TRPAD (Transaction Logic with Partially Defined Actions)--an expressive formalism for reasoning about the effects of compound actions. TRPAD is based on a subset of Transaction Logic, but extends it with special premise-formulas that generalize the data and transition formulas of the original Transaction Logic. We develop a sound and complete proof theory for TRPAD and illustrate the formalism on a number of non-trivial examples. In addition, we show that most of TRPAD is reducible to ordinary logic programming and that this reduction is sound and complete.

Transaction Logic is a logic for representing declarative and procedural knowledge in logic programming, databases, and AI. It has been successful in areas as diverse as workflows and Web services, security policies, AI planning, reasoning about actions, and more. Although a number of implementations of Transaction Logic exist, none is logically complete due to the inherent difficulty and time/space complexity of such implementations. In this paper we attack this problem by first introducing a logically complete tabling evaluation strategy for Transaction Logic and then describing a series of optimizations, which make this algorithm practical. In support of our arguments, we present a performance evaluation study of six different implementations of this algorithm, each successively adopting our optimizations. The study suggest that the tabling algorithm can scale well both in time and space. We also discuss ideas that could improve the performance further.

To address the serious problems in Cloud application development such as complex architecture and WS API, highly running cost, poor UI and interaction and so on, we found that the problems stem from no using RIA's power fully and inappropriate functionality segmentation between client-side and server-side. That is, Web services, application logic and transaction logic are overly concentrated on the server side. We proposed 2-Tier Cloud-ARchitecture (2TCAR), which contains rich client tier based on RIA and server-side Cloud tier based on SimpleDB. Rich client tier is maximized to implement almost all functionalities of Cloud application and transaction logic; functionality in server-side Cloud tier is simplified only to implement data storage and query; communication between two tiers is also simplified via REST. In the article we researched corresponding technologies such as Cloud computing, Web services, REST, Flex in RIA and SimpleDB Cloud. Further, we presented how use Flex to implement UI presentation & interaction, transaction logic, REST requests & responses in rich client tier; we also described how to design SimpleDB Cloud in server-side Cloud tier, and communication between two tiers via REST. All research findings were applied into a Cloud application demo. The practice has shown that the 2TCAR is effective and valuable for Cloud application.

In this paper we propose to demonstrate a logic-based and data-driven complex event processor. The event processor is called ETALIS (Event-driven Transaction Logic Inference System). ETALIS is based on decomposition of complex event patterns into patterns goals. Goals are asserted by declarative rules, which are executed in the backward chaining mode. A specific property of these rules is that they are event-driven, and allow reasoning over events relationships.

This paper presents a language, based on transaction logic, for specifying dynamic authorisation policies, i.e., rules governing actions that may depend on and update the authorisation state. The language is more expressive than previous dynamic authorisation languages, featuring conditional bulk insertions and retractions of authorisation facts, non-monotonic negation, and nested action definitions with transactional execution semantics. Two complementary policy analysis methods are also presented, one based on AI planning for verifying reachability properties in finite domains, and the second based on automated theorem proving, for checking policy invariants that hold for all sequences of actions and in arbitrary, including infinite, domains. The combination of both methods can analyse a wide range of security properties, including safety, availability and containment.

Hospital medicine storage information system is an important element of Hospital Information System (HIS). The implementation of hospital medicine storage information system based on B/S architecture is discussed. The main functions and implementation details of the system are presented. Based on Java 2 Platform Enterprise Edition (J2EE), using integrated open source frame, four-level structure is adopted to develop the system. Hereinto, the representation level, control level, and transaction logic level adopt the struts frame that accords with MVC mode, while the persistent data level adopts Hibernate frame. Consequently, it not only makes the system structure clear and maintainable, but also strengthens codes’ readability and reusability greatly.

The Future Internet predicts more and more networked devices on the Internet. These devices interact, exchange knowledge, and cooperate in a dynamic environment, changing their states. Each state change may be signified by an event. In scenarios, where a number of devices collaborate on a common goal, it is a challenge to capture relevant complex changes, and abstract them in particular collaboration situations. Further on, it is even more challenging to put those changes in a relevant context, and to reason about collaboration situations before adequately reacting on events (changes). We present a novel event-driven reactivity model for Future Internet collaborations. We implement a flexible collaborative workflow in a declarative way, solving before mentioned challenges. Particularly, Concurrent Transaction Logic is used for specification, reasoning, and execution of ad-hoc collaborative workflows.

In my thesis, I present problems and techniques in tabling Transaction Logic ($\mathcal{TR}$). $\mathcal{TR}$ is an extension of classical logic programming with backtrackable state updates and it has a top-down evaluation algorithm similar to Prolog's SLD derivation extended with execution paths of states instead of a single global state. This backward chaining algorithm can be very inefficient by re-computing the same transactional queries more than once, or can enter into infinite loops by visiting the same paths of states an infinite number of times when computing answers to recursive programs. We solve these problems by memoizing (caching) the calls, call initial states, unifications (answers) and return states in a searchable structure for the Sequential Transaction Logic, respective building a graph for the query and tabling the nodes ready for current execution for the Concurrent Transaction Logic. Important problems of tabling $\mathcal{TR}$ are to store, index, update, query and resume states into memory. I implemented and measured the efficiency of multiple data structures used in tabling programs with backtrackable updates in XSB Prolog. My thesis studies the data structures and their performance for various applications of TR, such as, artificial intelligence planning, NP-complete graph algorithms (Hamiltonian cycle, clique, shortest consuming paths, connected components) and active databases. One of the most promising techniques was storing logs (i.e., inserts and deletes relative to a materialized state) into individual tries (optimized for querying), while keeping a global page trie as a common index for restarting.

In this paper, we present a powerful logical encoding of complex event patterns into Transaction Logic programs. Complex Event Processing (CEP) deals with finding composed events and has useful applications in areas ranging from agile business and enterprise processes management, financial market applications to active Web and service oriented computation. Many systems for event processing have ad-hoc semantics with unexpected behaviors. Hence formal logical semantics is an important requirement for event-driven reactive systems. On the other hand, many logic-based approaches for CEP (based on formal semantics) fail, due to their inability to compute complex events in the data-driven fashion. Our approach enables both logic-based and data-driven complex event detection. Moreover, the proposed backward chaining approach allows for very efficient reasoning of complex events and actions triggered by these events.

Web services solve the problem of inter-organization business integration and are under a distributed, dynamic, autonomic and heterogeneous environment. The correctness and verification of Web service orchestration is important. Formalization is a valid method. This paper gives the model of Web service orchestration based on concurrent transaction logic. An introduction of Web service orchestration and concurrent transaction logic is given. Then the translation rules from WS-BPEL to concurrent transaction logic are given. The verification problem o Web service orchestration based on concurrent transaction logic is discussed. Finally, an actual Web service orchestration example based on concurrent transaction logic is illustrated.

Several approaches to semantic Web services, including OWLS, SWSF, and WSMO, have been proposed in the literature with the aim to enable automation of various tasks related to Web services, including discovery, contracting, enactment, monitoring, and mediation. The ability to specify processes and to reason about them is central to these initiatives. In this paper we analyze the WSMO choreography model, which is based on Abstract State Machines (ASMs), and propose a methodology for generating WSMO choreography from visual specifications. We point out the limitations of the current WSMO model and propose a faithful extension that is based on Concurrent Transaction Logic (CTR). The advantage of a CTR-based model is that it uniformly captures a number of aspects that previously required separate mechanisms orwere not captured at all. These include process specification, contracting for services, service enactment, and reasoning.

The emerging paradigm of service-oriented computing requires novel techniques for various service-related tasks. Along with automated support for service discovery, selection, negotiation, and composition, support for automated service contracting and enactment is crucial for any large scale service environment, where large numbers of clients and service providers interact. Many problems in this area involve reasoning, and a number of logic-based methods to handle these problems have emerged in the field of Semantic Web Services. In this paper, we build upon our previous work where we used Concurrent Transaction Logic (CTR) to model and reason about service contracts. We significantly extend the modeling power of the previous work by allowing iterative processes in the specification of service contracts, and we extend the proof theory of CTR to enable reasoning about such contracts. With this extension, our logic-based approach is capable of modeling general services represented using languages such as WS-BPEL.

A set of patterns that characterize the types of control flow that appear frequently in composition of processes have been proposed in the literature; the informal nature of these patterns justifies a precise representation of these patterns. This paper provides implementations of those patterns in concurrent transaction logic (CTR) - a logical framework for specification, analysis, and execution of database transactions. We show how these representations can be expressed as reusable definitions that can be then reused as needed (e.g. for building more complex patterns). The resulting pattern definitions can be used as a foundation for pattern-based service composition, execution, and reasoning.

Many emerging applications show the need for a fine-grained context based access control requirements. The generalized temporal RBAC model has been proposed to capture fine-grained time-based access control requirements using periodic time expression to capture recurring intervals of time. In this paper, we present conditional temporal RBAC (CT-RBAC) model that extends GTRBAC model by extending the periodic time expression. In particular, the extension allows fine-grained extension to capture other logical conditions that restricts the validity of the temporal constraints. CT-RBAC uses a symbolic representation of conditional periodic time that can be used to define a set of conditions to qualify the components of a periodic time expression, using the concurrent transaction logic. Because of the conditional set introduced, CT-RBAC extends the time control dimension to the (condition, time) control plane and the (time, constraint) plane of the GTRBAC framework to the (condition, time, constraint) three-dimensional control space, thus providing more flexibility in the access control model. We analyze conflicts introduced by the constraint set and the complexity of evaluating the conditional set.

Reasoning on Constraint Handling Rules (CHR) programs and their executional behaviour is often ad-hoc and outside of a formal system. This is a pity, because CHR subsumes a wide range of important automated reasoning services. Mapping CHR to Transaction Logic (τ R) combines CHR rule specification, CHR rule application, and reasoning on CHR programs and CHR derivations inside one formal system which is executable. This new τ R semantics obviates the need for disjoint declarative and operational semantics.

We present a logic for specifying policies where access requests can have effects on the authorization state. The logic is semantically defined by a mapping to Transaction Logic. Using this approach, updates to the state are factored out of the resource guard, thus enhancing maintainability and facilitating more expressive policies that take the history of access requests into account. We also present a sound and complete proof system for reasoning about sequences of access requests. This gives rise to a goal-oriented algorithm for finding minimal sequences that lead to a specified target authorization state.