dataesr/scientific-paragraphs-categorization huggingface dataset:
Preliminary experiments Now that the applications and the test bench have been described, preliminary experiments need to be done in order to find information leakage. Where should the EM probe be located, what can we see at this location? For this part, a RF-R 0. 3-3 probe from Langer was used (bandwidth from 30MHz to 3GHz). The probe is moved over the board (not only the chip since leakage can occur at other locations) and on both sides of the board. Then data is measured for 250ns both during a real sbox computation and when no computation at all is performed (idle state). Fig. 1:  A trace measured during an s-box computation. A pattern which may be a memory access is stressed out. A measured trace is shown on figure  1  corresponding to an s-box computation. Patterns can clearly be seen but do not seem synchronized with our computation.
Here, the success metric used is the ratio of successful detection that the secret PIN digit is equal to the candidate (for 10 digit values, a purely random method would have a 10% success rate). For the 10 secret digit values (for 1 candidate value only), template classes where created from the measurement of 200k traces. In other words, for each secret value, 200k traces where measured and used to characterize the signal corresponding to this secret (forming one template class). This is the learning dataset. Then 15k additional traces where measured, here again for each secret value. This is the test dataset. Our success rate is measured by trying to match these 10 • 15k = 150k traces to each one of the 10 template classes. Let r be the actual, true, success rate and p the measured success rate.
22%). The TrustZone and the activity of other cores have no effect on the attack success rate. It can be observed on the last two rows of table 2 that using a bigger sampling rate can decrease the success rate, below our error interval. We attribute this paradoxical effect to our principal component analysis (PCA) preprocessing that select the dimensions maximizing the variance. Since at the end of the PCA 10kpts traces are obtained whatever the size of the input traces (20kpts or 50kpts), it is possible that the preprocessing reduces our success rate by maximizing variance not linked with the secret, such as variance generated by the activity of other cores. Therefore, the preprocessing is able to efficiently compress the template data (traces size divided by 5), but at the cost of a reduced success rate.
Conclusion The difficulty of adapting side-channel attacks to high-end devices has often been supposed. We have seen that the true difficulty arises from the need for a more precise synchronization with the leakage. If the attacker is able to synchronize, simple attacks (CPA) have been shown to be successful. The activity of other cores and the utilization of TrustZone have no effect on the attacks efficiency. As expected the TrustZone, a hardwareassisted software protection mechanism, offers no SCA protection. It may be a problem when most TrustZone capable devices are embedded systems that may endure physical attacks. Yet if synchronization is not possible, there are some attacks (e. g. template attacks) that are able to exploit the time dimension as any other dimension. We hint that such techniques may be more common in the future to overcome the true difficulty with high-end devices: dealing with time precision (problem even worse with an OS or a virtual machine).
Here again TrustZone or the activity of other cores have no incidence. But with these attacks, managing the big amount of data generated by our measures may prove to be the limiting factor, requiring better computing resources. Even if side-channel attacks techniques have to be adapted to the new challenges created by high-end devices, there is no reasons that they will not be as successful as on smartcards. The smartphone industry in particular should rapidly move to SCA-proof technologies before the development of these attacks.
TEM Measurements (SAC) Images were obtained using a Philips CM12 microscope at 120 kV. Samples were prepared by different protocols depending on whether they come as a power or suspension. For powders, they were dispersed by ultrasonication in acetone or ethanol. The suspensions were used as delivered or after a step of dispersion followed by vortex agitation. In both cases, a drop was deposited on a grid, excess sample was removed with a filter paper and the sample was left for drying under air a few minutes. EM grids were "Lacey Carbon (S166-3H)" or "carbon films (S160-H)" purchased from Agar. The Lacey carbon grids were preferred in the case of agglomerated samples such as TiO 2 -P25 or TiO 2 -A12. All the images obtained from TEM were analyzed using the ImageJ software (version 1. 51, NIH, Bethesda, MD, USA)  [58]  and the line measurement tool.
SAXS measurements on Ludox samples were carried out after a factor 100 dilution in water. This was done to ensure a dilute regime compatible with the observation of typical form factors of the nanoparticles, and to minimize the structure factor contribution arising from nanoparticle interactions. Calculations of monodisperse spherical form factors were made using the SASFit [62] software and were compared with experimental data. The diameter refinement was performed to obtain the best agreement with experimental data, in particular regarding the position of intensity minima and maxima. Reliability ranges corresponding to acceptable sphere diameters were estimated for each sample.
Size determination of PS22 with AFM appears to be the most accurate (average size = 21. 5 ± 4. 6 nm). It should be noticed that this average value is itself an average value of several different AFM experiments (Figure  1B ). AFM data consisted of 395 measurements performed on nine different and independent experimental conditions using various size measurement approaches (see Materials and Methods and Figure  S5 ). Heterogeneity in AFM measurements seemingly resembles those observed in average values from different techniques with minimum and maximum values ranging from 17 to 25 nm in both cases, although AFM data show a larger standard deviation. Globally, results obtained on PS22 are within a 25% variation (percentage amplitude) among the four tested biophysical methods. Remarkably, the extreme variations cancel out to provide a global average value equal to the expected calibrated value.
The global average value of all tested direct techniques is shown in the last column (in red). The two sub-populations observed in wet-STEM were described prior to the change of TEM(GRE) protocol. The larger size populations are colored in yellow, whereas smaller size populations are in orange. Global average of NP sizes within the same technique is colored in pink. The large SD values in AFM data (green columns) prompted checking for the presence of smaller NPs in TEM data by changing the protocol of NPs deposition (TEM1, carbon floatation; and TEM2, direct deposition; see Materials and Methods). For both NPs, the TEM2 method identified the presence of smaller NPs than with the TEM1 method, in close agreement with AFM results (which is using a direct deposition method). The global average value of all tested direct techniques is shown in the last column (in red).
Acknowledgments: The initial part of this work was inspired by discussions at the European  COST Action   TD1002 :  AFM4NanoMed&Bio  within the working group 4 (http://afm4nanomedbio. eu/working-group-4. aspx):  Vesna Svetličić ,  Tea Mišić  and  Galja Pletikapić  ( IRB Zagreb ),  Alessandro Podestà  ( Univ. Milano), Jean-Nicolas Audinot (Luxembourg Inst. Sci. Technol. ). We thank  Marie Carrière  ( CEA/INAC Grenoble ) for her advice concerning nanoparticles. We acknowledge the  TEM-team CEA/DRF platform  for the use of  TEM Philips.
Data-oriented systems and applications are at the centre of current developments of the World Wide Web. In these scenarios, assessing what policies propagate from the licenses of data sources to the output of a given data-intensive system is an important problem. Both policies and data flows can be described with Semantic Web languages. Although it is possible to define Policy Propagation Rules (PPR) by associating policies to data flow steps, this activity results in a huge number of rules to be stored and managed. In a recent paper, we introduced strategies for reducing the size of a PPR knowledge base by using an ontology of the possible relations between data objects, the Datanode ontology, and applying the (A)AAAA methodology, a knowledge engineering approach that exploits Formal Concept Analysis (FCA).
In  [7] , we studied how a PPR knowledge base can be compressed by using an ontology of the possible relations between data objects, the Datanode ontology  4  , and by applying the (A)AAAA methodology, a knowledge engineering approach that exploits Formal Concept Analysis (FCA). In this article we illustrate how reasoning on policy propagation can be practically performed. Building upon  [7] , we report on an extension of the (A)AAAA methodology that includes a coherency check between the hierarchy of the FCA lattice and the Datanode ontology. This extension was necessary in order to exploit the compressed rule base during reasoning and avoid incorrect results. While the compression of the rule base reduces the number of rules to be managed, it requires the reasoner to compute more inferences.
Therefore, we study the impact of rule base compression on the performance of the reasoning process. In other words, this article focuses on two contributions that relate to the aspect of reasoning with (compressed) PPRs, which was missing in  [7] : 1-the extension of the (A)AAAA methodology by adding an additional coherency check step to the Assessment phase, and 2-the evaluation of the effect of compression on reasoning performance. The article is structured as follows. Section 2 reviews the relevant literature. Section 3 presents an exemplary use case, and introduces the elements for reasoning on policy propagation, going through the description of the data flow, the representation of policies, and the concept of Policy Propagation Rule (PPR). Section 4 provides a summary of the (A)AAAA methodology, integrated with a novel Assessment phase that includes a coherency check algorithm that allows effective reasoning with a compressed rule base.
Related Work In recent years, data repositories and registries have been growing, spanning from data cataloguing services (Datahub 5 ), data collections (Wikidata 6 , Europeana 7 ), to platforms that manage the collection and redistribution of data (Socrata 8 ). An emerging category of such systems are City Data Hubs, which need to support developers not only in obtaining data, but also in assessing the policies associated with data resulting from complex pipelines  [12, 3, 2]. It is therefore for these systems to implement technologies that allow policies associated to derived datasets to be computed. In this article we concentrate on the problem of reasoning with propagating policies. Policies can be represented on the Web in a machinereadable format. The W3C ODRL Community Group 9  works on the development of a set of specifications to enable interoperability and transparent communication of policies associated with software, services, and data.
For instance, partitive relations influence the attached policies but are not derived from any action on the data. Nevertheless, a PPR reasoner can surely benefit from a well-defined semantics of ODRL actions. Recently, the W3C Permissions & Obligations Expression Working Group 11  followed up on ODRL to develop an official W3C standard for defining permissions and obligations. The RDF Licenses Dataset  [28]  is an attempt to establish a knowledge base of license descriptions based on RDF and the ontology provided by ODRL. It also uses other vocabularies aimed to extend the list of possible actions, for instance the Linked Data Rights 12  vocabulary. Process executions can be described in the Semantic Web using the Provenance Ontology (PROV-O)  [24]. PROV-O describes workflow executions in terms of agents, actions and assets involved.
The Datanode ontology has been designed to describe Semantic Web applications by means of the relations between the data involved in their processes  [6]. The ontology is a taxonomy of possible relations that may occur between data objects, which might be part of a process execution, such as the ones described with PROV-O. It can therefore be used to further qualify the implications of the actions performed in such a process. Datanode can describe process implications in a data-oriented way, namely as network of data objects. While policies and process executions can be represented, in the present paper we aim at studying the process of reasoning upon the propagation of policies across a data flow. Rule-based representation and reasoning over policies is required in order to enable secure data access and usage in distributed environments, particularly in the Semantic Web  [25, 13, 4].
These contributions form the background of the approach we are following in the present work. The problem of compressing propositional knowledge bases has been extensively studied in the past, focusing on the optimization of a Horn minimization process to improve the performance of rule execution  [17, 5]. Differently, we deal with compression as a mean to reduce the number of minimal rules to be managed (each PPR being already an atomic rule), by means of an additional knowledge base (the Datanode ontology). It is worth noting that our problem is not one of policy enforcement, but of providing the right information about policies that might affect the terms of use of a given asset produced by a complex data flow. This problem is also different from the one of minimizing access control policies (example, the abstraction by subsumption proposed in  [19] ), as the abstraction required is on the propagation of the policy, not the policy itself.
Permissions, in turn, can comprise a odrl:duty (or more). For example, the RDF Licenses Dataset  [28]  is a source of such descriptions. In our work, we also developed ad-hoc RDF documents to satisfy this requirement, when necessary. Description of the data flow. Data flows are represented with the Datanode ontology  [6]. The terms are defined under the http://purl. org/ datanode/ns/ namespace (we use the prefix dn: for readability). The ontology defines a unique type -dn:Datanode -and 115 relations, starting from a single top property: dn:relatedWith, having dn:Datanode as rdfs:domain and rdfs:range. An instance of dn:Datanode is any data object that can be the input or output of a process. The ontology groups the relations under five main dimensions  14  , summarized in Figure  1 : Adjacency.
dn:adjacentTo represents proximity between two datanodes in a data container. For example, proximity may result from being parts of the same datasetdn:disjointPartWith, or being an annotation of the dataset -dn:hasAnnotation, or an attachment -dn:attachedTo. Derivation. This branch specializes dn:hasDerivation in a number of different forms. Examples cover activities like mining -dn:hasExtraction, selection -dn:isSelectionOf, reasoning -dn:hasInference, remodelling dn:remodelledFrom, or the activity of making snapshots of data or cachesdn:hasSnapshot, dn:hasCache, to mention a few. Metalevels. This dimension covers the relations between a data object and its metadata. The property dn:metadata is used to designate a relation with information that applies to the datanode as a whole. This relation specializes as dn:describes, dn:hasAnnotation and dn:hasStatistics.
Interpretation. This is designed to capture the possibility that a datanode might contribute to inferences that can be made in another one. Two datanodes might be "understood" together, i. e. their content can be compared, or the interpretation (inferences) of one may affect the interpretation (inferences) of another. The more intuitive examples are dn:consistentWith and dn:inconsistentWith. However, this is also the area of the ontology that covers partitive relations: dn:isPartOf and the two specializations dn:isPortionOf and dn:isSectionOf. In Datanode, portion refers to a part of the population of a dataset (such as the rows of a spreadsheet), while section refers to a set of values for a certain dimension in a dataset (for example, a column of a spreadsheet). Capabilities. Capability is intended as the power or ability to generate an outcome  15.
Capability is covered with two separate branches starting from dn:overlappingCapabilityWith and dn:differentCapabilityFrom, respectively. Two datanodes may have similar (or different) potential. For example, dn:overlappingVocabularyWith and dn:overlappingPopulationWith express the similarity between two data objects in terms of vocabulary or population of a dataset. Under this scope, we also positioned dn:optimizedInto (also a kind of derivation), to state the empowerment of an existing capability. It is worth noting that Datanode relations often have multiple ancestors. For example, dn:hasStatistics is both a dn:hasComputation and a dn:describedBy kind of relation, which in turn are subsumed by dn:hasDerivation and dn:metadata respectively. Similarly, dn:hasAnnotation relates a datanode to some attached metadata, therefore it is subsumed by dn:attachedTo and dn:metadata.
E. Daga et al. / Reasoning with Data Flows and Policy Propagation Rules by the path ex:descriptionsFromFlickr dn:samePopulation / dn:isPortionOf ex:events. Therefore, the data flow is a backtrace of the abstract process of the EventMedia system, from the ex:output data object towards the input data sources. The data flow described so far can be leveraged by a reasoner in conjunction with the ODRL policies of the inputs, and the PPRs, to infer the policies associated with ex:output. Listing 3 shows the policies propagated from the inputs to the output of the EventMedia data flow, some of the deriving from the restrictions applied to Flickr data, shown previously in Listing 1 In  [7]  we considered the set of relations defined by Datanode and the policies defined in the RDF Licenses Dataset to generate a knowledge base of 3865 propagation rules.
In what follows we summarize the methodology, focusing on the coherency check element, and refer the reader to  [7]  for a general overview. The methodology is composed of the following phases: A1 -Acquisition. The initial task is to set up a knowledge base of PPRs. We used the Datanode ontology to extract a list of 115 possible relations between data objects, and combined them with 113 policies derived from the ones defined in the RDF License Dataset. The combination of relations and policies lead to a matrix of 12995 cells. This phase required a manual supervision of all associations between policies and relations in order to establish the initial set of propagation rules. This was performed with the support of the Contento tool  [9].
For example, Listing 5 shows the set of mismatches detected for concept 71. In this list, the dn:isVocabularyOf branch contains a number of relations that do not propagate the related policies, breaking the assumption that all the policies of dn:isVocabularyOf are also propagated by all the other relations in his branch. With the Fill operation, we can add all the necessary rules to remove this mismatch. After each operation, we run our process again from the Analysis phase to the Assessment, in order to evaluate whether the change fixed the mismatch and/or how much the change affected the compression factor. The process is repeated until all mismatches have been fixed, and there are no other quasi matches that can be adjusted to become full matches. Moreover, when new policies are defined in the dataset of licenses, the process has to be repeated in order to insert the new propagation rules.
org/ datanode/0. 3/ns/ and the modified version of the ontology can be found at http://purl. org/ datanode/0. 5/ns/. As previously mentioned, the Acquisition phase has been performed with the Contento tool  [9, 8]. The tools used in the other phases of the methodology, from the Abstraction to the Adjustment phases, can be found at https://github. com/enridaga/ppr-a-five. Highlighted are the maximum and minimum values for each of the data flow inputs. In one case (DISCOU-11), none of the policies attached to the source are propagated to the output.
Experiments The methodology described in the previous section allows to reduce the number of rules that need to be stored and managed. The results of applying this methodology on the PPR knowledge base derived from the RDF Licenses Dataset, show how the compression factor can be dramatically increased after several iterations. Our assumption in this work is that it might positively affect the performance of reasoning on policy propagation. Here, we therefore assess through realistic cases the performance of reasoners when dealing with a compressed knowledge base of PPRs, as compared to when dealing with the uncompressed set. We took 15 data flow descriptions from previous work  [6] , referring to 5 applications that rely on data obtained from the Web. Each data flow represents a data manipulation process, consuming a data source (sometimes multiple sources), and returning an output data object.
Alternatively, a reasoner can compute all possible inferences at the time the knowledge base is loaded, and only explore the materialized facts at query time. In order to appropriately address both of those reasoning strategies, we run the experiments with two different reasoners. The first reasoner performs the inference at query time using a backward chaining approach; is implemented as Prolog program and we will refer to it as the Prolog reasoner. The second reasoner computes all the inferences at loading time (materialization); is implemented as an RDFS reasoner in conjunction with SPIN rules, and we will refer to it as the SPIN reasoner. Both reasoners are implemented in Java within the PPR Reasoner project  30. Both reasoners have the capability of executing PPRs and expand the results according to the ontology hierarchy.
E. Daga et al. / Reasoning with Data Flows and Policy Propagation Rules The Prolog implementation is a program relying on JLog, a Prolog interpreter written in Java  31. The program incorporates a meta rule that traverses the set of PPRs, encoded as facts. At the same time, it supports the subsumption between relations. Listing 6 shows an excerpt of the program. The SPIN reasoner is built upon the RDFS reasoner of Apache Jena 32  in combination with SPIN  33  , a rule engine that allows to define rules using SPARQL. The core part of the reasoner executes PPRs as a SPARQL meta query (Listing 7). Listing 7: Construct meta-query of the SPIN reasoner.
Figures  8  and 9  illustrate the results of the experiments performed with the Prolog and the SPIN reasoner, respectively. For each data flow, the bar on the 34 Coefficient of Variation, also known as Relative Standard Deviation (RSD). https://en. wikipedia. org/wiki/ Coefficient_of_variation left displays the time with an uncompressed input, and the one on the right the time with a compressed input. We will follow this convention in the other diagrams as well. Figure  8c  displays a comparison of the total time between an uncompressed and compressed input with the Prolog reasoner. In all cases, there has been a significant increase in performance with the compressed rule base: in three cases (DBREC-5, DISCOU-1, REXPLORE-4) the uncompressed version of the experiment could not complete within the five minutes, while the compressed version returned results in less then a minute.
The Upcoming service is not available at the time of writing, however a snapshot of the documentation can be consulted from the Web Archive, reporting a non-commercial use clause: https: //web. archive. org/web/20130131064223/http: //upcoming. yahoo. com/services/api/. The application was firstly produced in 2014, when the EventMedia dataset description article was firstly submitted to the Semantic Web Journal. The description produced refers to the submitted version, which could be changed in the published version.