dataesr/scientific-paragraphs-categorization huggingface dataset:
ACKNOWLEDGMENTS Research reported in this article was supported by  European Molecular Biology Organisation Long Term Postdoctoral Fellowship EMBO   ALTF 1261-2007  to J. B. and by the  National Institute of General Medical Sciences  of the  National Institutes of Health  under award number  R01GM026338. The content is solely the responsibility of the authors and does not necessarily represent the official views of the National Institutes of Health. The authors thank  Yongli Zhang  for his advice about previous work on aligning temporal data.
Current work on computational reflection is single-minded; each reflective procedure is written with a specific application or scope in mind. Composition of these reflective procedures is done by a proofgenerating tactic language such as Ltac. This composition, however, comes at the cost of both larger proof terms and redundant preprocessing. In this work, we propose a methodology for writing composable reflective procedures that solve many small tasks in a single invocation. The key technical insights are techniques for reasoning semantically about extensible syntax in intensional type theory. Our techniques make it possible to compose sound procedures and write generic procedures parametrized by lemmas mimicking Coq's support for hint databases.
Specification & Implementation Definition bstM : bmodule := { bfunction "lookup"("s", "k", "tmp") [ lookupS] "s" ← * "s";; [ ∀ s, ∀ t, PRE[ V] bst' s t (V "s") * mallocHeap POST[ R] (V "k" ∈ s) \is R * bst' s t (V "s") * mallocHeap] While ("s" = 0) { "tmp" ← * "s" + 4;; If ("k" = "tmp") { Return 1 (* Key matches! *) } else { If ("k" < "tmp") { "s" ← * "s" (* Lower key *) } else { "s" ← * "s" + 8 (* Higher key *) } } };; Return 0 }. For example, Coq's autorewrite tactic is based on hint databases that package together a collection of rewrites and associated tactics to solve side conditions. These features, however, have not made their way to reflective procedures.
Domain-Specific Hints & Proof In this work, we focus on building extensible reflective procedures that perform many reasoning steps in a single invocation. Figure  1  demonstrates the degree of automation that we achieve applying our techniques to program verification in Bedrock  [4] , a Coq  [6]  library for low-level, imperative programming. Note that the implementation is completely separated (with the exception of loop invariants) from the automated verification. Effective automation for verifying such a program requires simultaneously reasoning about abstract predicates, low-level machine words, and high-level sets. To that end, our automation (sep) is written modularly and composed into large reflective procedures. Reasoning for problem-specific constructs is incorporated via HintDatabases that are constructed completely automatically from both fully verified reflective procedures (similar to Ltac's Hint Extern) and guarded rewriting lemmas (similar to Ltac's Hint Rewrite.
3). Our approach allows us to build independent pro- cedures for reasoning about different domains, such as lists and bit-vectors, and compose them after the fact. -Finally, our proof procedures are easy to customize and extend without knowing about the details of reflection. One drawback of reflective verification has been the need to write and verify programs in order to extend the automation. Combining the above techniques, we have built a more elementary interface that allows users to construct verified hint databases from Coq theorems completely automatically and pass them to generic reflective automation that applies the theorems (Section 3. 4). After presenting our technical contributions, we evaluate the performance and power of our automation (Section 4) and discuss related work (Section 5).
Our techniques are implemented in the MirrorShard library that lays the foundation for the Bedrock automation. Both repositories are available online. https://github. com/gmalecha/mirror-shard/ https://github. com/gmalecha/bedrock-mirror-shard/ 2 Simple Entailment: A Computational Reflection Primer Before diving into the novel bits, we sketch the high-level approach of computational reflection. We use entailment checking in a toy fragment of propositional separation logic  [16]  as our running example. Separation logic describes the program state compositionally by splitting it into disjoint pieces using the separating conjunction (notated * ), which has the empty state (notated ∅) as its unit. For example, the formula P * Q * R * ∅ states that the entire program state can be divided into three disjoint parts described respectively by the opaque propositions P , Q, and R.
To simplify passing provers around, we package them with their constraints and their soundness proofs using Coq's dependent records 6. Record HintDatabase := { Types : constraints Type ; Funcs : ∀ ts, constraints (func (applyC Types ts)) ; Prover : ∀ ts, ProverT (applyC Types ts) ; Prover_sound : ∀ ts fs, ProverOk (applyC Types ts) (applyC (Funcs ts) fs) (Prover ts) }. The first two fields represent the constraints for the type and function environments, with the latter phrased using our technique. The Prover field would contain the functional prover code, e. g. prove_sum_comm wrapped in our prover interface. The final field, Prover_sound, would contain the proof that the procedure is sound, derived from prove_sum_comm_sound. To invoke a reflective procedure with a particular hint database, we rely on Ltac to handle the constraints.
For example, the top-level soundness lemma for cancellation has the following form: Theorem Apply_cancel_sound ts (fs : fenv ts) (prover : ProverT ts) (prover_ok : ProverOk ts fs prover) : ∀ (lhs rhs : sexpr ts) (us vs : env ts),. To apply such a theorem, our reification process projects out the constraints from the hint database and uses them as base environments when constructing the syntactic terms. We can then instantiate the prover and its soundness proof to work on the extended environments (distinguished using primes) by simple application.
Apply_cancel_sound ts' fs' (hints. (Prover) ts' : ProverT ts' (*≡ProverT (applyC hints. (Types) ts')*)) (hints. (Prover_sound) ts' fs' : ProverOk ts' fs'). Taking a closer look at the types we notice that the definition of applyC justifies the type assertions for the final two arguments. For example, the third argument actually has type ProverT (applyC hints. (Types) ts'), but since we construct ts' to retain the entries of hints. (Types), this type is definitionally equal to ProverT ts'. 6 The HintDatabase record in MirrorShard contains an additional field for the constraints on the predicate environment, but our example does not require it.
While complex, this proof is done once and used whenever we need to type-theoretically strengthen the result of unification. Fig. 3. Verification process and the breakdown of verification time. To make rewriting hints easy to use, we have completely automated the construction of syntactic lemmas and their composition into (an extended version of) the hint databases described in the previous section. These extended hint databases carry two lists of lemmas, one for forward rewriting and the other for backward rewriting, as well as their corresponding proof terms.
Evaluation & Discussion The techniques in Sections 3. 2-3. 4 form the core insights of the MirrorShard framework. In this section we discuss our results applying this framework to verify programs written in the Bedrock system. We begin with an overview of the end-to-end verification process before justifying our claims from the introduction about the benefits of building broader reflective procedures. We restrict our evaluation to a collection of data structure libraries including a memory allocator, linked-list operations, sets implemented as unsorted lists and binary trees, and queues. Together, these constitute approximately 355 lines of code that generate 253 verification conditions. The source code to these examples is found in the examples directory of our bedrock-mirror-shard repository.
The Verification Procedure The end-to-end automation that verifies an entire Bedrock module is broken down into three independent, reflective tasks (verification condition generation, symbolic execution, and entailment checking) punctuated by Ltac-based higherorder reasoning. Figure  3  shows the overall process. We focus on the latter two tasks that, combined, apply to a single verification condition. Each verification condition assumes a precondition and that a particular code path is followed. The obligation is to show either that the code runs without errors (progress) or finishes in a state satisfying some postcondition (preservation). We focus on the second case since it is more interesting. To solve a preservation verification condition, symbolic execution runs to compute the (strongest) postcondition of the path under the precondition.
In order to exploit this information during symbolic execution, our symbolic executor uses the following hint, provided in a hint database: This lemma is fed to the reflective rewriting framework discussed in Section 3. 4, which exposes the → predicate that symbolic execution knows how to interpret 7. Without this mechanism, we could achieve the same automation by running an Ltac loop bouncing between our reflective symbolic execution and the autorewrite tactic to perform this rewriting. In the above example, this loop would call symbolic execution, which would get stuck on the final instruction, falling back on autorewrite to expose the cons cell, enabling a second call to symbolic evaluation to complete the task. Figure  4  shows how the loop approach compares to our fully reflective procedure (1-Shot).
Using the latter, the entire symbolic execution takes 0. 39 seconds, less than half the amount of time (0. 89 seconds) taken by autorewrite to perform just the rewriting. Overall the reflective composition results in a 4. 6x speedup over the Ltac-based composition on this goal, translating into 44 seconds when applied to the entire linked-list module. While our reflective rewriter is not as powerful as autorewrite, it is customizable in the same way. Further, because it is written in Gallina rather than hardcoded inside Coq, we can extend it with smarter unification that, for example, can reason about provable rather than just definitional equality.
Several projects have built large, generic reflective procedures. In his PhD thesis, Lescuyer  [14]  describes a reflective implementation of an SMT solver. While he also uses an environment-based representation, he is unable to reason about it semantically. As a result, it is not clear how to support first-class hint databases or include additional theories that need to reason semantically about symbols represented using the environment. Our work also supports quantifiers. Similar to our rewriting engine is the work by Braibant and Pous on reasoning modulo associativity and commutativity  [3]. Like Lescuyer, they specialize their procedures for reasoning semantically about a fixed set of symbols (in their case an abstract commutative, associative operator), which removes the need to reason about multiple types or multiple operators.
Our techniques support both. Recent work by Claret et al. [5]  on posterior simulation for reflective proofs aims to make it easier to write reflective procedures by supporting side effects and branching proof search efficiently. This goal is complementary to our own work and offers a method of automatic caching for results of the (potentially large) proof searches that our extensible procedures enable. This caching may become essential if reflective procedures begin to rely heavily on speculation. In the wider sphere of proof automation, Mtac  [18]  proposes a monadic language for writing Gallina terms that are run during program elaboration. Unlike MirrorShard, Mtac supports dependent and polymorphic types; however, its support for binder manipulation is less sophisticated. For example, it does not appear to be possible to apply lemmas without knowing their types a priori, making it difficult to parametrize by lemmas that are applied automatically.
The Ssreflect tactic library  [10]  has become a popular alternative to Ltac. Ssreflect provides a higher-level tactic language and support for "small-scale" reflection. The tactics aim to make it easier to refactor proofs and lemmas, but it is still focused on smaller reasoning steps. This approach avoids the need to compose reflective procedures but requires more effort by the user to determine and perform the appropriate reasoning explicitly. One of the core problems that we overcome in our formulation is the expression problem. Our concrete syntax is similar to that of Garillot and Werner  [9] , though their work does not suggest any methods for achieving semantic reasoning, which is essential to reasoning about actual terms. Delaware et al. [8]  recently proposed another solution to this problem using Church encodings.
Conclusions In this work we presented three novel techniques for building extensible reflective procedures in Coq. First, we presented a reflected representation of unification variables and existential quantifiers, which we reason about using a verified unification algorithm. Our second technique is a simple encoding of extensible syntax suitable for computational reflection, plus a formulation of constraints that allows reasoning about this representation without any runtime overhead. Our third technique is a method for building first-class, reflected hint databases that can be used by reflective procedures. These techniques form the core technical insights of MirrorShard, a reusable Coq library for reflective procedures about separation logic. The extensibility of these procedures allows them to reason about broader problems by reflectively orchestrating general and domain-specific reasoning.
Acknowledgments. The authors thank  Patrick Hulin  and  Edward Z. Yang  for their contributions to the MirrorShard implementation. We received helpful feedback on this paper from:  Andrew W. Appel ,  Jesper Bengtson ,  Josiah Dodds ,  Georges Gonthier ,  Daniel Huang ,  Andrew Johnson ,  Jacques-Henri Jourdan ,  Scott Moore ,  Greg Morrisett , and  Kenneth Roe. This work has been supported in part by a  Facebook Fellowship , an  NSF   Graduate Research Fellowship ,  NSF  grant  CCF-1253229 ,  AFRL  under agreement  FA8650-10-C-7090 , and  DARPA  under agreement number  FA8750-12-2-0293. The U. S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. The views and conclusions.
For MAPPIT, cells were stimulated with leptin (100 ng/ml) 24h after transfection. In KISS experiments that involved treatment with chemical compounds, agonists, or antagonists, these agents were added to the cells at 24h after transfection, and treatments lasted for 24h unless mentioned otherwise. Nutlin-3 was obtained from Cayman Chemical (Ann Arbor, MI), ABT-737 from Selleckchem (Houston, TX), losartan from Fluka (St. Louis, MO), somatostatin, angiotensin II, telmisartan, CYN154806, and tunicamycin from Sigma (St. Louis, MO). Luciferase data is represented as average relative light units (rlu) Ϯ standard deviation of three technical transfection replicates. In Fig. 3B , 3F, 3G, and 3H, data is normalized by dividing the luciferase rlu obtained for a bait-prey combination by those obtained for the same bait combined with the control prey (unfused gp130).
In Fig. 5C  and 5D , luciferase activity measured in cells treated with methotrexate fusion compound is normalized against that obtained in untreated cells. Curves were fit using 4-parameter nonlinear regression in GraphPad Prism. In Fig. 2B  and 2C , data for LUMIER, MAPPIT, Y2H, PCA, and wNAPPA were taken from Braun et al. (17). As in the case of the methods tested in Braun et al. , also for KISS 2 assay configurations were tested (the TYK2 domain being fused either N-or C-terminally to the bait of interest, see Fig. 2A ) and the data of both were combined. The ratios of the luciferase signal obtained for a bait-prey combination versus that obtained for the combination of the same bait with a negative control prey (unfused gp130) and versus that obtained for the combination of the same prey with a negative control bait (unfused TYK2 C-terminal fragment) were evaluated against a detection threshold.
After three washes with 1ϫ PBS, cells were permeabilized with 0. 1% Triton X-100 in 1ϫ PBS for 10 min and blocked in 1% BSA in 1ϫ PBS for another 10 min at room temperature. Samples were then incubated for 1 h at 37 °C with primary antibody. After four washes in 1ϫ PBS, cells were incubated for 1 h at room temperature with Alexa fluorochrome-conjugated secondary antibodies. The following antibodies were used: rat anti-HA, rabbit anti-gp130, goat anti-calnexin, anti-rat Alexa Fluor 488, anti-rabbit Alexa Fluor 568, and anti-goat Alexa Fluor 568. After secondary antibody incubation, cells were washed four times in 1x PBS and nuclei were stained with DAPI (2 g/ml). After a final wash step in 1xPBS, coverslips were mounted using propyl gallate. Images were acquired using a 60 ϫ 1. 35 NA objective on an Olympus IX-81 laser scanning confocal microscope and analyzed using Fluoview 1000 software.
Because the KISS readout relies on endogenous STAT3, another limitation of the assay is that it is not suitable for studying interactions involving proteins or stimuli that modulate STAT3 signaling. For instance, several baits and preys from the PRS/RRS data set produced a background reporter signal in the absence of the interaction partner, potentially obscuring a PPI-dependent KISS signal. Also, we were unsuccessful in demonstrating ligand-induced association of the beta-2 adrenergic receptor with beta 2 arrestin because ligand triggering of this receptor activates STAT3 (data not shown). Nevertheless, including the proper controls allows for easy detection of false positives that occur independent of bait-prey interaction. The importance of mapping PPIs and studying their functional modulation extends beyond fundamental biology.
Acknowledgments-We thank  Dr. R. Prywes  for sharing the BiP expression plasmid. * This work was supported by grants from the  Belgian government  (Interuniversity Attraction Poles Project  P6/36 ), the  Fund for Scientific Research -Flanders  ( FWO-V Project G. 0864. 10 ), the  GROUP-ID Multidisciplinary Research Partnership of Ghent University  and the  NIH  ( U01  Grant  HG001715 ). S. G. and I. L. are postdoctoral fellows with the Fund for Scientific Research -Flanders (FWO-V). J. T. is the recipient of an  ERC Advanced Grant  (#  340941 ).
The results were determined using a Bioplex 200 system (BioplexManager software; Biorad, Marnes-la-Coquette, France) and adjusted to 10 9 platelets. Alternatively, RANTES and sCD62P were tested via ELISA using a commercial kit (R&D Systems Europe Ltd, Lille, France) according to the manufacturer's instructions and as described previously  [2]. Duplicate ELISA data for each sample were fitted separately and then averaged to provide the final result and standard deviations. Absorbance at 450 nm was determined with an ELISA reader (Magellan software Sunrise; Tecan group Ltd. , Lyon, France). Data (expressed in pg/ml) were adjusted to 10 9 platelets.
Acknowledgments We thank  Drs. Catherine Argaud ,  Sophie Acquart ,  Francoise Boussoulade ,  Ms. Pauline Damien ,  Marie-Ange Eyraud , and  Mr. Charles-Antoine Arthaud  ( EFS Auvergne-Loire, France ) for help in obtaining and preparing the human blood cells. We also thank  Drs. Halim Benamara ,  Patrick Fabrigli ,  Helene Odent-Malaure ,  Pascale Oriol ,  Christiane Mounier ,  Denis Guyotat , and  Delphine Gorodetzki  for sharing clinical data. The authors gratefully acknowledge the invaluable help of  Ms. Sophie Ramas ,  Mr. Pierre Marcoux , and  Mr. Emeric Page  `s with the experimental procedures.
The scheme in Eq. (  3 ) is implicit with respect to the dependent variables ψ resolved on the co-located grid (dissipation/diffusion terms are treated explicitly with first-order accuracy, see  Smolarkiewicz and Margolin (1998) ). Algebraic inversion and insertion into the mass continuity Eq. (1c) leads to an elliptic boundary value problem for the pressure variable π. The complete development and details about the applied preconditioned generalised conjugate residual iterative solver can be found in  Prusa et al. (2008) ;  Smolarkiewicz and Szmelter (2011)  and  Kühnlein et al. (2012). Finally, for second-order accuracy of the MPDATA module A in Eq. (  3 ), the availability of an O(δt 2 ) estimate for the advective velocity v at the intermediate time level t n+1/2 is required, and various predictor schemes exist for that purpose  (Smolarkiewicz and Margolin, 1998).
By default, two passive tracers are simulated in each run: the first tracer is initialised by a simple Eulerian variable and is advected using Eq. (1d), while the second is represented by means of Lagrangian particles and is advected using the LCM module. The two types of tracer do not interfere. The effect of the underlying advection scheme is analysed in Sect. 3. 6. Unless noted, solely tracers with Lagrangian treatment are presented in the following sections. Since the advection algorithm in NTMIX is not positive definite (only important for the Eulerian tracer), the initial concentration discontinuity at r = 20 m is smoothed with a standard tanhprofile in radial direction (e. g. Paoli et al. , 2003). For EU-LAG, which uses the non-oscillatory MPDATA advection algorithm, and for the Lagrangian tracers, the initialisation as a step function is appropriate.
Acknowledgements. The first author is partly funded by the  DFG (German Science Foundation , contract number  UN286/1-1 ). The second author acknowledges the support of the CORAC consortium through the project " Traînées de condensation et climat  ( TC2 )". Fruitful discussions with and support by  Joris Picot  and  Takashi Misaka  are acknowledged. The in-situ measurement data was prepared and provided by  P. Jeßberger. Computational resources were made available by the  German Climate Computing Center (DKRZ)  through support from the  German Federal Ministry of Education and Research (BMBF)  and by CINES in Montpellier. This work contributes to the  DLR  projects  CATS  and WeCare. The service charges for this open access publication have been covered by a  Research Centre of the Helmholtz Association.
The Hubble Frontier Fields (HFF) program combines the capabilities of the Hubble Space Telescope (HST ) with the gravitational lensing of massive galaxy clusters to probe the distant Universe to an unprecedented depth. Here, we present the results of the first combined HST and Spitzer observations of the cluster Abell-2744. We combine the full near-infrared data with ancillary optical images to search for gravitationally lensed high-redshift (z 6) galaxies. We report the detection of 15 I 814dropout candidates at z ∼ 6 -7 and one Y 105 -dropout at z ∼ 8 in a total survey area of 1. 43 arcmin 2 in the source plane. The predictions of our lens model allow us to also identify five multiply-imaged systems lying at redshifts between z ∼ 6 and z ∼ 8. Thanks to constraints from the mass distribution in the cluster, we were able to estimate the effective survey volume corrected for completeness and magnification effects.
This was in turn used to estimate the rest-frame ultraviolet luminosity function (LF) at z ∼ 6 -8. Our LF results are generally in agreement with the most recent blank field estimates, confirming the feasibility of surveys through lensing clusters. Although based on a shallower observations than what will be achieved in the final dataset including the full ACS observations, the LF presented here goes down to M UV ∼ -18. 5, corresponding to 0. 2L ⋆ at z ∼ 7, with one identified object at M UV ∼ -15 thanks to the highly-magnified survey areas. This early study forecasts the power of using massive galaxy clusters as cosmic telescopes and its complementarity to blank fields.