bluuebunny/crossref_metadata_2025_split huggingface dataset:
Clinical manifestations and treatment of oral and maxillofacial space infections with a third molar origin
Authors: Ge Shengyou , Yang Xiaochen , Yang Song , Li Hengyong , Zhou Kai , Song Kai , Shang Wei , Feng Yuanyong 
Published: October 2021

AbstractObjectiveThis study aimed at evaluating the clinical manifestations and therapeutic options for oral and maxillofacial space infections originating from the third molar.MethodsClinical data for 60 patients with oral and maxillofacial space infections with a third molar origin who were treated between June 2016 and December 2020 in the Department of Oral and Maxillofacial Surgery of the Affiliated Hospital of Qingdao University were collected. Based on whether they were diabetic or not, patients were assigned into two groups: the diabetes mellitus (DM) group and the non‐DM group. The collected basic information included gender, age, systemic diseases, etiology and infected areas, whereas treatment information included antibiotic administration, length of hospitalisation, costs, bacteria and sensitivity tests as well as associated complications.ResultsOf the 60 patients, 36 were males while 24 were females with an age range of 21–51 years. A total of 32 patients exhibited third molar pericoronitis, whereas 26 patients had deep neck space or chest cavity infections. Compared to the non‐DM group, the length of hospital stay was relatively longer while antibiotic administration was higher in the DM group. The conformance rate of empirical antibiotic use and drug sensitivity tests was 64.9% (37/57).ConclusionDM is a risk factor for oral and maxillofacial space infections. Space infections with third molar origins are associated with serious complications. Based on patient's conditions, treatment plans should be comprehensively evaluated and personalised treatment plans formulated. Antibiotic administration by clinicians is not standardised; therefore, it is important to make adjustments depending on subsequent bacterial culture results.
Factors influencing the quality of life in patients with severe dementia
Authors: Nagata Yuma , Nishikawa Takashi , Tanaka Hiroyuki , Ishimaru Daiki , Ogawa Yasuhiro , Fukuhara Keita , Shigenobu Kazue , Ikeda Manabu 
Published: October 2021

AbstractBackgroundA comprehensive understanding of the relevant factors involved in improving quality of life (QoL) is essential in patients with severe dementia; however, rating scales used in previous studies may not adequately reflect the factors that affect these patients. The purpose of this study was to identify factors that contribute to QoL using an evaluation scale suitable for patients with severe dementia.MethodsThe current cross‐sectional study was conducted at a hospital for recuperation in Hyogo prefecture in Japan. The measurement scales included the QoL in Late‐Stage Dementia Japanese version (QUALID‐J), Cognitive Test for Severe Dementia, Neuropsychiatric Inventory‐Nursing Home (NPI‐NH), Physical Self‐Maintenance Scale (PSMS), Pain Assessment in Advanced Dementia (PAINAD), and Special Care Unit Environment Quality Scale (SCUEQS). Multiple regression analyses were performed.ResultsWe assessed a total of 105 patients with severe dementia (80 women; aged 87.3 ± 6.3 years). Multiple regression demonstrated that the QUALID‐J total score was significantly affected by the NPI‐NH and PAINAD scores. Factors 1 (expression of comfort) and 2 (expression of discomfort) of the QUALID‐J were significantly affected by the PSMS and PAINAD, and the NPI‐NH and PAINAD scores, respectively.ConclusionOur results indicate that behavioural and psychological symptoms of dementia and pain are important factors in influencing the QoL of patients with severe dementia.
Evaluation of MODIS Water Vapour Products over ALGERIA using Radiosonde Data
Authors: Namaoui Houaria , Kahlouche Salem , Belbachir Ahmed Hafidh 
Published: October 2021

Remote sensing of atmospheric water vapour using GNSS and Satellite data has become an efficient tool in meteorology and climate research. Many satellite data have been increasingly used to measure the content of water vapour in the atmosphere and to characterize its temporal and spatial variations. In this paper, we have used observations from radiosonde data collected from three stations (Algiers, Bechar and Tamanrasset) in Algeria from January to December 2012 to evaluate Moderate Resolution Imaging Spectroradiometer (MODIS) total precipitable water vapour (PWV) products. Results show strong agreement between the total precipitable water contents estimated based on radiosondes observations and the ones measured by the sensor MODIS with the correlation coefficients in the range 0.69 to 0.95 and a mean bias, which does not exceed 1.5.
Community-Dwelling Older Adults and Physical Activity Recommendations: Patterns of Aerobic, Strengthening, and Balance Activities
Authors: Wingood Mariana , Bonnell Levi , LaCroix Andrea Z. , Rosenberg Dori , Walker Rod , Bellettiere John , Greenwood-Hickman Mikael Anne , Wing David , Gell Nancy 
Published: October 2021

