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.

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.

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.

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.

Evaluation of the properties of various planning techniques such as completeness and termination plays an important role in choosing an appropriate planning technique for a particular planning problem. In this paper, we use the already existing formal specification of two well-known and classic state space planning techniques, forward state space planning and goal stack state space planning techniques, in Transaction Logic(\( \mathcal {TR} \)) to study their completeness. Our study shows that using \( \mathcal {TR} \), we can formally specify the serializability of planning problems and prove the completeness of \( \textit{STRIPS}\) planning problems for planning problems with serializable goals.

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.

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 paper, we argue that Transaction Logic 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 Transaction Logic lets one specify the \({\textit{STRIPS}}\) planning algorithm easily and concisely, and to prove its completeness. Moreover, extensions to allow indirect effects and to support action ramifications come almost for free. Finally, the compact and clear logical formulation of the algorithm made possible by this logic is conducive to fruitful experimentation. To illustrate this, we show that a rather simple modification of the \({\textit{STRIPS}}\) planning strategy is also complete and yields speedups of orders of magnitude.

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.

We propose External Transaction Logic (or ETR), an extension of Transaction Logic able to represent updates in internal and external domains whilst ensuring a relaxed transaction model. With this aim, ETR deals with two main components: an internal knowledge base where updates follow the strict ACID model, given by the semantics of Transaction Logic; and an external knowledge base of which one has limited or no control and can only execute external actions. When executing actions in the external domain, if a failure occurs, it is no longer possible to simply rollback to the initial state before executing the transaction. For dealing with this, similarly to what is done in databases, we define compensating operations for each external action to be performed to ensure a relaxed model of atomicity and consistency. By executing these compensations in backward order, we obtain a state considered to be equivalent to the initial one.

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.

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.

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.

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.

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.

We present a generalized committed choice construct for concurrent programs that interact with a shared store. The generalized committed choice (GCC) allows multiple computations from different alternatives to occur concurrently and later commit to one of them. GCC generalizes the traditional committed choice in Dijkstra's Guarded Command Language to handle don't know non-determinism and also allows for speculative computation. The main contribution of the paper is to introduce the GCC programming construct and the associated semantics framework for formalizing GCC. We give some experimental results which show that the power of GCC can be made practical.

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.

Workflow modeling technology has seen an explosion of interest and advances in recent years. Numerous technical challenges have been addressed to provide concurrent workflow management systems which are required by dynamic application domains. Concurrent transaction logic (CTR) has become one of the most exciting methods for concurrent business process modeling. This paper presents a novel modeling method for flexible workflow specification. The method extends sequential transaction logic with logical connectives for concurrent execution of processes. It presents the semantic specification for workflow structures which are based on the proposed extended semantic logic. An experimental case is put forward to show that the proposed method is appropriate for modeling concurrent workflow systems under dynamic environments.

EJB, providing specification for development and deployment of component based application, permits distributed development as a central element of J2EE environment that automatically manages transaction management, persistence, and concurrency control, which are the most complicated components in an enterprise environment. In this paper, we aim to resolve DAOs transaction logic complexity and performance reduction of components in the EJB based legacy system. Therefore, this paper describes the design and implementation of IDAO that applies iterator pattern. IDAO achieves an effect that reduces the complexity of transaction logic, system overload by database connection, and reduction of performance through container managed transactions.

In this work we propose to use a Horn fragment of Concurrent Transaction Logic ( ${\mathcal CTR}$) as an intuitive logic framework to specify semantics of concurrent programming languages. Using Horn logic to specify a programming language has been suggested before [5,6,2]. By specifying a programming language we mean writing semantics, all three semantics-operational, denotational, and axiomatic-in Horn logic, which is also executable. Slonneger convincingly demonstrated that, for the specification of denotational semantics, Prolog can be regarded as superior to imperative languages. Gupta [2] expanded on the idea and showed how Horn logic denotations lead to some interesting practical applications, such as automatic program verification and automatic generation of compilers. The work presented here builds on the aforementionedworks and extends that of [2] by providing a Horn logic denotational semantics for concurrent programming languages.

