dataesr/scientific-paragraphs-categorization huggingface dataset:
Rating ranks are continuously observed for all agencies so that the exact dates of rating transitions are registered. We built three datasets starting from 1/1/1998 to 31/5/2017, depending on the data availability for each agency. The resulting datasets consist of 184. 340 observations for Moody's, 179. 686 observations for Fitch and 175. 916 for S&P 1. All data are grouped in 8 rating class such that: AAA (Aaa) = 1; AA (Aa) = 2; A = 3; BBB (Baa) = 4; BB (Ba) = 5; B = 6; CCC-CC-C (Caa-Ca-C) = 7; SD/RD = 8 for S&P / Fitch (Moody's). For the sake of clarity we will denote the rating notations as k = 1,. , 8. Conventionally, credit ratings from k = 1 to k = 4 are defined investment grade rating classes, while credit ratings from state k = 5 to state k = 8 are defined speculative grade rating classes.
1 The countries composing the datasets are 26 and not all the 28 Members of European Union, due to lack of data in the case of Cyprus and Estonia. The former are assigned to obligors with relatively low to moderate risk of default. Speculative grade rating categories denote an higher risk of default until the occurrence of the event of default or selected default. From the datasets we observed that most of the sample countries had an investment grade rating class. In fact, the percentage of speculative categories is low and it increases after the 2008 (around the financial crisis), reaching the maximum in the period surrounding the Greek crisis (  2012 ) with only the 19% of the sample experiencing this ranking. This was caused by the fact that after the 2008, European countries experienced a lot of downgrades (i.
Furthermore, we simulate the evolution of the credit spread by assigning the mean value of its distribution to the corresponding rating class. The dynamic index is then computed as showed in Equation (  8 ). Finally, the first and the second order moments result from the average value and the standard deviation of DT(t) over all Monte Carlo iterations. The whole methodology described in the present work has been implemented using the Python programming language  (Dubois et al. (1996) ) in order to obtain all results reported in the next Section. The main Python packages we used are NumPy  (Oliphant (2006) ), SciPy  (Jones et al. (2001) ), Matplotlib  (Hunter (2007) ) and PyQt4  (Summerfield (2007) ). The whole code can be easily downloaded by the following GitHub repositories: https://github.
com/lstorchi/markovctheil/ tree/continuous. The main computational kernel can be found in the mainmkvcmp. py source code file, when one can found the main_mkc_comp_cont function. Furthermore, there are two utilities one can use to reproduce the full set of results reported in the present paper: the markovc. py CLI code, and a minimal GUI implemented using PyQt that is the named markovc_qt. py.
Simulation in the Case of Brexit The whole methodology has been replicated for the Brexit scenario. To build this scenario we follow the hypothesis of independence, previously stated, between sovereign credit ratings and, as a consequence, between credit spreads. This is why we have just removed the historical data of United Kingdom (UK) from the datasets, without changing the other countries. As this country experienced only one transition from rating k = 1 to k = 2 , the generator matrices are similar with a Brexit 1,2 < a 1,2 ; a Brexit 2,1 > a 2,1 and a Brexit 2,3 > a 2,3. Furthermore, the credit spread distribution does not change dramatically. In fact, the average value of rating classes 1 and 2 reduces by, respectively, 6% and 2%. This is the reason, as shown in Figure  6 , the results about the financial inequality are close to the previous ones.
Discrete vs. Continuous The advantages of the continuous time framework are well known and documented. First of all, the main advantage refers to the ability of capturing all transitions. As a matter of fact, the continuous observation of the rating migrations (i. e. , in a daily scale) allows to estimate probabilities of rare events that we would never have observed in the discrete-time framework. Furthermore, by using daily data, the generator matrix estimated for Fitch matrices has dimension (8 × 8) while, using the discrete-time model the transition probability matrix have dimension (7 × 7). This happens because we observe the transition to and from the default state (RD), occurred only for four days in a month. Moreover from the S&P dataset we register two transitions to and from default state (k = 8).
varying model. These works suffer from two disadvantages of the traditional H ∞ solving method, the high order of the controller and the lack of robustness with respect to model uncertain parameters. In order to cope with those problems, we propose to use the Matlab's Systune toolbox which enables synthesizing structured controllers from H ∞ specifications and also to perform a robustness procedure to take model uncertainties into account  (Apkarian et al. , 2015). However, this procedure  (Apkarian et al. , 2015)  cannot ensure, in a guaranteed way, that the design and robustness constraints are reached for all possible values of model uncertain parameters. The sensitivity analysis of design objectives over model uncertainty is a non-convex problem. In order to solve this problem, we propose a global optimization approach which enables performing a robustness analysis in a guaranteed way based on Interval Analysis (see  (Kearfott, 1992)  and  (Monnet et al.
Decades went by since Mark Weiser published his influential work on the computer of the 21st century. Over the years, some of the UbiComp features presented in that paper have been gradually adopted by industry players in the technology market. While this technological evolution resulted in many benefits to our society, it has also posed, along the way, countless challenges that we have yet to surpass. In this paper, we address major challenges from areas that most afflict the UbiComp revolution: 1. Software Protection: weakly typed languages, polyglot software, and networked embedded systems. 2. Long-term Security: recent advances in cryptanalysis and quantum attacks. 3. Cryptography Engineering: lightweight cryptosystems and their secure implementation. 4. Resilience: issues related to service availability and the paramount role of resilience.
1. Software protection in Section 2: we study the impact of the adoption of weakly typed languages by resource-constrained devices and discuss mechanisms to mitigate this impact. We go over techniques to validate polyglot software (i. e. , software based on multiple programming languages), and revisit promising methods to analyze networked embedded systems. 2. Long-term security in Section 3: we examine the security of today's widely used cryptosystems (e. g. , RSA and ECC-based), present some of the latest threats (e. g. , the advances in cryptanalysis and quantum attacks), and explore new directions and challenges to guarantee long-term security in the UbiComp setting. 3. Cryptography engineering in Section 4: we restate the essential role of cryptography in safeguarding computers, discuss the status quo of lightweight cryptosystems and their secure implementation, and highlight challenges in key management protocols.
Software protection Modern UbiComp systems are rarely built from scratch. Components developed by different organizations, with different programming models and tools, and under different assumptions are integrated to offer complex capabilities. In this section, we analyze the software ecosystem that emerges from such a world. Figure  2  provides a high-level representation of this ecosystem. In the rest of this section, we shall focus specially on three aspects of this environment, which pose security challenges to developers: the security shortcomings of C and C++, the dominant programming languages among cyber-physical implementations; the interactions between these languages and other programming languages, and the consequences of these interactions on the distributed nature of UbiComp applications.
Type safety A great deal of the software used in UbiComp systems is implemented in C or in C++. This fact is natural, given the unparalleled efficiency of these two programming languages. However, if, on the one hand, C and C++ yield efficient executables, on the other hand, their weak type system gives origin to a plethora of software vulnerabilities. In programming language's argot, we say that a type system is weak when it does not support two key properties: progress and preservation  [14]. The formal definitions of these properties are immaterial for the discussion that follows. It suffices to know that, as a consequence of weak typing, neither C, nor C++, ensure, for instance, bounded memory accesses. Therefore, programs written in these languages can access invalid memory positions.
However, they are not required to always find security vulnerabilities in software. Furthermore, the runtime overhead of dynamic analyses still makes it prohibitive to deploy them into production software  [27]. As a middle point, several research groups have proposed ways to combine static and dynamic analyses, producing different kinds of hybrid approaches to secure low-level code. This combination might yield security guarantees that are strictly more powerful than what could be obtained by either the static or the dynamic approaches, when used separately  [28]. Nevertheless, negative results still hold: if an attacker can take control of the program, usually he or she can circumvent state-ofthe-art hybrid protection mechanisms, such as control flow integrity  [29]. This fact is, ultimately, a consequence of the weak type system adopted by languages normally seen in the implementation of UbiComp systems.
Therefore, the design and deployment of techniques that can guard such programming languages, without compromising their efficiency to the point where they will no longer be adequate to UbiComp development, remains an open problem. In spite of the difficulties of bringing formal methods to play a larger role in the design and implementation of programming languages, much has already been accomplished in this field. Testimony to this statement is the fact that today researchers are able to ensure the safety of entire operating system kernels, as demonstrated by Gerwin et al. [30] , and to ensure that compilers meet the semantics of the languages that they process  [31]. Nevertheless, it is reasonable to think that certain safety measures might come at the cost of performance and therefore we foresee that much of the effort of the research community in the coming years will be dedicated to making formal methods not only more powerful and expressive, but also more efficient to be used in practice.
In the second front, researchers have devised analyses that infer the contents  [48]  and the size of arrays  [49]  in weakly-typed programming languages. More importantly, recent years have seen a new flurry of algorithms designed to analyze C/C++ style pointer arithmetics  [50] [51] [52] [53]. The wide adoption of higher-level programming languages coupled with the construction of new tools to analyze lower-level languages is exciting. This trend seems to indicate that the programming languages community is dedicating each time more attention to the task of implementing safer distributed software. Therefore, even though the design of tools able to analyze the very fabric of UbiComp still poses several challenges to researchers, we can look to the future with optimism.
Cryptographic engineering UbiComp systems involve building blocks of very different natures: hardware components such as sensors and actuators, embedded software implementing communication protocols and interface with cloud providers, and ultimately operational procedures and other human factors. As a result, pervasive systems have a large attack surface that must be protected using a combination of techniques. Cryptography is a fundamental part of any modern computing system, but unlikely to be the weakest component in its attack surface. Networking protocols, input parsing routines and even interface code with cryptographic mechanisms are components much more likely to be vulnerable to exploitation. However, a successful attack on cryptographic security properties is usually disastrous due to the risk concentrated in cryptographic primitives.
Federated identity management system The IdM models guide the construction of policies and business processes for IdM systems but do not indicate which protocols or technologies should be adopted. SAML (Security Assertion Markup Language)  [173] , OAuth2  [174]  and OpenId Connect specifications stand out in the federated IdM context  [175, 176]  and are adequate for UbiComp systems. SAML, developed by OASIS, is an XML-based framework for describing and exchanging security information between business partners. It defines syntax and rules for requesting, creating, communicating and using SAML Assertions, which enables SSO across domain boundaries. Besides, SAML can describe authentication events that use different authentication mechanisms  [177]. These characteristics are very important for the interoperability between security technologies of different administrative domains to be accomplished.
Privacy implications UbiComp systems tend to collect a lot of data and generate a lot of information. Correctly used, information generates innumerable benefits to our society that has provided us with a better life over the years. However, the information can be used for illicit purposes, just as computer systems are used for attacks. Protecting private information is a great challenge that can often seem impractical, for instance, protecting customers' electrical consumption data from their electricity distribution company  [184] [185] [186]. Ensuring security is a necessary condition for ensuring privacy, for instance, if the communication between clients and a service provider is not secure, then privacy is not guaranteed. However, it is not a sufficient condition, for instance, the communication is secure, but a service provider uses the data in a not allowed way.
Regulation UbiComp systems tend to run worldwide. Thus, their developers need to deal with several laws from distinct cultures. The abundance of laws is a challenge for international institutions. The absence of laws too. On the one hand, the excess of laws compels institutions to handle a huge bureaucracy to follow several laws. On the other hand, the absence of laws causes unfair competition because unethical companies can use private data to get advantages over ethical companies. Business models must use privacy-preserving protocols to ensure democracy and avoid a surveillance society (see  [187] ). Such protocols are the solution for the dilemma between privacy and information. However, they have their own technological challenges.
Differential privacy The idea of differential privacy is similar to the idea of indistinguishability in cryptography. For defining it, let be a positive real number and A be a probabilistic algorithm with a dataset as input. We say that A isdifferentially private if for every dataset D 1 and D 2 that differ in one element, and for every subset S of the image of A, we have Pr [A (D 1 ) ∈ S] ≤ e × Pr [A (D 2 ) ∈ S] , where the probability is controlled for the algorithm randomness. Differential privacy is not a metric in the mathematical sense. However, if the algorithms keep the probabilities based on the input, we can construct a metric d to compare the distance between two algorithms with d (A 1 , A 2 ) = | 1 -2 |. In this way, we can determine if two algorithms as equivalents 1 = 2 , and we can determine the distance from an ideal algorithm computing d (A 1 , A ideal ) = | 1 -0|.
Entropy and the degree of anonymity The degree of anonymity g can be measured with the Shannon entropy H(X) = N i=1 p i • log 2 1 p i , where H(X) is the network entropy, N is the number of nodes, and p i is the probability for each node i. The maximal entropy happens when the probability is uniform, i. e. , all nodes are equiprobably 1/N, hence H M = log 2 (N). Therefore, the anonymity degree g is defined by g = 1 - H M -H(X) H M = H(X) H M. Similar to differential privacy, we can construct a metric to compare the distance between two networks computing d g 1 , g 2 = |g 1g 2 |. Similarly, we can compare if they are equivalent g 1 = g 2. Thus, we can determine the distance from an ideal anonymity network computing d g 1 , g ideal = |g 1 -1|. The network can be replaced by a dataset, but in this model, each register should have a probability.
Complexity Complexity analysis also can be used as a metric to measure the time required in the best case for retrieving information from an anonymized dataset. It can also be used in private-by-design data as the time required to break a privacy-preserving protocol. The time measure can be done with asymptotical analysis or counting the number of steps to break the method. All techniques have their advantages and disadvantages. However, even though the complexity prevents the leakage, even though the algorithm has differential privacy, even though the degree of anonymity is the maximum, privacy might be violated. For example, in an election with 3 voters, if 2 collude, then the third voters will have the privacy violated independent of the algorithm used. In  [191] , we find how to break protocols based on noise for smart grids, even when they are provided with the property of differential privacy.
Private-by-design data Messages is the common word for private-by-design data. Messages are transmitted data, processed, and stored. For privacy-preserving protocols, individual messages should not be leaked. CryptDB 7 is an interesting tool, which allows us to make queries over encrypted datasets. Although messages are stored in a dataset, they are encrypted messages with the users' keys. To keep performance reasonable, privacy-preserving protocols aggregate or consolidate messages and solve a specific problem.
Another type is extrinsic approaches, whereby specially designed data are proactively injected into the signals/data or into the physical world and later a b extracted and examined to infer or verify the hosting data's origin, integrity, processing history, or capturing environment. In mid of the convergence between digital and physical systems with sensors, actuators and computing devices becoming closely tied together, an emerging framework has been proposed as Proof-Carrying Sensing (PCS)  [197]. This was inspired by Proof-Carrying Code, a trusted computing framework that associates foreign executables with a model to prove that they have not been tampered with and they function as expected. In the new UbiComp context involving cyber physical systems where mobility and resource constraints are common, the physical world can be leveraged as a channel that encapsulates properties difficult to be tampered with remotely, such as proximity and causality, in order to create a challenge-response function.
The challenge in designing and securely implementing such protocols can be addressed by the synergy of combined expertises such as signal processing, statistical detection and learning, cryptography, software engineering, and electronics. To help appreciate the intrinsic and extrinsic evidences in addressing the security and forensics in UbiComp that involves both digital and physical elements, we now discuss two examples. Consider first an intrinsic signature of power grids. The electric network frequency (ENF) is the supply frequency of power distribution grids, with a nominal value of 60Hz (North America) or 50Hz (Europe). At any given time, the instantaneous value of ENF usually fluctuates around its nominal value as a result of the dynamic interaction between the load variations in the grid and the control mechanisms for power generation.
A major challenge and research opportunity lies on discovering and characterizing suitable intrinsic and extrinsic evidences. Although qualitative properties of some signatures are known, it is important to develop quantitative models to characterize the normal and abnormal behavior in the context of the overall system. Along this line, the exploration of physical models might yield analytic approximations of such properties; and in the meantime, data-driven learning approaches can be used to gather statistical data characterizing normal and abnormal behaviors. Building on these elements, a strong synergy across the boundaries of traditionally separate domains of computer forensics, information forensics, and device forensics should be developed so as to achieve comprehensive capabilities of system forensics in UbiComp.
Conclusion In the words of Mark Weiser, Ubiquitous Computing is "the idea of integrating computers seamlessly into the world at large"  [1]. Thus, far from being a phenomenon from this time, the design and practice of UbiComp systems were already being discussed one quarter of a century ago. In this article, we have revisited this notion, which permeates the most varied levels of our society, under a security and privacy point of view. In the coming years, these two topics will occupy much of the time of researchers and engineers. In our opinion, the use of this time should be guided by a few observations, which we list below: -UbiComp software is often produced as the combination of different programming languages, sharing a common core often implemented in a type-unsafe language such as C, C++ or assembly.
-Several databases currently store sensitive data. Moreover, a vast number of sensors are constantly collecting new sensitive data and storing them in clouds. Privacy-preserving protocols are being designed and perfected to enhance user's privacy in specific scenarios. Cultural interpretations of privacy, the variety of laws, big data from legacy systems in clouds, processing time, latency, key distribution and management, among other aforementioned are challenges for us to develop privacy-preserving protocols. -The convergence between the physical and digital systems poses both challenges and opportunities in offering forensic capabilities to facilitate the authentication of data as well as the access conditions including who, when, where, and how; a synergistic use of intrinsic and extrinsic evidences with interdisciplinary expertise will be the key.
Obtaining the necessary data Through his publication, Glick provides guidance on ways to obtain data on parameters required for calculating a sample size based on a test statistic, especially when data require to be generated through specific assumptions when evaluating new interventions  [10]. Additional parameters are needed for using our method: the size of the target population (N), the annual discount rate (τ), the time horizon in years (k), and the cost per participant included (C p ). The size of the target population can be estimated through prevalence and incidence data from registries, large cohort studies, medico-administrative databases, or surveillance systems. N has to be calculated over the entire time horizon used for the estimation of EVPI n. It is usually easier to gather data on the annual number of individuals susceptible to benefit from the new intervention.
Application Data were extracted from a sample size calculation computed for a planned randomized trial-based CEA comparing telemedicine to face-to-face care in elderly patients with complicated chronic wounds in nursing homes. The expected per patient cost of telemedicine was 477€. It took into account the mean number of teleconsultation/ patient; the duration of a teleconsultation; the cost of the informatics equipment for telemedicine, and their amortization over 3 years; and the expected number of teleconsultations. The expected per patient cost of face-to-face care was 645€ and took into account the mean number of consultation/patient; the proportion of patients needing a consultation with a dermatologist or a day hospitalization in a geriatric department; the cost of consultations and day hospitalizations, and the cost of medical transportations.