dataesr/scientific-paragraphs-categorization huggingface dataset:
Acknowledgements. We thank  Eric Emsellem  and  Guy Perrin  for their help in securing financial support for this research and the work of TF. TF and MDL would like to thank  Fiorella Polles  for helpful discussions on the use and interpretation of Cloudy and MDL thanks  Pierre Guillard  for advice and interesting discussions about PDR physics and modeling. TF would like to thank  Susanne Aalto  on her valuable input on an earlier version of this paper. This study makes use of ADS/JAO. ALMA# 2015. 1. 00530. S. ALMA is a partnership of  ESO  (representing its member states),  NSF (USA)  and  NINS (Japan) , together with  NRC (Canada) ,  NSC  and  ASIAA (Taiwan) , and  KASI (Republic of Korea) , in cooperation with the  Republic of Chile. This work fulfills part of the Ph. D. requirements for Theresa Falkendal at  Sorbonne Université.
Acknowledgments The present volume is one of the outcomes of the conference "Theory's History, 196X-199X: Challenges in the Historiography of Architectural Knowledge," convened in Brussels, February 6-8, 2017 and organized by the current volume's editors, together with Yves Schoonjans, Elke Couchez, Ricardo Agarez, and Maarten Delbeke. 44 The volume's introduction partly draws on the jointly drafted Call for Papers for this conference, while the majority of individual contributions are substantially revised versions of papers presented on the occasion itself. We are thankful to Andrew Leach and an anonymous reviewer for their constructive comments on an earlier draft of this introduction as well as the book's overall setup. Semiotics did not originate in the mid-1960s. At the awakening of the 20 th century, the development of a general "theory of signs" was announced almost simultaneously by the Swiss linguist Ferdinand de Saussure (1857-1913), who named it "sémiologie," and by the American philosopher and scientist Charles Sanders Peirce (1839-1914), who used the term "semiotic.
CH A P T E R 4 Architecture Becomes Programming: invisible Technicians, Printouts, and Situated Theories in the 1960s Matthew Allen I will begin with a slightly unusual telling of a much-rehashed narrative in the history of architectural theory. 1  In a 1957 essay, John Summerson suggested that architects would need to reconstruct their discipline around programming -they should give up designing form and start to think about organizing patterns of activity. 2  few architects took Summerson's advice to heart. Christopher Alexander wrote software to manipulate architectural programs; Cedric Price seems to have spent most of his time gathering data and drawing diagrams. 3 Two senses of the term "programming" developed simultaneously in this era. In architecture, programming referred to the practice of organizing functional spaces,  4  while in the field of computation, programming referred to the practice of creating software.
10 ). As much as any other image from this period, these drawings convey the atmosphere of 1960s hacker culture: extracting the furthest range of surprising possibilities from the limited equipment available. These printouts also certainly take part in the information aesthetic -"the 'pleasure' of thinking" and "the excitement of discovering new rules, laws, and limitations"  60  -that drove much experimentation in computer art in this period. 61 LCGSA researchers looked for patterns in the built environment by obsessively studying the figures created by overlapping layers of information. 62 When Colin Rowe later poked fun at "the enthusiasts for data collection," it was certainly people like the researchers at the LCGSA that he had in mind. The theory involved in standard printer drawings could be characterized as positivist: the information aesthetic certainly depends on belief in the value of empiricism, that knowledge is cumulative, and that societies and environments are undergirded by patterns and laws.
ASP has been commonly used for temporal reasoning and the representation of action theories, following the methodology proposed by  Gelfond and Lifschitz (1993). This methodology represents transition systems by adding to all time-dependent predicates an extra integer parameter: the time point T ranging over the finite interval 0, 1,. , n-1 where n ∈ N is some fixed length that can be iteratively increased. A major disadvantage of this representation is that it provides neither special language constructs nor specific inference methods for temporal reasoning, as available in LTL. As a result, it is infeasible to represent properties of reactive systems (with infinite runs or traces) such as safety ("Is some particular state reachable?"), liveness ("Does some condition happen infinitely often?"), or to conclude that a given planning problem has no solution at all.
This logic allows for first-order logic programs in ASP to be partially simplified before grounding. Moreover, its monotonic basis, Quantified Here-and-There (QHT), can be used to check the property of strong equivalence, analogous to HT in the propositional case. The definition of QHT is based on a first-order language denoted by C, F, P , where C, F and P are three disjoint sets representing constants, functions and predicates, respectively. Given a set of constants D, we define: • T (D, F ) as the set of all ground terms that can be built with functions in F and constants in D, and • A(D, P ) as the set of all ground atomic sentences that can be formed with predicates in P and constants in D. In its most general version, QHT allows for different domains in the here and there worlds and the interpretation of equality can also be varied in each world.
This is, in fact, the usual model-based problem solving orientation of ASP, where stable models encode solutions to a particular problem, encoded by the rules in the logic program. In this way, if we want to solve a temporal diagnosis scenario, we are interested in finding at least one TS-model that explains the observations. Similarly, for a given planning problem, we look for some plan that reaches the goal in a finite number of steps. In this section, we show how the generation of TS-models can be done using ASP technology by considering temporal theories with a syntax closer to logic programming. As we see next, both TEL ω and TEL f can be reduced to a normal form that we call (modal) temporal logic programs. This normal form is useful for ASP-based computation. For the finite case, there are two translations of this normal form into ASP.
Bounded translation of temporal programs over finite traces to ASP A first way to encode a temporal program P into standard ASP is by assuming that we know the (finite) trace length λ beforehand. In that case, we can compute all models in TEL(P, λ) by a simple translation of P into a regular program. For this, we let A k = {a k | a ∈ A} be a time stamped copy of alphabet for each time point k ∈ [0. λ). Definition 9 (Bounded translation;  Cabalar et al. 2018)  We define the translation τ of a temporal literal at time point k as: τ k (a) def = a k τ k (¬a) def = ¬a k for a ∈ A τ k (•a) def = a k-1 τ k (¬•a) def = ¬a k-1 for a ∈ A. We define the translation at time point k of any (non-fulfillment) rule r as those in Definition 7 as: τ k (r) def = τ k (a 1 ) ∨ • • • ∨ τ k (a m ) ← τ k (b 1 ) ∧ • • • ∧ τ k (b n ).
Pointwise translation of temporal programs over finite traces to ASP The bounded translation τ λ (P ) allows us to compute all models in TEL(P, λ) for a fixed λ. However, in many practical problems (as in planning, for instance), λ is unknown beforehand and the crucial task consists in finding a representation of TEL(P, k) that is easily obtained from that of TEL(P, k-1). In ASP, this can be accomplished via incremental solving techniques that rely upon the composition of logic program modules  (Oikarinen and Janhunen 2006). The idea is then to associate the knowledge at each time point with a module and to successively add modules corresponding to increasing time points (while leaving all previous modules unchanged). A stable model obtained after k compositions then corresponds to a TEL f -model of length k.
We have implemented a second system, telingo 12   (Cabalar et al. 2019) , that deals with present-centered temporal programs that are expressible in the full (non-ground) input language of clingo extended with temporal operators. In addition, telingo offers several syntactic extensions to facilitate temporal modeling: first, next operators can be used in singular heads and, second, arbitrary temporal formulas can be used in integrity constraints. All syntactic extensions beyond the normal form of Theorem 11 are compiled away by means of the translation used in its proof. The resulting present-centered temporal programs are then processed according the point-wise translation. To facilitate the use of operators • and •, telingo allows us to express them by adding leading or trailing quotes to the predicate names of atoms, respectively.
For instance, the temporal literals •p(a) and •q(b) can be expressed by 'p(a) and q'(b), respectively. For another example, consider the representation of the sentence "A robot cannot lift a box unless its capacity exceeds the box's weight plus that of all held objects": :-lift (R ,B), robot (R), box (B ,W), # sum { C : capacity (R ,C ); -V ,O : ' holding (R ,O ,V) } < W. Atom 'holding(R,O,V) expresses what the robot was holding at the previous time point. The distinction between different types of temporal rules is done in telingo via clingo's #program directives  (Gebser et al. 2019) , which allow us to partition programs into subprograms. More precisely, each rule in telingo's input language is associated with a temporal rule r of form (b 1 ∧ • • • ∧ b n → a 1 ∨ • • • ∨ a m ) as in Definition 7 and interpreted as r, • r, or ( → r) depending on whether it occurs in the scope of a program declaration headed by initial, dynamic, or final, respectively.
Accordingly, <*/1, <?/1, <:/1 represent , , •, and analogously their future counterparts. I and are are represented by &initial and &final. This is complemented by Boolean connectives &, |, ~, etc. For example, the integrity constraint 13  'shoot ∧ unloaded ∧ • shoot → ⊥' can be expressed as follows. :-shoot , & tel { <* unloaded & < <? shoot }. Once telingo has translated an (extended) temporal program into a regular one, it is incrementally solved by clingo's multi-shot solving engine  (Gebser et al. 2019). To conclude this section, we provide a larger example of telingo encoding (a more detailed description of the system was presented by  Cabalar et al. (2019) ). Listing 1 contains an exemplary telingo encoding of the Fox, Goose and Beans Puzzle available at https://github. com/potassco/telingo/tree/master/examples/river-crossing.
Related work Covering the vast literature that falls in the intersection of temporal reasoning and logic programming is too ambitious for the purpose of the current survey (focused on extending ASP with modal, LTL operators) and would surely require a more extensive document. In this section, we overview those approaches that show a closer connection to the kind of temporal logic programs considered in the paper. We divide this related work into two categories: (1) extending the language with modal operators based on linear traces and (2) using logic programming for temporal reasoning.
Extending the syntax with linear modalities As mentioned in the introduction, the first use of the term "Temporal Logic Programming"  (Abadi and Manna 1989)  dates back to the late 1980s, appearing soon after the introduction of modal extensions of Prolog  (Fariñas del Cerro 1986; Bieber et al. 1988). Several Logic Programming (LP) languages dealing with LTL operators were proposed  (Moszkowski 1986; Fujita et al. 1986; Gabbay 1987b; Abadi and Manna 1989; Orgun and Wadge 1990; Baudinet 1992). The latter, a formalism called TEMPLOG, is perhaps a prominent case from a logical point of view. It provides a logical semantics in terms of a least LTL-model, in the spirit of the well-known least Herbrand model for positive 14  logic programs  (van Emden and Kowalski 1976). (Cabalar et al. 2015, Theorem 5)  proved that TEMPLOG is actually subsumed by TEL, that is, the latter can be used as a generalization of the former for an arbitrary temporal syntax that includes default negation.
However, although TEL provides a common underlying semantics to TEMPLOG and our temporal programs (which are the basis of telingo), these two languages understand the (modal) temporal logic programming paradigm in a substantially different way, analogous to the differences between Prolog and ASP. In particular, TEM-PLOG understands rules in a top-down fashion where the head is considered a goal and the body is seen as a method (list of subgoals) to achieve the goal. As a result, (futuretime) LTL operators are used to represent temporal relations affecting the achievement of these subgoals. As an example, one possible TEMPLOG rule could look like ( printorder ← ack , •(print, ♦finished) ), meaning that, at any moment, a printorder is fulfilled by immediately sending an acknowledgment ack , then starting the printer print and eventually sending a finished message.
This TEMPLOG rule naturally corresponds to the TEL implication ( ack ∧ •(print ∧ ♦finished) → printorder ), and has indeed the same semantics in TEL. However, it does not fit into the past-future syntactic fragment used in telingo, since the printorder in the head is in the relative past of the conditions required in the body, talking about future satisfaction of print or finished. Following the ASP bottom-up understanding of rules, which is closer to causal laws in action languages, this same example would be represented instead as the past-future formula: (printorder → ack ∧ •(print ∧ ♦finished )), which can be reduced afterwards to a present-centered logic program. To sum up, TEL is rich enough to cover both bottom-up and top-down readings of program rules, but for its use for temporal ASP, it suffices with a syntactic fragment where past is checked in the bodies and future is used in the head.
These action descriptions were then translated into logic programs under the ASP semantics using a similar transformation as the one presented in Section 5. 1. Several authors have explored the formalization of action and change using Dynamic Logic  (Baldoni et al. 1997; Schwind 1997; Castilho et al. 1999)  or DLTL  (Giordano et al. 2001) , though only the first one relies on a logic programming paradigm. Another prominent AI field for reasoning about dynamic systems where temporal logic has played an important role is Planning. In this area, the system behavior is specified in terms of some planning-specific language like STRIPS or PDDL, with a carefully limited syntax that avoids the need for an explicit representation of the (non-monotonic) law of inertia. This limited syntax restricts the specification of dynamic systems to a less expressive language than temporal ASP with telingo, where defaults, induction or aggregates can be freely combined with temporal operators, but has the advantage of allowing the design and implementation of efficient planning algorithms.
(2019). In this case, a classical graph search algorithm was implemented and multi-shot ASP solving was used to compute successor states during search. This has the advantage of being able to explore the whole state space and deciding whether a given planning problem has no solution, something impossible by the incremental horizon strategy followed in telingo. However, this planning based prototype had a rather limited syntax and did not allow the use of temporal expressions to incorporate temporal goals. Other AI areas where temporal logic has been successfully applied are, for instance, Multi Agent Systems (MAS) and Ontologies. In the case of MAS, a prominent example is the system Concurrent MetateM  (Fisher 1994 ), a language using LTL operators that exploits Gabbay's separation theorem  (Gabbay 1987a ) asserting that LTL descriptions can be reduced to a set of implications with the form "past → future.
This approach, called Datalog 1S , allows for reasoning about infinite traces while keeping decidability. Moreover, it was proved  (Baudinet et al. 1993 ) to be equally expressive to TEMPLOG, although both languages treat time in a different way: TEMPLOG uses intensional, temporal modalities, whereas Datalog 1S uses an extensional approach, representing time points as explicit parameters. Later on, this formalism was extended to so-called Datalog nS  (Chomicki and Imielinski 1993)  and used as a reasoning system for answering temporal queries expressed in past LTL. A similar approach to Datalog 1S , based on the introduction of a successor unary function, was adopted by  Eiter and Šimkus (2009)  for the more general case of ASP. Other extensions of Datalog that have been used as reasoning engines for temporal logics are Datalog LITE  (Gottlob et al.
The original approach translated the LTL formula into a propositional theory and then used a SAT solver as a backend. Heljanko and Niemelä (2003)  proved that an ASP solver could be used instead of SAT, providing a more compact translation of LTL formulas while keeping an efficient implementation. A similar approach was later followed by  Giordano et al. 2012; 2013  to implement BMC for action theories and temporal answer sets. Again, although the use of ASP for BMC is clearly in the intersection of temporal logics and logic programming, it does not necessarily represent a temporal extension of the latter. Note, for instance, that the tool by  Heljanko and Niemelä (2003)  provides a model checker whose input language are temporal formulas with the standard monotonic semantics of LTL. Finally, one more application of ASP for temporal reasoning is its use for encoding Qualitative (Spatio-)Temporal Calculi  (Li 2012; Brenton et al.
Moreover, the definition of TEL f has also provided a methodology for the study of other extensions, like the introduction of dynamic logic operators  (Cabalar et al. 2020)  or, more recently, the definition of temporal metric constructions  (Cabalar et al. 2020 ) that are planned to be further developed and combined with other features inside the software packages of potassco. org. This survey has been focused on the LTL extension of ASP where many interesting lines remain to be explored yet. For instance, we still miss an axiomatization that covers the finite trace variant of the monotonic basis, THT f , or a general axiomatization that is applicable to THT, that is, regardless of the trace length. Also, properties related to inter-definability of operators need to be further explored for the finite trace case.
(2017) , but it focused on infinite traces, making these results not extrapolatable to the case of telingo, where the hypothesis of finite traces can be exploited more efficiently. In a broader picture, we are facing a true rebirth of (Modal) Temporal Logic Programming, which is becoming a thrilling area with an intense research both on foundations and in practical implementation. As we have seen in Section 7, there exist several temporal extensions of ASP and Datalog with applications to planning and problem solving on dynamic domains, temporal Knowledge Representation and, more recently, stream reasoning. It seems clear that practical applications may require a richer language than the LTL syntax, as happens with some of the ASP extensions introducing metric constructs or path expressions from dynamic logic.
Acknowledgments We are thankful to the anonymous reviewers for their thorough work and their useful suggestions that have helped to improve the paper. A special thanks goes to  Mirosaw Truszczyński  for his support in improving the quality of our paper. We are especially grateful to  David Pearce , whose help and collaboration on Equilibrium Logic was the seed for a great part of the current paper. This work was partially supported by  MICINN, Spain , grant  PID2020-116201GB-I00 ,  Xunta de Galicia, Spain  ( GPC ED431B 2019/03 ),  Région Pays de la Loire, France , (projects  EL4HC  and etoiles montantes CTASP),  European Union   COST action   CA-17124 , and  DFG  grants  SCHA 550/11  and  15 ,  Germany.
Experimental data also suggest an in utero pathogenesis of ASD  [24] [25] [26] [27] [28] [29]. Thus, Maternal Immune Activation (MIA) or maternal valproate administration during gestation are associated with ASD  25, 30. Also, early post-natal alterations are observed in the ASD in utero VPA model and in Fragile X mice  31. Brain overgrowth during parturition and birth has been observed in the rodent ASD in utero VPA model  30. Collectively, these observations illustrate the extreme heterogeneity of pathological events associated with ASD and the need to identify the sequence of events generated by the initial in utero insult. Here, we analyzed biological and ultrasound measurements routinely collected in maternities from the first pregnancy trimester to 1 day after birth to determine if they could enable a prognosis of ASD at birth.
Results A classifier was trained on our dataset with a strategy aimed at minimizing false ASD detections while keeping true ASD detection rate as high as possible. The performance of the classifier was evaluated by the estimation of classification scores through a CV process. To reduce the risk of overfitting and assess the ability of the classifier to act without human intervention, two feature selection strategies (FSS) were employed. i) We first used a semi-automatic FSS with a preselection of features relying on domain knowledge and observations that suggest an implication of a given feature in ASD pathogenesis. With this approach, the true negative rate, i. e. the proportion of NT babies correctly classified as NT, was of 0. 96 (95% CI = [0. 95, 0. 97]), thus only 4% of NT babies were wrongly classified as ASD (Table  1 ).
A large dataset with enough samples in each ASD subclass might enable to extrapolate the methods and findings of this study into biological or symptomatic subgroups. To conclude, our results suggest that it might be possible to establish a prognosis at birth of a subpopulation of babies who will develop ASD. The trained algorithm will require larger replications before being considered as a clinical tool for predicting ASD in large populations, as false predictions might adversely affect individuals. Yet, our results are in keeping with various lines of evidence suggesting that ASD is generated in utero  16, 42  possibly by a pathogenic in utero sequence of events that impacts cell proliferation, migration and many other essential processes  66. The time and structural basis of the initial insult most likely underlies the heterogeneity of ASD  42, 66.
Data and experiments. In 2012-2013, 5356 babies were born in the maternity Hospital of the University of Limoges in France. Two to 5 years later, 65 of these babies (1. 21%) were diagnosed with ASD (DSM-5 APA 2013) and confirmed by ADI-R and the Autism Diagnostic Observation Schedule (ADOS G). Babies whose mothers were of legal age (18 years old in France) were included in the study. Moreover, the parents of the babies must speak French and be affiliated with the French social security system. The babies had to be born alive and had no abnormalities other than ASD and no abnormalities for the NT ones. Babies for whom the vast majority of the pregnancy was followed in another maternity hospital were excluded from this study. The classical follow-up from the second ultrasound (20-24 weeks of amenorrhea) was required to be included.
Data preprocessing. The values of each 116 recorded features in the dataset were explored and cleaned carefully to reduce the noise in the computations. Features with a missing value rate higher than 10% were removed from the classification process to reduce the imputation bias in the results. Features that were included in the classification process are given in the Supplementary Table  S5. Consequently, the classification dataset consists of 67 features for which 2. 58% of values are missing in total. The one-hot encoding technique  77  was applied to binarize categorical features. To avoid co-linearity, one category of each feature was dropped.