Though it is known that most older adults do not meet the recommended physical activity (PA) guidelines, little is known regarding their participation in balance activities or the full guidelines. Therefore, we sought to describe PA patterns among 1,352 community-dwelling older adult participants of the Adult Changes in Thought study, a longitudinal cohort study exploring dementia-related risk factors. We used a modified version of the Community Healthy Activities Model Program for Seniors questionnaire to explore PA performed and classify participants as meeting or not meeting the full guidelines or any component of the guidelines. Logistic regression was used to identify factors associated with meeting PA guidelines. Despite performing 10 hr of weekly PA, only 11% of participants met the full guidelines. Older age, greater body mass index, needing assistance with instrumental daily activities, and heart disease were associated with decreased odds of meeting PA guidelines. These results can guide interventions that address PA among older adults.
Franklinian Composite Tectono-Sedimentary Element, North Greenland
Authors: Hopper John R. , Ineson Jon R. 
Published: October 2021

Abstract
The Franklinian Composite Tectono-Sedimentary Element (CTSE) in North Greenland is dominated by Neoproterozoic–lowermost Devonian sedimentary strata and includes early synrift through to passive-margin TSEs of mixed carbonate and siliciclastic facies. The sedimentary successions are well exposed in much of northern Greenland, but in parts were strongly affected by the Ellesmerian Orogeny, resulting in a fold and thrust belt that deformed the northernmost exposures. An exposed palaeo-oilfield attests to the petroleum potential of the basin. Several formations have good source potential and several others have good reservoir properties. Palaeoheat-flow indicators show that temperatures increase to the north, where much of the basin is over-mature. Because of the remoteness of the area and the restricted locations where there is likely to remain petroleum potential, the basin is not currently a target for exploration.
SecRSL: security separation logic for C11 release-acquire concurrency
Authors: Yan Pengbo , Murray Toby 
Published: October 2021

We present Security Relaxed Separation Logic (SecRSL), a separation logic for proving information-flow security of C11 programs in the Release-Acquire fragment with relaxed accesses. SecRSL is the first security logic that (1) supports weak-memory reasoning about programs in a high-level language; (2) inherits separation logic’s virtues of compositional, local reasoning about (3) expressive security policies like value-dependent classification.
SecRSL is also, to our knowledge, the first security logic developed over an axiomatic memory model. Thus we also present the first definitions of information-flow security for an axiomatic weak memory model, against which we prove SecRSL sound. SecRSL ensures that programs satisfy a constant-time security guarantee, while being free of undefined behaviour.
We apply SecRSL to implement and verify the functional correctness and constant-time security of a range of concurrency primitives, including a spinlock module, a mixed-sensitivity mutex, and multiple synchronous channel implementations. Empirical performance evaluations of the latter demonstrate SecRSL’s power to support the development of secure and performant concurrent C programs.
Efficient compilation of algebraic effect handlers
Authors: Karachalias Georgios , Koprivec Filip , Pretnar Matija , Schrijvers Tom 
Published: October 2021

The popularity of algebraic effect handlers as a programming language feature for user-defined computational effects is steadily growing. Yet, even though efficient runtime representations have already been studied, most handler-based programs are still much slower than hand-written code.
This paper shows that the performance gap can be drastically narrowed (in some cases even closed) by means of type-and-effect directed optimising compilation. Our approach consists of source-to-source transformations in two phases of the compilation pipeline. Firstly, elementary rewrites, aided by judicious function specialisation, exploit the explicit type and effect information of the compiler’s core language to aggressively reduce handler applications. Secondly, after erasing the effect information further rewrites in the backend of the compiler emit tight code.
This work comes with a practical implementation: an optimising compiler from Eff, an ML style language with algebraic effect handlers, to OCaml. Experimental evaluation with this implementation demonstrates that in a number of benchmarks, our approach eliminates much of the overhead of handlers, outperforms capability-passing style compilation and yields competitive performance compared to hand-written OCaml code as well Multicore OCaml’s dedicated runtime support.
Synbit: synthesizing bidirectional programs using unidirectional sketches
Authors: Yamaguchi Masaomi , Matsuda Kazutaka , David Cristina , Wang Meng 
Published: October 2021

