dataesr/scientific-paragraphs-categorization huggingface dataset:
25 ± 0. 17) at the closure time. We next investigated whether the spreading difference between leaders and followers was conserved in matured tissues. To answer this question, we first defined a circular region of interest (ROI) of 350 µm in diameter centered with the square pattern and corresponding to a zone of low cell-ligand density (FN density from 118 ± 8 down to 32 ± 6 ng/cm 2 , Fig. 2B , in green). The rest of the pattern minus a border stripe of 10 µm to exclude border cells was used to create a second ROI, corresponding to a zone of high cell-ligand density (with FN density from 384 ± 10 ng/cm 2 down to 118 ± 8 ng/cm 2 Fig. 2B , in orange). β-Catenin-stained images of MDCK freshly closed tissues or matured tissues at 36 h after closure were acquired by epifluorescence microscopy and then segmented with EpiTools software  29  to detect cell-cell junctions  30  and quantify individual cellular areas in both ROIs.
Acknowledgements The authors gratefully acknowledge  Hélène Delobel ,  Grégoire Peyret  and  Pierre-Olivier Strale  (The  Alvéole Company ) for their technical help with the PRIMO photopatterning technique. This work was supported by the  PROSTEM  project (FEDER No. 1510614 , Wallonia  DGO6 ) and the  MAT(T) ISSE  project, which is financially supported by  Interreg V France-Wallonie-Vlaanderen  ( Fonds Européen de Développement Régional, FEDER-ERDF ). L. A. , C. B. , E. V. , D. M. and M. L. are financially supported by  FRIA (F. R. S. -FNRS ). The Mechanobiology & Soft Matter group belongs to the  French research consortium GDR 2108 AQV.
The synthetic models are designed by introducing LVA with varying percentage in velocity reductions at different depths and varying width into a modi ed velocity model (Supplementary Fig. 9 ). Rays traveling in these simulated models are computed using the same source-receiver geometry as that of the Pn picks, and the modelled travel times are inverted employing the same tomography method used for the real OBS data. The resulting 60 inverted models (Supplementary Fig. 11 ) are then compared with the tomographic velocity obtained using the real OBS dataset (see Methods; Supplementary Table  1 ). Based on these comparisons, we found that the mantle velocity within the LVA increases from 6. 89±0. 12 km/s just below the Moho to 7. 75±0. 06 km/s at 60 km depth, with the width of the LVA varying from 34.
Methods Data acquisition. The ILAB-SPARC experiment was conducted in the equatorial Atlantic Ocean on board the French R/V 'Pourquoi Pas?' in August-October 2018. The ILAB-SPARC N-S pro le was shot in a southsoutheast-north-northwest direction. Fifty four-component ocean bottom seismographs (OBSs) were deployed on the sea oor at ~14. 2 km interval. The shot line was extended by 50 km south of OBS50 and by 100 km north of OBS01, giving the N-S pro le a total length of ~850 km. The seismic source was composed of two sub-arrays with eight guns on each array, producing a total volume of 4990 cubic inches. The airgun arrays were towed at 10 m depth below the sea level and were red every 300 m. The vessel speed varied from 3. 2 to 4. 5 knots during acquisition. The maximum recording time for each shot is 130 s and the sampling rate is 4 ms.
The pressure component of the acquired seismic data is used in this study. Initial velocity model for ray-based tomography. Ray-based tomography requires an initial estimate of the velocity structure for the target region. The velocity structure of our study area is composed of four layers: water layer, sedimentary layer (where present), igneous crust and upper mantle. The thickness of the water column is obtained from the high-resolution bathymetry data acquired during the ILAB-SPARC expedition. We use a constant water velocity of 1. 5 km/s in tomography. Even though the water velocity exhibits some small horizontal and vertical variations, numerical tests demonstrate that using a constant water velocity of 1. 5 km/s has minor in uence on the modelled ray paths and travel times. The thickness of sediments is estimated using the two-way travel times (TWTTs) of the basement events, assuming the average velocity of sediment is 1.
The inserted LVAs have a constant velocity reduction of 8%. We calculate the travel times for these simulated velocity models using the same sourcereceiver con guration as that used in the tomography of the OBS data, and add some random travel time noise to mimic the picking uncertainty. Then we invert these synthetic travel time datasets using a similar 2-D tomography work ow (the same iteration process, smoothing strategy and parameters, initial model and similar nal χ 2 ) as that used in the tomography of OBS dataset. The tomographic results using the synthetic datasets are shown in Supplementary Fig. S6. Red lines in Supplementary Fig. S6  represent the base of the introduced LVAs, and any velocity reductions below the red lines are created by the downward smearing effect. Supplementary Fig.
S6  demonstrates that the amplitude of velocity reduction caused by the downward smearing effect is less than 0. 5% below 35 km depth. The downward smearing effect slightly enhances as the width of the introduced LVA increases, but cannot produce a 1% of velocity reduction at 50-60 km depths. These results demonstrate that a LVA extending to ~60 km depth at the Romanche TF is required by the OBS data, and hence real, and is not due to the vertical smearing effect of tomography. Resolution study for the width and velocity reduction of the LVA beneath the Romanche TF. Ray-based travel time tomography generally provides a smoothed version of the structure of the subsurface. In order to evaluate the resolution of the tomographic model from the OBS data, we conduct two groups of tests using synthetic seismic datasets.
LVAs with different widths and amplitudes of velocity reduction are introduced into the initial model that was used in the tomography of the OBS data, extending from the Moho down to the base of the model. The width of the inserted LVA is constant in depth in each test. Similar to the smearing tests, synthetic travel time datasets are generated using these designed models, and are inverted using a 2-D tomography work ow. In the rst group of tests, we x the amplitude of velocity reduction within the introduced LVA to 8% and vary the width of the LVA from 25 km to 60 km (Supplementary Fig. 7 ). We take 8% of velocity reduction for the inserted LVAs because the maximum velocity reduction within the LVA obtained using the OBS data is ~8% (Fig. 3a ). When the width of the introduced LVA is 25 km, the recovered velocity anomaly at the Moho is ~5%, with no recovery at 60 km depth (Supplementary Fig.
8 ). For an introduced LVA with less than 7% velocity anomaly, <1% of velocity anomaly is recovered at 60 km depth (Supplementary Fig. 8a-e ). When the amplitude of velocity reduction of the inserted LVA is 8%, ~8% velocity anomaly is recovered at the Moho, with ~1% recovered velocity anomaly at 60 km depth (Supplementary Fig. 8f ). Further increasing the amplitude of the velocity reduction to 9%, the introduced LVA can be better recovered (Supplementary Fig. 8g ). These tests suggest that the recovered 8% velocity anomaly just below the Moho at the Romanche TF using the OBS dataset requires a 50 km wide LVA with at least 8% velocity decrease at this depth. A larger velocity reduction is required if the width of the LVA is narrower than 50 km, due to the existence of strong tradeoff between the width and the amplitude of velocity reduction in tomography.
In all the tests, the majority of the LVAs is not completely recovered, suggesting that the tomography method underestimates the amplitude of the velocity anomaly signi cantly. The failure of constructing the sharp boundaries of the LVA using OBS data can possibly be attributed to the horizontal smoothing effect of tomographic inversion, which is clearly observed in all the tomographic results from the synthetic datasets (Supplementary Figs. 7, 8 ). From these tests, we are able to get some constraints on the possible width and amplitude of velocity reduction of the real LVA beneath the Romanche TF. Since the amplitude of the introduced velocity anomaly is kept constant for the whole column in each test, the recovered vertical mantle velocity gradient beneath the Romanche TF decreases smoothly with depth (Supplementary Figs.
3b ). The width of the LVAs used in tests is constant in depth, so varies between 30 km to 50 km. Based on the above analysis, we create a suite of models (Synthetic models in Supplementary Fig. 11 ) by inserting LVAs with different widths and changing velocity reductions in depth (Supplementary Table  1 ) into model A (Supplementary Fig 9). We calculate travel times through these synthetic models using the same source-receiver con guration as that used in the tomography of the OBS data. The picking uncertainties of the OBS data are assigned to these modelled travel time datasets, in order to eliminate the in uence of picking errors on the estimated width and velocity of the LVA. These synthetic travel time datasets are inverted starting from the same initial model as that used in the tomography of the OBS dataset.
After tomography, all these synthetic travel time datasets produce velocity models (Inverted results in Supplementary Fig. 11 ) showing similar mantle velocity structure to the tomographic result using the OBS data (Fig. 3a ) with a LVA in the mantle beneath the Romanche TF. The difference between the LVA obtained using the OBS dataset (Fig. 3a ) and those from the synthetic datasets (Inverted results in Supplementary Fig. Supplementary Table  1  shows the velocity mis ts measured within different windows. We set a mis t threshold to select the synthetic models whose tomographic results have a good t to the OBS data inverted result. By taking the average of the width and velocity of the introduced LVA in the selected models, we estimate the width and amplitude of velocity reduction of the real LVA below the Romanche TF (Supplementary Table  2 ).
46. We assume the anisotropy of the melt-impregnated peridotite is 4%, as a stronger mantle anisotropy is expected within TFs as compared to the average anisotropy (3. 4±0. 3%) of the normal oceanic lithosphere in the Atlantic Ocean  47. Assuming that the olivine-toserpentine alteration is the dominant reaction in serpentinization, the velocities in ridge-parallel direction of 0% and 100% serpentinized melt-impregnated peridotite at the reference temperature (100 o C) and pressure (0. 01 GPa) condition are 7. 88 km/s and 6. 13 km/s, respectively, estimated using the Matlab toolbox from Abers et al. 23. The variations of temperature and pressure with depth relative to the reference temperature and pressure cause changes of -0. 04 km/s and -0. 12 km/s in P-wave velocity at the Moho and at 16 km depth  23  , respectively.
Data availability. The high-resolution bathymetry data collected during the ILAB-SPARC expedition and presented in this paper is available online (https://doi. pangaea. de/10. 1594/PANGAEA. 922331) under the condition of acknowledging Marjanović et al. , 2020. The travel time picks will be available along with publication of the paper and the raw OBS seismic data used in this study on request from the authors.
5 mW. The scattered light was analyzed using a 600 lines/mm grating and collected by a Si-based CCD (charge-coupled device) detector of 1024 × 256 pixels cooled with liquid nitrogen. A composite spectrum covering the spectral range between 150 and 4000 cm -1 was obtained by using the LabSpec (version 5) package that merges several partial spectra with different wavenumber ranges. Before the measurements, the spectrometer was calibrated using the 520. 4 cm -1 peak of crystal Si. XRD measurements were acquired with a Thermo ARL X'TRA powder diffractometer, operating in the Bragg-Brentano geometry and equipped with a Cu-anode X-ray source (K α , λ = 1. 5405 Å), using a Peltier Si(Li) cooled solid-state detector. The patterns were collected with a scan step of 0. 03 • in the 10-70 2θ range. The diffractometer was calibrated with a reference silicon powder (d 111 = 3.
2 • for the untreated mixed serpentines (i. e. , 2. 45 Å for chrysotile-2M, 2. 51 Å for lizardite-1T, and 2. 55 Å for antigorite) tend to wane and be replaced by a broad two-dimensional diffraction band of olivine (forsterite) and enstatite (see Figure  4 ), indicating a high degree of stacking disorder in silicate layers  [28, 30, 32, 33]. These results indicate that the phase transformation of the garnierite to the olivine (forsterite) and enstatite has occurred and they are in good agreement with the previously reported literature  [9, 30]. The phase transformation from garnierite to olivine (forsterite) and enstatite is also evidenced by micro Raman spectroscopy; see Figure  5. In order to identify the mineral phases, the recorded Raman spectra were compared to reference spectra from both the RRUFF database  [31, 36, 37]  and the Raman Open Database  [38] [39] [40] [41].
• , 26. 55 • , 36. 47 • , 39. 37 • , 42. 37 • , 50. 04 • , and 59. 84 • (degrees) having d-spacing of 4. 27, 3. 35, 2. 46, 2. 28, 2. 13, 1. 82, and 1. 54 Å respectively, which are in good agreement with the RRUFF database [31]. The diffraction peak at 2θ = 12. 01 • shows that the main Ni-bearing mineral phase is serpentine [(Mg, Fe, Ni) 6 Si 4 O 12 (OH) 6 ] having d 101 = 7. 36 Å [7,32,33]. Other broad peaks at about 19. 55 • , 24. 44 • , 34. 43 • , and 35. 57 • having d-spacing 4. 53, 3. 63, 2. 60,.
• The proof technique of semantic type soundness, together with advances in separation logic and machine-checked proof, has enabled us to begin building rigorous formal foundations for Rust as part of the RustBelt project. There is a longstanding tension in programming language design between two seemingly irreconcilable desiderata. • Safety. We want strong type systems that rule out large classes of bugs statically. We want automatic memory management. We want data encapsulation, so that we can enforce invariants on the private representations of objects and be sure that they will not be broken by untrusted code. • Control. At least for "systems programming" applications like web browsers, operating systems, or game engines, where performance or resource constraints are a primary concern, we want to determine the byte-level representation of data.
We want to optimize the time and space usage of our programs using low-level programming techniques. We want access to the "bare metal" when we need it. Sadly, the conventional wisdom goes, we can't have everything we want. Languages like Java give us strong safety, but it comes at the expense of control. As a result, for many systems programming applications, the only realistic option is to use a language like C or C++ that provides fine-grained control over resource management. However, this control comes at a steep cost. For example, Microsoft recently reported that 70% of the security vulnerabilities they fix are due to memory safety violations  [33] , precisely the type of bugs that strong type systems were designed to rule out. Likewise, Mozilla reports that the vast majority of critical bugs they find in Firefox are memory-related  [16].
2. Rust also provides a rich set of APIs-e. g. , for concurrency abstractions, efficient data structures, and memory management-which fundamentally extend the power of the language by supporting more flexible combinations of aliasing and mutation than Rust's core type system allows. Correspondingly, these APIs cannot be implemented within the safe fragment of Rust: rather, they internally make use of potentially unsafe C-style features of the language, but in a safely encapsulated way that is claimed not to disturb Rust's language-level safety guarantees. These aspects of Rust's design are not only essential to its success-they also pose fundamental research questions about its semantics and safety guarantees that the programming languages community is just beginning to explore. In this article, we begin by giving the reader a bird's-eye view of the Rust programming language, with an emphasis on some of the essential features of Rust that set it apart from its contemporaries.
This is important: if we take our previous Arc example, and replace all the Arc by Rc, the program has a data race and might deallocate the memory too early or not at all. However, quite remarkably, the Rust compiler is able to catch this mistake. The way this works is that Rust employs something called the Send trait: a property of types which is only enjoyed by a type T if elements of type T can be safely sent to another thread. The type Arc<T> is Send, but Rc<T> is not. Both join and spawn require everything captured by the closure(s) they run to be Send, so if we capture a value of the non-Send type Rc<T> in a closure, compilation will fail. Rust's use of the Send trait demonstrates how sometimes the restrictions imposed by strong static typing can lead to greater expressive power, not less.
In particular, C++'s smart reference-counted pointer, std::shared_ptr, always uses atomic instructions 2  , because having a more efficient nonthread-safe variant like Rc is considered too risky. In contrast, Rust's Send trait allows one to "hack without fear"  [26] : it provides a way to have both thread-safe data structures (such as Arc) and non-thread-safe data structures (such as Rc) in the same language, while ensuring modularly that the two do not get used in incorrect ways.
To solve this problem, Rust has an "escape hatch": Rust consists not only of the safe language we discussed so far-it also provides some unsafe features such as C-style unrestricted pointers. The safety (memory safety and/or thread safety) of these features cannot be guaranteed by the compiler, so they are only available inside syntactic blocks that are marked with the unsafe keyword. This way, one can be sure to not accidentally leave the realm of safe Rust. For example, the implementation of Arc uses unsafe code to implement a pattern that would not be expressible in safe Rust: sharing without a clear owner, managed by thread-safe reference counting. This is further complicated by support for "weak references": references that do not keep the referent alive, but can be atomically checked for liveness and upgraded to a full Arc.
The correctness of Arc relies on rather subtle concurrent reasoning, and the Rust compiler simply has no way to verify statically that deallocating the memory when the reference count reaches zero is in fact safe. Alternatives to unsafe blocks. One could turn things like Arc or Vec into language primitives. For example, Python and Swift have built-in reference counting, and Python has list as a built-in equivalent to Vec. However, these language features are implemented in C or C++, so they are not actually any safer than the unsafe Rust implementation. Beyond that, restricting unsafe operations to implementations of language primitives also severely restricts flexibility. For example, Firefox uses a Rust library implementing a variant of Arc without support for weak references, which improves space usage and performance for code that does not need them.
Should the language provide primitives for every conceivable spot in the design space of any built-in type? Another option to avoid unsafe code is to make the type system expressive enough to actually be able to verify safety of types like Arc. However, due to how subtle correctness of such data structures can be (and indeed Arc and simplified variants of it have been used as a major case-study in several recent formal verification papers  [12, 18, 9] ), this basically requires a form of general-purpose theorem prover-and a researcher with enough background to use it. The theorem proving community is quite far away from enabling developers to carry out such proofs themselves. Safe abstractions. Rust has instead opted to allow programmers the flexibility of writing unsafe code when necessary, albeit with the expectation that it should be encapsulated by safe APIs.
Safe encapsulation means that, regardless of the fact that Rust APIs like Arc or Vec are implemented with unsafe code, users of those APIs should not be affected: so long as users write well-typed code in the safe fragment of Rust, they should never be able to observe anomalous behaviors due to the use of unsafe code in the APIs' implementation. This is in marked contrast to C++, whose weak type system lacks the ability to even enforce that APIs are used safely. As a result, C++ APIs like shared_ptr or vector are prone to misuse, leading to reference-counting bugs and iterator invalidation, which do not arise in Rust. The ability to write unsafe code is like a lever that Rust programmers use to make the type system more useful without turning it into a theorem prover, and indeed we believe this to be a key ingredient to Rust's success.
Formal verification Semantic type soundness is ideal for reasoning about programs that use a combination of safe and unsafe code. For any library that uses unsafe code (such as Arc, Mutex, Rc, and Vec) one has to prove by hand that the implementation satisfies the safety contract. For example: Theorem 2. Arc satisfies its safety contract. For safe pieces of a program, the verification is automatic. This is expressed by the following theorem, which says that if a component is written in the safe fragment of Rust, it satisfies its safety contract by construction. Theorem 3 (Fundamental theorem). If a component e is syntactically well-typed, then e satisfies its safety contract. Together, these imply that a Rust program is safe if the only appearances of unsafe blocks are within libraries that have been manually verified to satisfy their safety contracts.
Iris's user-defined ghost state has enabled us to verify the soundness of libraries like Arc, for which ownership does not correspond to physical ownership (e. g. , two separately-owned Arc<T>'s may be backed by the same underlying memory)-a phenomenon known as "fictional separation"  [11, 10]. It has also enabled us to reason about Rust's borrowing and lifetimes at a much higher level of abstraction, by deriving (within Iris) a new, domain-specific "lifetime logic". • Iris supports impredicative invariants: invariants on the program state that may refer cyclically to the existence of other invariants  [32]. Impredicative invariants play an essential role in modeling central type system features such as recursive types and closures. The complexity of Rust demands that our semantic soundness proofs be machine-checked, as it would be too tedious and error-prone to do proofs by hand.
Numerical Experiments We implemented the modification of Algorithm 1 presented in Remark 3. 6 in matlab 2019b-Win64 on a Lenovo Yoga 260 Laptop with Windows 10 and an Intel Core i7 6500U CPU with 2. 59 GHz and 16GB RAM. As stopping criterion of the algorithm we considered the situation when the absolute values of both the differences between x k+1 and x k , and x k+1 and z k are not larger than the considered error ε > 0. First we considered a toy example, where one can already note the "conflict" between the properties of the involved operator and function, then an application in oligopolistic markets.
The proximity operator of (the separable function) h has as components the ones of the involved functions, which are known (cf. [6, 13, 29] ). For instance, the proximity operator of parameter γ > 0 of ϕ 1 over [0, 2] at z ∈ [0, 2], is, when γ < 1/2, equal to (z + γ )/(1 -2γ ) when this lies in [0, 2], otherwise being 0 when z < -γ and 2 otherwise, while in case γ ≥ 1/2 the analysis can be done in a similar manner. In the following numerical implementations we apply these formulae for γ = αλ < 1/2. In Tables  3  and 4  we present the computational results obtained by implementing the mentioned algorithm in matlab for various choices of the involved parameters and of the allowed error ε > 0. In all the situations presented below we give the number of iterations and the CPU time needed by the program to reach a suitable approximation of the solution of the corresponding oligopolistic equilibrium problem.