FLORA-2 is an advanced knowledge representation system that integrates F-logic, HiLog, and Transaction Logic. In this paper we give an overview of the theoretical foundations of the system and of some of the aspects of nonmonotonic reasoning in FLORA-2. These include scoped default negation, behavioral inheritance, and nonmonotonicity that stems from database dynamics.

\(\mathcal{F}\) lora-2 is a rule-based object-oriented knowledge base system designed for a variety of automated tasks on the Semantic Web, ranging from meta-data management to information integration to intelligent agents. The \(\mathcal{F}\) lora-2 system integrates F-logic, HiLog, and Transaction Logic into a coherent knowledge representation and inference language. The result is a flexible and natural framework that combines rule-based and object-oriented paradigms. This paper discusses the principles underlying the design of the \(\mathcal{F}\) lora-2 system and describes its salient features, including meta-programming, reification, logical database updates, encapsulation, and support for dynamic modules.

As an extention of the TRASYS approach to reasoning about actions, this work presents a new step in the direction to the transposition of the gap between action formalisms and their real execution inside planning environments. We try to clarify some points of the former paper by presenting a re-structured overview of the of Transaction Logic formalism and proposing some modifications to the action model which will allow the use of nonatomic formulae in the world model. Aiming an efficient method for executing action specifications, we present how could these specifications be rendered into a PROLOG program.

The authors outline the features of the transaction processing performance council (TPC) benchmark A and describe the implementation of the benchmark in a distributed transaction processing (TP) environment. TPC benchmark A simulates a TP environment and exercises key components of the system under test (SUT) using a simple, update-intensive transaction type. It is intended to simulate a class of TP application environments instead of the entire range of TP environments. Nevertheless, the single transaction type specified by the TPC benchmark A standard provides a simple, repeatable unit of work. An overview of this benchmark is provided in terms of the application environment, the transaction logic, terminal communication, implementation constraints, database design, benchmark metrics, transactions per second (TPS) and price per TPS. >

During the last years, a number of formal specification languages for knowledge-based systems has been developed. Characteristics for knowledge-based systems are a complex knowledge base and an inference engine which uses this knowledge to solve a given problem. Specification languages for knowledge-based systems have to cover both aspects. They have to provide the means to specify a complex and large amount of knowledge and they have to provide the means to specify the dynamic reasoning behavior of a knowledge-based system. This paper focuses on the second aspect. For this purpose, we survey existing approaches for specifying dynamic behavior in related areas of research. In fact, we have taken approaches for the specification of information systems (Language for Conceptual Modeling and TROLL), approaches for the specification of database updates and logic programming (Transaction Logic and Dynamic Database Logic) and the generic specification framework of Abstract State Machines.

In recent years we have been experiencing a tremendous change in software development processes, where new systems are built by utilizing distributed, possibly heterogeneous, components. In this paper, we propose an infrastructure and a meta programming environment that allows for distributed components to be integrated, in a fully customizable manner, into Web-enabled environments. In particular, we propose an architecture that conforms to the event-condition-action paradigm. A set of event-condition-action rules combined with a rule enac?ent engine serves as a driver that determines the transaction logic by which remote services are invoked. A prototype system using the proposed architecture applied to the domain of e-commerce is also presented.

This paper reports on the design and implementation of FLORA -- a powerful DOOD system that incorporates the features of F-logic, HiLog, and Transaction Logic. FLORA is implemented by translation into XSB, a tabling logic engine that is known for its efficiency and is the only known system that extends the power of Prolog with an equivalent of the Magic Sets style optimization, the well-founded semantics for negation, and many other important features. We discuss the features of XSB that help our effort as well as the areas where it falls short of what is needed. We then describe our solutions and optimization techniques that address these problems and make FLORA much more efficient than other known DOOD systems based on F-logic.

We propose an extension of classical predicate calculus, called Transaction Logic, which provides a logical foundation for the phenomenon of state changes in logic programs and databases. Transaction Logic comes with a natural model theory and a sound and complete proof theory. The proof theory not only verifies programs, but also executes them, which makes this logic an ideal tool for declarative programming of database transactions and state-modifying logic programs. The semantics of Transaction Logic leads naturally to features whose amalgamation in a single logic has proved elusive in the past. These features include hypothetical and committed updates, dynamic constraints on transaction execution, non-determinism, and bulk updates. Finally, Transaction Logic holds promise as a logical model of hitherto non-logical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects. This paper presents the semantics of Transaction Logic and a sound and complete SLD-style proof theory for a Horn-like subset of the logic.