We propose a technique for synthesizing bidirectional programs from the corresponding unidirectional code plus a few input/output examples. The core ideas are: (1) constructing a sketch using the given unidirectional program as a specification, and (2) filling the sketch in a modular fashion by exploiting the properties of bidirectional programs. These ideas are enabled by our choice of programming language, HOBiT, which is specifically designed to maintain the unidirectional program structure in bidirectional programming, and keep the parts that control bidirectional behavior modular. To evaluate our approach, we implemented it in a tool called Synbit and used it to generate bidirectional programs for intricate microbenchmarks, as well as for a few larger, more realistic problems. We also compared Synbit to a state-of-the-art unidirectional synthesis tool on the task of synthesizing backward computations.
Relational nullable types with Boolean unification
Authors: Madsen Magnus , van de Pol Jaco 
Published: October 2021

We present a simple, practical, and expressive relational nullable type system. A relational nullable type system captures whether an expression may evaluate to null based on its type, but also based on the type of other related expressions. The type system extends the Hindley-Milner type system with Boolean constraints, supports parametric polymorphism, and preserves principal types modulo Boolean equivalence. We show how to support full Hindley-Milner style type inference with an extension of Algorithm W.
We conduct a preliminary study of open source projects showing that there is a need for relational nullable type systems across a wide range of programming languages. The most important findings from the study are: (i) programmers use programming patterns where the nullability of one expression depends on the nullability of other related expressions, (ii) such invariants are commonly enforced with run-time exceptions, and (iii) reasoning about these programming patterns requires not only knowledge of when an expression may evaluate to null, but also when it may evaluate to a non-null value. We incorporate these observations in the design of the proposed relational nullable type system.
UDF to SQL translation through compositional lazy inductive synthesis
Authors: Zhang Guoqiang , Xu Yuanchao , Shen Xipeng , Dillig Işıl 
Published: October 2021

Many data processing systems allow SQL queries that call
user-defined functions (UDFs)
written in conventional programming languages. While such SQL extensions provide convenience and flexibility to users, queries involving UDFs are not as efficient as their pure SQL counterparts that invoke SQL’s highly-optimized built-in functions. Motivated by this problem, we propose a new technique for translating SQL queries with UDFs to pure SQL expressions. Unlike prior work in this space, our method is not based on syntactic rewrite rules and can handle a much more general class of UDFs. At a high-level, our method is based on counterexample-guided inductive synthesis (CEGIS) but employs a novel compositional strategy that decomposes the synthesis task into simpler sub-problems. However, because there is no universal decomposition strategy that works for all UDFs, we propose a novel
lazy inductive synthesis
approach that generates a sequence of decompositions that correspond to increasingly harder inductive synthesis problems. Because most realistic UDF-to-SQL translation tasks are amenable to a fine-grained decomposition strategy, our lazy inductive synthesis method scales significantly better than traditional CEGIS.

We have implemented our proposed technique in a tool called CLIS for optimizing Spark SQL programs containing Scala UDFs. To evaluate CLIS, we manually study 100 randomly selected UDFs and find that 63 of them can be expressed in pure SQL. Our evaluation on these 63 UDFs shows that CLIS can automatically synthesize equivalent SQL expressions in 92% of the cases and that it can solve 2.4× more benchmarks compared to a baseline that does not use our compositional approach. We also show that CLIS yields an average speed-up of 3.5× for individual UDFs and 1.3× to 3.1× in terms of end-to-end application performance.
Formal verification of high-level synthesis
Authors: Herklotz Yann , Pollard James D. , Ramanathan Nadesh , Wickerson John 
Published: October 2021

High-level synthesis (HLS), which refers to the automatic compilation of software into hardware, is rapidly gaining popularity. In a world increasingly reliant on application-specific hardware accelerators, HLS promises hardware designs of comparable performance and energy efficiency to those coded by hand in a hardware description language such as Verilog, while maintaining the convenience and the rich ecosystem of software development. However, current HLS tools cannot always guarantee that the hardware designs they produce are equivalent to the software they were given, thus undermining any reasoning conducted at the software level. Furthermore, there is mounting evidence that existing HLS tools are quite unreliable, sometimes generating wrong hardware or crashing when given valid inputs.
To address this problem, we present the first HLS tool that is mechanically verified to preserve the behaviour of its input software. Our tool, called Vericert, extends the CompCert verified C compiler with a new hardware-oriented intermediate language and a Verilog back end, and has been proven correct in Coq. Vericert supports most C constructs, including all integer operations, function calls, local arrays, structs, unions, and general control-flow statements. An evaluation on the PolyBench/C benchmark suite indicates that Vericert generates hardware that is around an order of magnitude slower (only around 2× slower in the absence of division) and about the same size as hardware generated by an existing, optimising (but unverified) HLS tool.
Well-typed programs can go wrong: a study of typing-related bugs in JVM compilers
Authors: Chaliasos Stefanos , Sotiropoulos Thodoris , Drosos Georgios-Petros , Mitropoulos Charalambos , Mitropoulos Dimitris , Spinellis Diomidis 
Published: October 2021

Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings.
We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs.
We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers.
Specifying and testing GPU workgroup progress models
Authors: Sorensen Tyler , Salvador Lucas F. , Raval Harmit , Evrard Hugues , Wickerson John , Martonosi Margaret , Donaldson Alastair F. 
Published: October 2021

