dataesr/scientific-paragraphs-categorization huggingface dataset:
Primary production and euphotic depth are derived from satellite ocean colour data following  Behrenfeld and Falkowski (1997). Temperature and currents are calculated by the global eddy-resolving ocean circulation model PSY4v4 of Mercator-Ocean (<www. mercator-ocean. fr/eng>). This model assimilates both satellite (sea surface temperature and height) and in situ data (< http://marine. copernicus. eu/ >). The approach is particularly useful for understanding generalist marine predators, as the functional groups are representative of key prey taxa (mid-water fishes and squids;  Bailleul et al. 2010a , Goetsch et al. 2018 ). An example of daily output can be seen in Fig. 2a , while the model is described in more detail in Supplementary material Appendix 1 S1 and in full by  Lehodey (2004)  and  Lehodey et al.
Metrics of predator distribution and foraging effort We gridded (1° × 1° spatial resolution) seal location and dive data into metrics of distribution (seal density) and foraging effort. A satellite relayed data loggers (SRDL) transmits highly summarised dive information, reducing each dive profile to five segments delineated by the six main inflection points of the full profile  (Heerah et al. 2015). For each dive, maximum dive depth (m), hunting time (s) and a dive residual (as defined below) were calculated. Hunting time, the duration of time spent in active prey search, was calculated following  (Heerah et al. 2015). Hunting time is an index of vertical sinuosity within a dive to determine the duration spent in active foraging, indicated by those segments with a rate of change less than 0.
4 m s -1. This method has been validated against accelerometer-inferred prey capture data, where segments classified as active hunting were associated with 68% of prey capture attempts, and outperformed similar metrics for inferring hunting behaviour  (Heerah et al. 2015). As dive depth increases, so too must the duration of descent and ascent. The dive residual -the residual of the dive depth versus dive duration regression  (Bestley et al. 2015)  -is a practical means of determining whether a dive is relatively long or short for a given depth (although see also  Jouma'a et al. 2016). Comparisons between seal metrics and the modelled prey field were performed over the months April-August. Using our filtered dataset, we calculated a metric of seal distribution, defined as the number of seals visiting each grid cell over the 13 years of available data; and three metrics of foraging effort, defined as the mean maximum depth, hunting time and dive residual per individual per grid cell.
Modelling predator responses to prey Prior to fitting statistical models, we assessed the data for the presence of outliers in the simulated prey information, removing values beyond the 1-99% quantile range. This removed a small number of observations from our seal distribution (50; final n = 1171) and effort (95; final n = 2473) datasets. We anticipated a non-linear relationship between seal and prey covariates, so adopted a generalised additive model (GAM) framework (package mgcv; Wood 2011). Seal distribution was modelled against mean prey biomass and prey biomass variability using a simple fixed-effects model (GAM) assuming a negative-binomial error structure and logarithmic link function. The hunting time, dive residual and mean maximum depth models were fitted using the same fixed effects, but with the addition of a random effect for individual seals using a generalised additive mixed model (GAMM), with a gaussian error and identity link function.
Shallow dive depths along with short hunting times were also predicted over the southern Kerguelen plateau. Our prediction maps generally conformed well to the observational dataset. On average, predicted values differed from observations by 1 ± 0. 8, 74 ± 67 m and 4 ± 2. 9 min for seal density, maximum dive depth and hunting time respectively. Differences between predicted and observed seal density and behaviour are displayed along the right-hand column of Fig. 5 , while standard errors around these spatial predictions are displayed in Supplementary material Appendix 1 S3.
It is relevant to note that the seal dataset used in this study is spatially limited to match the available prey fields. Southern elephant seals do disperse well beyond these bounds (0-140°E, 40-70°S) and show individual specialisation for different regional environments  (Bailleul et al. 2010a , Hindell et al. 2017) , although not necessarily for three-dimensional habitats  (McIntyre et al. 2017). High observed seal density within this area likely represents a northern 'edge' of those seals adopting a MIZ foraging strategy farther south  (Labrousse et al. 2015). Therefore, the predator-prey interactions here are likely not shaped by mesoscale eddies, but rather by sea-ice dynamics. Finally, our GA(M)Ms also predicted few seals foraging over the southern Kerguelen plateau, where dives were shallow but comparatively short (i.
Acknowledgements -The Kerguelen Islands ARGOS seal tracking and dive data were collected as part of a collaboration between IMOS and SNO-MEMO (PI C. GUINET). Data were sourced from the  Integrated Marine Observing System (IMOS). IMOS is a national collaborative research infrastructure, supported by the  Australian Government. It is operated by a consortium of institutions as an unincorporated joint venture, with the  Univ. of Tasmania as lead agent. We are grateful to  Olivier Titaud  for technical support with SEAPODYM. This work was strengthened by thoughtful feedback from three anonymous reviewers.
Funding -Field work at Kerguelen was conducted as part of the IPEV programs no. 109  (PI H. WEIMERSKIRCH) and no. 1201  ( PI C. GILBERT ) in collaboration with IMOS. This study received support from the  European H2020   International Cooperation  project  MESOPP (Mesopelagic Southern Ocean Prey  and Predators, < www. mesopp. eu/>). DBG was funded through a  Tasmania Graduate Research Scholarship. SB is supported by the  Australian Research Council  under  DECRA award   DE180100828. Additional funding support was received through  Institut Polaire Paul Emile Victor. Grant Number:  1201.
In this paper, we develop a new framework called SteelCore that aims to provide the benefits of Nanevski et al. 's shallow embeddings, while also supporting dynamically allocated invariants and locks in the flavor of Iris. Specifically, we develop SteelCore in the effectful type theory provided by the F ★ proof assistant  (Swamy et al. 2016). One of our main insights is that an effectful type theory is not only useful for programming; it can also be leveraged to build new program logics for effectful program features like concurrency. Building on prior work  (Ahman et al. 2018 ) that models the effect of monotonic state in F ★ , we develop a semantics for concurrent F ★ programs while simultaneously deriving a CSL to reason about F ★ programs using the effect of concurrency. The use of monotonic state enables us to account for invariants and atomic actions entirely within SteelCore.
The net result is that we can program higher order, dependently typed, generally recursive, shared-memory and message-passing concurrent F ★ programs and prove their partial correctness using SteelCore. 1. 1 SteelCore: A Concurrent Separation Logic Embedded in F ★ SteelCore is the core semantics of Steel, a DSL under development in F ★ for programming and proving concurrent programs. In this paper, we focus primarily on the semantics, leaving a detailed treatment of other aspects of the Steel framework to a separate paper. The structure of SteelCore is shown in Figure  1. Building on the monotonic state effect, we prove sound a generic program logic for concurrency, parametric in a memory model and a separation logic (ğ3). We instantiate this semantics with a separation logic based on partial commutative monoids, stored invariants, and state machines (ğ4).
PCMs in SteelCore are orthogonal from ghost state: they can be used both to separate and manage access permissions to both concrete and ghost stateÐin practice, we use fractional permissions to control read and write access to references. Further, SteelCore includes a notion of monotonic references, which when coupled with F ★ 's existing support for ghost values and invariants, allow programmers to code up various forms of state machines to control the use and evolution of shared resources. Demonstrating the flexibility of our semantics, we extend it to allow augmenting CSL assertions with frameable heap predicates, a style that combines CSL with implicit dynamic frames  (Smans et al. 2012 ) within the same mechanized framework. Putting it to work. We present several examples showing SteelCore at work, aiming to illustrate the flexibility and extensibility of the logic and its smooth interaction with dependently typed programming in F ★.
Starting with an atomic compare-and-set (CAS) instruction, we program verified libraries for spin-locks, for fork/join parallelism, and finally for protocol-indexed channel types. Our channel-types library showcases dependent types at work with SteelCore: its core construct is a type of channels, chan p, where p is itself a free-monad-like computation structure "one-level upž describing an infinite state machine on types. We prove, once and for all, that programs using a c:chan p exchange a trace of messages on c accepted by the state machine p. Mechanization. SteelCore is a fully mechanized CSL embedded in F ★ , and applicable to F ★ itself. The code and proofs are available from https://fstar-lang. org/papers/steelcore. Summary of contributions. In summary, the main contributions of our work include the following: • A new construction of indexed, effectful action trees, mixing data and effectful computations to represent concurrent, stateful and potentially divergent computations, with an indexing structure capturing the proof rules of a generic CSL.
This makes ctree_total more similar to  Piróg et al. 's (2018)  scoped operations, with f being in the "scopež of Bind. The nat index counts the number of Act, Par and Bind nodes. We also define an abbreviation nctree_total a to package a tree with its index as a dependent pair. A definitional interpreter for ctree_total. To give a semantics to ctree_total, we interpret its action trees in an interleaving semantics for state-passing computations, relying on a boolean tape to resolve the nondeterminism inherent in the Par nodes. To that end, we define a state and nondeterminism monad, with sample, get, and put actions: We can now interpret ctree_total trees as nst computations. It should be possible to define such an interpreter in many type theories, in a variety of styles. Here, we show one way to program it in F ★ , making use of its effect system to package the nst monad as a user-defined effect.
INDEXED ACTION TREES AND A PARTIAL CORRECTNESS SEPARATION LOGIC Recall from ğ1 that our goal is to define the indexed action trees with the following type: type ctree (st:state) (a:Type) (pre:st. slprop) (post:a → st. slprop) : Type The type is indexed by st:state, a typeclass encapsulating (at least) the type of the memory st. mem and the type of separation logic assertions on the memory st. slprop. Intuitively, a ctree st a fp0 fp1 is the type of a potentially divergent, concurrent program manipulating shared state of type st. mem. The program expects the fp0 footprint of some initial memory m0:st. mem. When run in m0, it may diverge or produce a result:a and m1:st. mem, providing the (fp1 result) fragment of m1 to the context. The state typeclass for the semantics is shown below. First, we define a pre_state containing all the operations we need.
CSL-Indexed Action Trees with Monotonic State Figure  2  shows the way we represent computation trees in SteelCoreÐextending the ctree type from the introduction. To reduce clutter, we omit binders for implicit argumentsÐin the type of each constructor of the inductive ctree, we only bind names that do not appear free in other arguments of the constructor. These trees differ from the simple action trees we used in ğ2. 1. The additional indexing structure in each case of ctree posits the proof rules of a program logic for reasoning about ctree computations. In ğ3. 3, we show that this logic is sound by denoting ctree st a fp0 fp1 trees via an interleaving, definitional interpreter into NMST computations. As NMST computations are potentially divergent, we do not need to prove termination of the definitional interpreter.
The computation type of g has the Dv effect, indicating a potentially divergent continuation. Parallel composition. Par cL cR composes computations in parallel. The indexing structure yields the classic CSL rule for parallel composition of computations with disjoint footprints. Structural rules: Framing and Subsumption. The Frame c f node preserves the frame f across the computation c. The Sub c node allows strengthening the initial footprint and weakening the final footprint of c. These nodes directly correspond to the canonical CSL frame and consequence rules. These structural rules are essential elements of our representation. The indexing structure of ctree defines a program logic and the structural rules are manifested as a kind of re-indexing, which must be made explicit in the inductive type as additional constructors.
Atomic actions. An Act e node is reduced by applying it, and returning its result in a Ret node. | Act #fp1 e → let x = e () in Reduct (fp1 x) fp1 (Ret fp1 x) Multi-step interpreter. Implementing a general recursive, multi-step interpreter is straightforward: we recursively evaluate single steps until we reach a Ret node. The type of the interpreter, shown below, is the main statement of partial correctness for our program logic. let rec run #st #a #fp0 #fp1 (f:ctree st a fp0 fp1) : NMST a st. mem st. evolves (requires 𝜆m0 → st. interp (st. inv m0 * fp0) m0) (ensures 𝜆m0 x m1 → st. interp (st. inv m1 * fp1 x) m1) = match f with | Ret _ x → x | _ → let Reduct _ _ f' = step f in run f' The type states that when run in an initial state m0 satisfying the memory invariant st. inv m0 and separately the footprint assertion fp0, the code either diverges or returns x:a in a final state m1 with the invariant st.
STEELCORE AT WORK: LOCKS, FORK/JOIN, CHANNELS, TRACES In this section, we make use of the SteelCore program logic to build a few libraries of verified synchronization primitives. We start with a spin lock, built using invariants accessed by an atomic CAS instruction. Using a spin lock, we build a library for fork/join concurrency on top of structural parallelism (par) and general recursion. Finally, we present a library of synchronous, simplex channels whose use is controlled by a specification-level state machine. All of our examples are programmed directly within F ★ , making use of all its abstraction and specification features, including mixing dependently typed specifications and effects with SteelCore's CSL. That said, while our proofs already rely on both SMT solving and dependent typechecking, they are still quite manual.
For convenience, similarly to the NST effect in ğ2. 1, we package the ctree trees into a Steel effect having the form Steel a fp0 fp1. Using this Steel effect, allocating a lock is straightforward: let new_lock p : Steel (lock p) p (𝜆 _ → emp) = let r = alloc available in let i = new_invariant (lockinv r p) in (| r, i |) Releasing a lock requires opening the invariant to gain permission to the referenceÐwe add comments to the code to show the relevant Hoare triples in the term using the notation {p} e {q}. Within the invariant, we use a ghost read to fetch the current value of the reference, then do a cas and can prove that it sets the reference to available. In the case where the reference was already set to available, we use the affinity of our separation logic to forget the assertion (b=false wand p) before closing the invariant.
We could also return the resulting boolean to avoid losing information. Acquiring a lock is similar to releasing it: We try to set the lock reference to locked within the invariant using an atomic cas. If cas fails, we "spin" by repeatedly calling acquire until the lock becomes available. The function terminates once the reference has been set to locked and we successfully acquired the corresponding slprop. Although SteelCore's logic is predicative, since the host language supports abstraction in arbitrary universes, we can build libraries whose specifications are generic in separation logic assertionsÐthis allows us to use our spin lock library to protect any slprop.
Fork/Join SteelCore's only concurrency primitive is the Par combinator for structured parallelism shown in Figure  2 , that we expose as a stateful par in the Steel effect. However, having just built a library for locks, we can code up a library for fork/join concurrency without too much trouble. As with locks, since the host language is higher order, we can easily abstract over computations and their specifications, although Hoare triples are not part of SteelCore's logic itself. The interface we provide for forking and joining threads is shown below. The type thread p represents a handle to a thread which guarantees p upon termination. The combinator fork f g runs the thread f and continues with g in parallel, passing to g a handle to the thread running f. The join t combinator waits until the thread t completes and guarantees its postcondition.
We leave both of these extensions to future work. Discussion. In a sense, we've come full circle: we started in ğ3 by representing infinite concurrent computations as indexed effectful action trees. Now, we specify concurrent programs using indexed types, where the indexes themselves are action trees with infinite traces, with a proof within SteelCore that the message traces are partial traces of the index state machines. To prove safety properties of concurrent, channel-using programs, one can reason by induction on the partial traces. Alternatively, rather than reason directly on traces, one might even replay the methodology of this paper "one level upž and derive a program logic to reason about action tree indexes.
RELATED WORK Throughout the paper, we have discussed connections to many strands of related work on CSL. In particular, we have drawn inspiration from, and contrasted our work with, Iris  (Jung et al. 2018). The most significant point of contrast with Iris, perhaps, is our differing goals. Iris is a powerful impredicative logical framework into which other logics and programming languages can be embedded and studied. This has allowed researchers to use Iris as a foundation on which to investigate languages and language features as different as unsafe blocks in Rust  (Jung et al. 2017 ) and state-hiding via rank-2 polymorphism in Haskell  (Timany et al. 2018). In contrast, with SteelCore, we aim not to provide a general logical framework but instead to extend a proof assistant's programming language with an effect for concurrency and to reason about effectful, dependently typed concurrent programs in a CSL.
ACKNOWLEDGMENTS  Aymeric Fromherz 's and  Denis Merigoux 's work was supported in part by internships at  Microsoft Research. Aymeric Fromherz  was also funded by the  Department of the Navy, Office of Naval Research  under Grant no. N00014-18-1-2892. Denis Merigoux  was also funded by  ERC  Consolidator Grant CIRCUS no. 683032. Danel Ahman 's work was supported in part by the  Microsoft Research Visiting Researcher program. He has also received funding from the  European Union 's  Horizon 2020 research and innovation programme  under the  Marie Skłodowska-Curie  grant agreement no. 834146. We thank  Robbert Krebbers , the shepherd of this paper; the anonymous reviewers;  Matt Parkinson ,  Derek Dreyer ,  Ralf Jung ,  Aleks Nanevksi  and all the members of Project Everest for their feedback, answering questions and many useful discussions.
As a baseline comparison, we first estimated timedependent variations of speciation (estimated with phylogeny) or origination (estimates with fossils) rates and extinction rates with time-continuous birth-death models (65) (SI Appendix, Table  S2 ). We then assessed the effect of global climate changes on the diversification of conifers, approximated with global variations of atmospheric carbon data  (68)  and on global oxygen isotopic data (69, 72) (Fig. 3A ), hereafter denoted as the PDDM-climate model. We find evidence that global variations of past climates correlate significantly with changes in diversification rates (SI Appendix, Fig. S5  and Tables  S3  and S4 ). Specifically, both fossil and phylogenetic datasets support a scenario where extinction rates correlate negatively with temperature (Fig.
Materials and Methods Time-Calibrated Phylogeny and Fossil Occurrences. We used two timecalibrated conifer phylogenies including 1) 489 of 615 species (∼80% of the living species diversity) (33) and 2) 578 of 615 species (∼94% of the living species diversity)  (34). We studied the fossil record of conifers using a subset of the plant dataset compiled by Silvestro et al. (27)  and updated with new occurrences available in the Paleobiology Database via FossilWorks. We checked for fossil occurrences using the name "Pinophyta," and we specified the taxonomic criteria to look for family and genus names. We did not conduct analyses at the species level because this would greatly reduce the number of reliably identified taxa and the power of the analyses. We generated the conifer fossil dataset including the sister extinct lineages Cordaitales comprising 7,927 fossil occurrences representing 100 genera (31 extant and 69 extinct).
For comparison, the conifer dataset of Silvestro et al. (27)  contained 6,470 occurrences representing 55 genera  (12 extant and 43 extinct). We also analyzed a dataset excluding Cordaitales, which resulted in 6,764 occurrences for 94 genera (31 extant and 63 extinct). Estimation of Origination/Speciation and Extinction Rates. We performed diversification analyses on the conifer time tree using TreePar  (66) , which was used to infer speciation and extinction rates through time. This method relaxes the assumption of constant diversification rates by allowing rates to change at specific points in time. Such a model is therefore suited for the detection of rapid changes in speciation and extinction rates, which may be expected in response to abiotic events such as the K/Pg mass extinction event or biotic factors such as floristic turnovers.
Origination and extinction rates are measured as the expected number of origination and extinction events per lineage per million years. One potential problem in fixing a priori the number of rate shifts is overparameterization. We overcame this issue by assuming that the rates of origination and extinction are part of two families of parameters following a common prior distribution, with parameters estimated from the data using hyperpriors  (27, 80). We ran PyRate for 10 million MCMC generations on each of the 10 randomly replicated datasets. We monitored chain mixing and effective sample sizes by examining the log files. After excluding the first 20% of the samples as burn-in period, we combined the posterior estimates of the origination and extinction rates across all replicates to generate rates-throughtime plots.