The persistence of information through the intermediary of a virtual component requires mechanisms synchronizing the persistence of information. Different solutions can do this which are ACID compliant.
Some providers implement internal mechanisms. These providers are therefore immutable virtual components implementing mechanisms that synchronize the state of duplicates. In this case, the logic components do not need to be concerned with this synchronization. Oracle’s two-phase mechanism  and Microsoft’s transaction coordinator  are examples.
When duplicate immutable dependencies cannot implement synchronization between duplicates, this synchronization should be addressed within the logic components.
Immutable virtual components must be synchronized in order to preserve information in an ACID-compliant manner, and so must be all duplicates of the same component.
The logic component managing these duplicates must then include a mechanism allowing avoidance of the use of an immutable virtual component, if ever the component could not preserve a state. Also, the logic components must be able to ensure that the virtual components have retained an identical state.
All these mechanisms an integral part of logic component. Multiple database management systems implement these mechanisms.  Conversely, as mentioned in section Framework for analysis of the mecanisms, their implementation is beyond the scope of this study.
In a software solution, several components can depend on the same immutable component, which makes this virtual component a common dependency of at least two logic components of the solution.
The figure below illustrates an example in which duplicates of a logic component are based on the same immutable virtual component, and implement a timing mechanism through a communication link.
The mechanisms put in place within a logic component must then be synchronized between duplicates of this component, in addition to management of synchronization internal to the component itself. The scope of the analysis abstracts the internal implementation of the components, assuming that these mechanisms are supported out of the software solution.