As GPU availability has increased and programming support has matured, a wider variety of applications are being ported to these platforms. Many parallel applications contain fine-grained synchronization idioms; as such, their correct execution depends on a degree of relative forward progress between threads (or thread groups). Unfortunately, many GPU programming specifications (e.g. Vulkan and Metal) say almost nothing about relative forward progress guarantees between workgroups. Although prior work has proposed a spectrum of plausible progress models for GPUs, cross-vendor specifications have yet to commit to any model.
This work is a collection of tools and experimental data to aid specification designers when considering forward progress guarantees in programming frameworks. As a foundation, we formalize a small parallel programming language that captures the essence of fine-grained synchronization. We then provide a means of formally specifying a progress model, and develop a termination oracle that decides whether a given program is guaranteed to eventually terminate with respect to a given progress model. Next, we formalize a set of constraints that describe concurrent programs that require forward progress to terminate. This allows us to synthesize a large set of 483 progress litmus tests. Combined with the termination oracle, we can determine the expected status of each litmus test -- i.e. whether it is guaranteed to eventually terminate -- under various progress models. We present a large experimental campaign running the litmus tests across 8 GPUs from 5 different vendors. Our results highlight that GPUs have significantly different termination behaviors under our test suite. Most notably, we find that Apple and ARM GPUs do not support the linear occupancy-bound model, as was hypothesized by prior work.
Modular specification and verification of closures in Rust
Authors: Wolff Fabian , Bílý Aurel , Matheja Christoph , Müller Peter , Summers Alexander J. 
Published: October 2021

Closures are a language feature supported by many mainstream languages, combining the ability to package up references to code blocks with the possibility of capturing state from the environment of the closure's declaration. Closures are powerful, but complicate understanding and formal reasoning, especially when closure invocations may mutate objects reachable from the captured state or from closure arguments.
This paper presents a novel technique for the modular specification and verification of closure-manipulating code in Rust. Our technique combines Rust's type system guarantees and novel specification features to enable formal verification of rich functional properties. It encodes higher-order concerns into a first-order logic, which enables automation via SMT solvers. Our technique is implemented as an extension of the deductive verifier Prusti, with which we have successfully verified many common idioms of closure usage.
Symbolic value-flow static analysis: deep, precise, complete modeling of Ethereum smart contracts
Authors: Smaragdakis Yannis , Grech Neville , Lagouvardos Sifis , Triantafyllou Konstantinos , Tsatiris Ilias 
Published: October 2021

We present a static analysis approach that combines concrete values and symbolic expressions. This symbolic value-flow (“symvalic”) analysis models program behavior with high precision, e.g., full path sensitivity. To achieve deep modeling of program semantics, the analysis relies on a symbiotic relationship between a traditional static analysis fixpoint computation and a symbolic solver: the solver does not merely receive a complex “path condition” to solve, but is instead invoked repeatedly (often tens or hundreds of thousands of times), in close cooperation with the flow computation of the analysis.
The result of the symvalic analysis architecture is a static modeling of program behavior that is much more complete than symbolic execution, much more precise than conventional static analysis, and domain-agnostic: no special-purpose definition of anti-patterns is necessary in order to compute violations of safety conditions with high precision.
We apply the analysis to the domain of Ethereum smart contracts. This domain represents a fundamental challenge for program analysis approaches: despite numerous publications, research work has not been effective at uncovering vulnerabilities of high real-world value.
In systematic comparison of symvalic analysis with past tools, we find significantly increased completeness (shown as 83-96% statement coverage and more true error reports) combined with much higher precision, as measured by rate of true positive reports. In terms of real-world impact, since the beginning of 2021, the analysis has resulted in the discovery and disclosure of several critical vulnerabilities, over funds in the many millions of dollars. Six separate bug bounties totaling over $350K have been awarded for these disclosures.