sadat2307/MSciNLI huggingface dataset:
Domain: Software and its engineering
Sentence 1: The reason for this separation is to enforce a few syn­tactic restrictions on the language.
Sentence 2: nested datatypes(Bird andMeertens,1998) and constructors with functional parameters having recursive occurrences (Mei­jer and Hutton, 1995) are excluded, since traversals are hardtode.nefor those types.Despite these restrictions, the data constructorpresentedhereis comparablein expressive power to ML-style and Haskell 98-style datatypes, allow­ing us to express (type-)parametrized datatypes, mutually recursivedatatypes and existentialdatatypes.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The model aims at establishing a common under­standing of the support that should be provided by a generic B3G-SOM and can be considered as a facilitator for design­ing architectures of speci.c B3G-SOM solutions.
Sentence 2: the entities and relationships within our model, and the rich textual description, should be intended as base guidelines to be considered while designing B3G-SOM architectures.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Informally, the above definition states that for a protocol P to satisfy the K-protection requirement, whatever information it passes to a peer X (other than C and S) should not increase the certainty of X about the result beyond a certain limit.
Sentence 2: x should not be able to determine, with a probability above a certain threshold, that any given value v belongs to a column RjX in the result RX (the translation of RC to X s schema).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: A PROPOSAL OF A PATTERN MV-C-UI For the use in ambient computing environments, this work proposes a derivation of the MVC-pattern called MV-C-UI (Model&#38;View-Controller-User Interface Implementation), in which the cuts to implement physical distribution are de­noted by the symbol - (minus).
Sentence 2: the controller is separated from the application host and free to (partially) migrate to other devices.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Damasc can be leveraged by existing applications without rewrit­ing the application code, as long as data management libraries (e.g., NetCDF [20], NetCDF-4 [34], HDF5 [13], MPI-IO [10]) are rewrit­ten to interface Damasc.
Sentence 2: rewrite only the external libraries to issue declarative queries instead of reading/writing byte extents.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Although this minimalist approach is useful in the first stages of teaching objects and in exploratory design, we suggest that most designs should evolve towards building classes with a rich set of constructors and methods so that the instance objects may be born mature, that is, ready to use in the program without further tweaking.
Sentence 2: we believe that if students are taught to design in this manner, then they will be more effective both as students and as computing professionals.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Implementing this automatically requires some annota­tions on the speci.cation, as well as a fairly complex anal­ysis of the base program, however, going well beyond the cheap techniques we have introduced here.
Sentence 2: such analysis is necessary when it is not deemed acceptable to modify library code, to check that certain objects are con­structed only in the compiled code, and not elsewhere.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Here, we show what these skipped paths corre­spond to in typical programs, i.e., we show what code is typically analyzed at a particular approximation level, and what code is not visited at all.
Sentence 2: the analysis typically only applies full sensitivity for classes whose object contents must be distinguished to precisely answer a query, e.g., to .nd the contents of a particular Vector object.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This project is using several exemplars from a variety of US Federal agencies as the first step to providing guidance in how to improve access to tables.
Sentence 2: we are examining the tables presented in government statistical portals such as Fedstats (www.fedstats.gov) and the American Fact Finder (http://www.census.gov), and CD-ROM sources such as the Statistical Abstracts of the United States.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: It also agrees with the interview-derived data from Project D. We also used several additional measures to triangulate our results: evidence is stronger where analyses using dis­tinct measures concur.
Sentence 2: we used two addi­tional metrics to measure productivity: the number of mod­ules modi.ed per sta.-month and the number of completed MRs per sta.-month.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: But we again decided to use de Bruijn indices for the same reason as for term variables: names are dif.cult to reify ef.ciently as types in GHC, and reasoning about freshness would introduce a lot of complexity and force us to restructure the code signi.cantly.
Sentence 2: essentially the same arguments that led us to choose de Bruijn indices for the term variables, led us to use de Bruijn for term-level type variables.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: if ((wheat &#38; farm) or (wheat &#38; commodity) or (bushels &#38; export) or (wheat &#38; tonnes) or (wheat &#38; winter &#38; ¬ soft)) then WHEAT else ¬ WHEAT Such a method, sometimes referred to as knowledge engineering , provides accurate rules and has the additional benefit of being human understandable.
Sentence 2: the definition of the category is meaningful to a human, thus producing additional uses of the rule including verification of the category.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Therefore, we propose the following SS implementation: the accumulated overrun is saved in an overrun pool Opool, i.e., when an overrun O occurs, Opool+= O;  each recharge amount is limited by the initial server budget Q,i.e., if the server executedfor(Q+O)units, the recharge amount is set to Q;  at each replenishment time t: 1. the replenishment amount is, as usual, added to the current server budget q; 2. if Opool > 0,both the overrunpool Opool and the current budget q are decreased by min{q,Opool}; 3. a recharge of min{q,Opool} units is set after one period, i.e., at time t +P.
Sentence 2: in case of an overrun O, the proposed mech­anism works as if a budget amount of O (or as close as pos­sible to O) is instantly consumed by the server at the next replenishment time.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Hence, it retrieves theCSID and PC of the recovery point that corresponds to var2 (CSID=1 and PC=7 in this case), and sends the latest value of var2 to T2.With such information, T2 now can start the incremental recovery.
Sentence 2: it reexecutes the code from the instruction whose PC is 7, and uses the latest value of var2 and thevalue storedin space1 for all othervariables.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: However, every node N on this static chain between R and Q is in this subchain and hence is in the dynamic chain.
Sentence 2: n is in the part of this dynamic chain that extends from R to Q; hence N is in L, and therefore in T´ since it is in T. For part (b), suppose the contrary, so that X´ is in T´, and thus in L. Since L is strongly connected and R is in L, there is a path from X´ to R. Since X is a static descendant of R, there is a path from R to X, by Lemma 6.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 1 lst_nd* q(lst_nd *y) { // Inferred Pre: list(y) 2 lst_nd *x, *z; 3 x=malloc(sizeof(lst_nd)); x->tail=0; 4 z=malloc(sizeof(lst_nd)); z->tail=0; 5 // Abducted: list(y), Framed: z|->0 6 merge(x,y); // Obtained Post: list(x)*z|->0 7 merge(x,z); // Obtained Post: list(x) 8 return(x); 9 } // Inferred Post: list(ret) This time we infer anti-frame list(y) as before, but using bi­abduction we also infer z.0 as the frame axiom that won t be needed by procedure call at line 6.
Sentence 2: we obtain a solution of the bi-abduction question x.0 * z.0 * ?anti-frame f list(x) * list(y) * ?frame where ?anti-frame = list(y), ?frame = z.0.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We set out to answer this question within the context of an IBM middleware product-line.
Sentence 2: we wanted to know if AOSD could help us achieve consistent Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Interestingly, our asynchronous replication protocol may vary at run-time, according to the asynchrony of the system, between some form of primary-backup and some form of active replica- tion.
Sentence 2: different replicas can concurrently pro- cess different requests, which allows us to build a cluster of replicas that can dynamically scale up and down to handle the current demand.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The interval [r, r + D - 1] for 0 = r < R - 1 represents the node IDs that are in the rth region; the last region spans [D × (R - 1), nmax - 1].
Sentence 2: a node ID i is replicated to each other region by taking (i + D × r) mod n for 1 = r < R. the information is replicated evenly around the ID space to R locations.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 4.1 Variable Interface The variable interface of an SPL contains all unique sig­natures of all existing members (i.e., classes, methods, and .elds) with a presence condition describing in which fea­tures the member is de.ned.
Sentence 2: if a member is de.ned in several modules, it is included in the variable interface only once, but with the list of the de.ning features (i.e., the presence condition).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Baselines in Requirements Tracing Senthil Karthikeyan Sundaram Jane Huffman Hayes Alexander Dekhtyar Computer Science Department Computer Science Department Computer Science Department University of Kentucky University of Kentucky University of Kentucky skart2@uky.edu hayes@cs.uky.edu dekhtyar@cs.uky.edu ABSTRACT We summarize the results of our requirements tracing work to date, focusing on our empirical results with open source datasets.
Sentence 2: we describe the problem of after-the-fact requirements tracing for Verification and Validation (V&#38;V) analysts, we provide a brief overview of Information Retrieval methods we have applied as well as measures used to evaluate them, we describe our tracing tool, and we present the results of a number of empirical studies.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Acknowledgments The work presented in this article in mainly developed as a master the­sis by the two .rst authors[4], during that work we have received gen­ erous guidance from multiple members of the HIPERFIT research cen­ter.
Sentence 2: mogens Steffensen (Department of Math, University of Copenhagen), Carl Balslev Clausen (SimCorp), Martin Elsman (then Sim-Corp, now DIKU/HIPERFIT center), Dirk Bangert (Bangert Research) and Rolf Poulsen (Department of Math, University of Copenhagen).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In this experience report, I highlight some of the features I haveparticularly found useful,drawing examples frompub­lished veri.cations using SAL.
Sentence 2: i discuss the use of higher-order functions in model checking, in.nite­state bounded model checking, compositional speci.cation and veri.cation,and .nally,mechanical theoremproverand model checkerinterplay.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: For each in­stant, we detail exactly how and when each thread executes: Instant 1 :Thread A gets blocked line 1 because it is waiting for a signal not already broadcast during the instant.
Sentence 2: thread B broadcasts sig1 line 1 ,then it co­operates line 2 .B has completed its execution for the instant.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 5.1 Scalability and precision: SPEC In order to test the precision and scalability of PSE, we applied it to postmortem analysis of pointer dereferences in the integer benchmarks from Spec95.
Sentence 2: we  Bench Normal No Ts No May No Ab No May/Ab compress 0.001 0.001 0.001 0.001 0.001 li 0.524 0.773 0.288 0.571 0.111 go 0.002 0.007 0.002 0.002 0.002 m88ksim 0.003 0.012 0.002 0.003 0.002 ijpeg 0.017 0.039 0.002 0.017 0.002 perl 2.990 5.447 1.396 3.135 2.836 vortex 0.531 1.270 0.283 0.521 0.283 gcc 0.400 0.927 0.319 0.388 0.330 Figure 9: Average tracking times for our di.erent con.gurations on the SPECbenchmarks.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Although somewhat awkward, iterators let one write non-blocking tasks in a sequential style by yield-ing control to a dispatcher that advances the iterator through its states [CS05].
Sentence 2: by yielding CML events, and having the dispatcher queue an action to resume the iteration asynchronously on completion of each event, we can arrange to multiplex a large number of lightweight tasks over a much smaller set of CLR worker threads.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In our framework implementation, we follow an intuitive strat­egy that triggers the actuator component for adding a new replica when it detects a number of continuous up-to-date monitored repli­cation delays of a replica which exceeds its application-de.ned threshold(T )of SLA violation of data freshness.
Sentence 2: for a running database replica, if the latest T monitored replication delays are violating its SLA of data freshness, the analyser compo­nent will trigger the actuator component to activate the geographi­cally closest replica (for the violating replica).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Note that for nested structures, s, inside recordings, S, we have to take the least upper bound, C. | This is because when determining the kinds of values x can have in a concatenation, ·, we have to take the union of the possibilities.
Sentence 2: x is typed as a list whose elements can be in: L(R1).L(R2); i.e., the union of the two recordings of the same name.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: It is worth notice that .gures related to System.Data.-DataSet ob jects are actually referred to the overriders we implemented to serialize them, since the class is not Compact­Formatter.Serializable and we could not modify it.
Sentence 2: when using an overrider, we measure perfor­mances of overrider and not of the CompactFormatter.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: To the best of our knowledge this expressivity is not widely used to deliberately protect strengthened invariants, but the general pattern arises often.
Sentence 2: an OCaml compilation unit in .le foo.ml implicitly de.nes a module Foo ascripted to foo.mli (if that exists); the body of foo.ml itself often contains ascripted module de.nitions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: That is, the following code: int m(Foo x){return x.bar;} will be successfully compiled only if the table "Foo" has a .eld bar of type int.
Sentence 2: checks on the table shape are performed at compile-time.7 The two examples above also show that our approach allows, in a statically typed setting, an expressive power which is typical of dynamically typed languages.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Corollary 1 states that if for all the (m+1) intervals, Ii, i =0 ...m, fi does not satisfy the conditions (2) and (3) of the optimization problem OPTi, then in the optimal solution the response time of the application is limited to the set {c,(d-Bm),...,(d-B1),d}.
Sentence 2: if the given conditions hold, in the optimal solution, the slack of the application should be exactly equal to 0, d-c or one of the break-even times {Bi}.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The distributable threads model, discussed in detail in Section 3, provides a coherent, end-to-end abstraction for building concurrent, sequential activities for distributed systems in a manner familiar to Java and real-time programmers alike.
Sentence 2: the presence of a distributed ob ject model (RMI) in the Java platform makes the distributable thread concept a straightforward step for Java programmers into the world of distributed real-time programming.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This is because methodWithNameInClass/3, the SOUL query used with different parameters in the two alternatives, is de­.ned as: methodWithNameInClass( ?method, ?selector, ?class) if methodInClass( ?method, ?class), methodWithName( ?method, ?selector) Once we have de.ned an anti-explanation for an abducible pred­icate, we are implicitly de.ning a possible anti-explanation for all the predicates that depend on the success of our abducible predi­cate.
Sentence 2: if the success of methodWithNameInClass/3 depends on the success of methodInClass/2, an anti-explanation for methodInClass/2 will be an anti-explanation for methodWith­NameInClass/3.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The basic idea behind our technique is as follows.Aprogram exhibits phase behavior [15] in that it goes through several phases of execution that show approximately similar runtime character­istics compared to other phases of execution.
Sentence 2: if we can approxi­mately predict similarity among program phases statically, we can use this information to determine assignments of threads-to-core at alow runtime cost.by monitoring theexecutionof an initial phase in the program, we can predict the execution charac­teristic of the later phases of the program that resemble this phase.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Consequently, a global schedule can be created in which each cyberorg receives the resources it is promised as a func­tion of the resources entering the system.
Sentence 2: instead of launching a new scheduler for each cyberorg, all cyberorgs in­ternal schedules are composed into a single .at schedule of actors which is equivalent to the hierarchical schedule (Figure 6).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 15, it is also possible to re.ne implementation classes, whereby the def­initions of the nested classes can again be re.ned with the override modi.er.
Sentence 2: the subclassing and sub­typing relations between individual classes in standard OO are naturally carried over to the implementation classes of CIs; again with the important di.erence that our nested classes are virtual types as explained in the previous section.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The function F is constructed so that no matter how the algorithm redistributes its pebbles upon shaking a bin at time t, and no matter what the current state is, the decrease in F is no more than the cost incurred by the algorithm.
Sentence 2: for any 0 = t = n - 1: w(t) = F(t) - F(t + 1), where F(t) is the potential at t, and w(t) is the cost of the algorithm at t. Summing up over t, we get that the total A cost is t w(t) = F(0) -F(n) = O(n log n/ log m), implying (2).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In addition, due to the semantical complexity of certain features, a feature s implementation in one CAD system might result in geometry that is somewhat different from the ge­ometry that a different system generates from the same feature.
Sentence 2: the feature is the same at a certain level of abstraction (usu­ally, overall function as perceived by the user), but different at a detailed geometric level of abstraction.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Particularly noteworthy, an implementation of weak hiding is based on iteratively applying current mechanisms for name binding, noting that binding a scope expression s1 <=| s2 is equivalent to binding s1, followed by binding s2 if unsuccessful.
Sentence 2: bind (ref, (s1 <=| s2)) = bind (ref, s1) ?
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The end-to-end nature of our approach also has positive consequences on the interface between OEM and supplier: because the models can capture cross-cutting aspects of behavior and the corresponding failure management, interface requirements can be shared between OEM and supplier in a much more precise way than what is typical today.
Sentence 2: however, to demonstrate further utility of the proposed model-driven failure management approach we have conducted an experiment in verify­ing that a given implementation meets the stated failure hypothesis; We have applied this experimental setup to the running CLS case study of this paper.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The key observation is that, due to the usage of higher-level design pattern that structure process com­munication and fault recovery, the number of such failure points that needs to be inserted can be relatively few, and can be inserted in an application independent manner.
Sentence 2: the state spaces generated from a failure model can be generated automatically, are relatively small, and are thus amenable to model checking.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: While this approach works, it is cumbersome: we would effectively have to rerun the reason computation once for each such query by the user; speci.cally, once the user knows why s1 is in the slice, she may wish to know why s2 is in the slice, and so on.
Sentence 2: for analyses whose lattice elements are sets, we may wish to associate a reason with each element in the set rather than a single reason for the entire set.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In this paper, we further assume a single-assignment form where the iteration space of each statement exactly corresponds with the data space of the array written by that statement.
Sentence 2: for array references appearing on the left hand side of a statement, the expression indexing the i'th dimension of the array is the index variable of the i'th enclosing loop (this is formalized below).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We choose GPUs because they contain so many cores and some extra complexity regarding the L1 store and global synchro­nization.
Sentence 2: the use of larger ghost zones is es­pecially valuable in the Tesla architecture, because unlike the grid environment where a tile s data may persist in its PE s local memory, data in all PEs local memory has to be .ushed to the globally shared memory and reloaded again after the inter-loop communication.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: By combining the likelihood of mixed­version races with the severity of the resulting errors and inconsistencies which characterizes the impact of potential upgrade failures we estimate the risk of upgrading.We then compare this result with the risk of not upgrading, obtained from the severity of the original bugs or feature requests that are addressed by the upgrade.
Sentence 2: we estimate the expected impacts of the two alternative decisions to upgrade or not to upgrade over the typical time frame of a rolling upgrade.
Relationship: entailment