Transaction Logic was designed as a general logic of state change for deductive databases and logic programs. It has a model theory, a proof theory, and its Horn subset can be given a procedural interpretation. Previous work has demonstrated that the combination of declarative semantics and procedural interpretation turns the Horn subset of Transaction Logic into a powerful language for logic programming with updates [BK98,BK94,BK93,BK95]. In this paper, we focus not on the Horn subset, but on the full logic, and we explore its potential as a formalism for reasoning about logic programs with updates. We first develop a methodology for specifying properties of such programs, and then provide a sound inference system for reasoning about them, and conjecture a completeness result. Finally, we illustrate the power of the inference system through a series of examples of increasing difficulty.

During the last years, a number of formal specification languages for knowledge-based systems have been developed. Characteristic for knowledge-based systems are a complex knowledge base and an inference engine which uses this knowledge to solve a given problem. Specification languages for knowledge-based systems have to cover both aspects: they have to provide means to specify a complex and large amount of knowledge and they have to provide means to specify the dynamic reasoning behaviour of a knowledge-based system. This paper will focus on the second aspect, which is an issue considered to be unsolved. For this purpose, we have surveyed existing approaches in related areas of research. We have taken approaches for the specification of information systems (i.e., Language for Conceptual Modelling and Troll), approaches for the specification of database updates and the dynamics of logic programs (Transaction Logic and Dynamic Database Logic), and the approach of Abstract State Machines.

Transaction logic (TR) is a formalism that accounts for the specification and execution of update phenomena in arbitrary logical theory, specially logic programs and databases. In fact, from a theoretical standpoint, the planning activity could be seen as such a kind of phenomenon, where the execution of plan actions update a world model. This paper presents how a planning process can be specified and formally executed in TR. We define a formal planning problem description and show that goals for these problems may be represented not only as questions to a final database state, but also as the invocation of complex actions. The planning process in this framework can be considered as an executional deduction of a TR formula. As a highlight of this work we could mention that it provides a clean and declarative approach to bridging the gap between formal and real planning. The user not only “programs” his planning problem description, but also gains a better understanding of what is behind the semantics of the plan generation process.

This paper presents database applications of the recently proposed Transaction Logic—an extension of classical predicate logic that accounts in a clean and declarative fashion for the phenomenon of state changes in logic programs and databases. It has a natural model theory and a sound and complete proof theory, but, unlike many other logics, it allows users to program transactions. In addition, the semantics leads naturally to features whose amalgamation in a single logic has proved elusive in the past. Finally, Transaction Logic holds promise as a logical model of hitherto non-logical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects. This paper focuses on the applications of T r to database systems, including transaction definition and execution, nested transactions, view updates, consistency maintenance, bulk updates, non-determinism, sampling, active databases, dynamic integrity-constraints, hypothetical reasoning, and imperative-style programming.

Some recent trends in distributed intelligent systems rely extensively on agent-based approaches. The so-called Multi-Agent Systems (MAS) are taking over the management of sensitive data on behalf of their producers and users (e.g., medical records, financial investment, energy market). Therefore, trusted interactions are needed more than ever, while accountability and transparency among the agents seem crucial characteristics to be achieved. To do so, recent trends advocate the use of blockchain technologies (BCT) in MAS. The blockchain is a distributed ledger technology that can execute programmable transaction logic, and provides a shared, immutable, and transparent append-only register of all the actions happening in the network. Although a few theoretical approaches have already been proposed, the quest for such a system consolidating BCT and MAS to guarantee privacy, scalability, transparency, and efficiency continues. This paper presents a reconciling system including BCT within the dynamics of a MAS. Such a system aims at (i) building a solid ground for trusted interactions and (ii) enabling more characterizing feature-based and trustworthy ways of computing agent reputation. The system has been tested in four scenarios with different configurations (regular executions and involving down-agents or malicious behaviors). Finally, the paper summarizes and discusses the experience gained, argues about the strategic choice of binding MAS and BCT, and presents some future challenges.