Reactivity of HTcO4 with methanol in sulfuric acid: Tc-sulfate complexes revealed by XAFS spectroscopy and first principles calculations

The reaction between HTcO4 and MeOH in 13 M H2SO4 was investigated by 99Tc NMR, UV-visible and X-ray absorption fine structure (XAFS) spectroscopy. Experimental results and first principles calculations show the formation of Tc(+5) sulfate complexes. The results expand the fundamental understanding of Tc in high acid solutions

On the nature of heptavalent technetium in concentrated nitric and perchloric acid

The speciation of Tc(+7) was performed in HClO4 and HNO3 by 99-Tc NMR, UV-Vis and XAFS spectroscopy. The speciation of Tc(+7) depends on the concentration and strength of the acid. Pertechnetic acid, HTcO4, forms above 8 M HClO4 while in concentrated HNO3, [TcO4]− is still the predominant species. EXAFS spectroscopy shows that the structure of HTcO4 in HClO4 is similar to the one in H2SO4. The reactivity of Tc(+7) was analyzed in the frame of the partial charge model. The partial charge calculated on the Tc atoms (ΔTc) indicates that HTcO4 (ΔTc = +057) is more electrophilic than [TcO4]− (ΔTc = +0.52). The difference in the oxidizing properties between [TcO4]− and HTcO4 is given from the reaction of these species with 12 M HCl(aq). In 13 M sulfuric acid HTcO4 is reduced to Tc(+5) while [TcO4]− is not reduced in 6 M H2SO4

Detecting Feature Interactions: How Many Components Do We Need?

Features are a structuring mechanism for <i>additional</i> functionality, usually in response to changing requirements. When several features are invoked at the same time, by the same, or different components, the features may not interwork. This is known as <i>feature interaction</i>. We employ a property-based approach to feature interaction detection: this involves checking the validity (or not) of a temporal property against a given system model. We use the logic LTL for temporal properties and the model-checker Spin to prove properties. To gain any real insight into feature interactions, it is important to be able to infer properties for networks of <i>any</i> size, regardless of the underlying communication structure. We present an inference mechanism based on abstraction. The key idea is to model-check a system consisting of a constant number (<i>m</i>) of components together with an <i>abstract</i> component representing any number of other (possibly featured) components. The approach is applied to two systems with communication which is peer to peer and client server. We outline a proof of correctness in both cases. The techniques developed here are motivated by feature interaction analysis, but they are also applicable to reasoning about networks of other types of components with suitable notions of data abstraction

Fair model checking with process counter abstraction

10.1007/978-3-642-05089-3_9Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)5850 LNCS123-13

Invariant Generation for Parametrized Systems using Self-Reflection

We examine the problem of inferring invariants for parametrized systems. Parametrized systems are concurrent systems consisting of an a priori unbounded number of process instances running the same program. Such systems are commonly encountered in many situations including device drivers, distributed systems, and robotic swarms. In this paper we describe a technique that enables leveraging off-the-shelf invariant generators designed for sequential programs to infer invariants of parametrized systems. The central challenge in invariant inference for parametrized systems is that naïvely exploding the transition system with all interleavings is not just impractical but impossible. In our approach, the key enabler is the notion of a reflective abstraction that we prove has an important correspondence with inductive invariants. This correspondence naturally gives rise to an iterative invariant generation procedure that alternates between computing candidate invariants and creating reflective abstractions