sadat2307/MSciNLI huggingface dataset:
Domain: Software and its engineering
Sentence 1: Afterinserting thesetwo .lters,thetotal numberoffalse positives reported was 27.Of these, 22 are related to unex­pectedinteractionsbetween theframeworkand the applica­tion.
Sentence 2: some requests took a longer amount of time to complete, which in turn caused an execution time­outin ourframeworkto expire.In other casesfalsepositives were caused by non-determinism in the reply that we had not caught(e.g., calls tothe currenttime or random num­ber generation).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Then SummaryEFopt(1, u, v) holds if and only if u is an entry of a proce­dure that is reachable in P and v is a state in the same procedure reachable from the entry u using a run that returns from all calls.
Sentence 2: summaryEFopt(1, u, v) holds when u is an entry of main iff v is a state of main that is reachable in P .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Understanding Java involves a somewhat different set of issues than we had been addressing.
Sentence 2: our previous efforts had not tackled the problem of multithreaded computations (the lack of a standard threading model for C++ made this difficult), and they paid a lot of attention to memory allocations; our work for Java has emphasized threading and takes a very different view of how memory is uti- lized.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: A comprehensive review for search-based software engineering (SBSE) is available in [5], where search techniques are well described with applications to a variety of software engineering problems.
Sentence 2: harman listed a set of potential objectives used for multi-objective test optimization in regression testing [29], which have been studied in the existing literature (e.g., execution time and fault detection capability) [20].
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Fromtheselines,itisclearthatthe TC+Otechnique outperforms all other techniques.
Sentence 2: note that, for any percentage n between 0% and 100%, TC+O localizes more faults than any of the other algorithms when up to n% of all statements are examinedindecreasing order of suspiciousness.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Therefore, we must maximize CRR, but without generating too many clusters.
Sentence 2: based on this recommendation, a simple rule of thumb to determine the value of k is the following: (a) run the clustering algorithm with several values of k; (b) plot the respective CRR values, which will result in a monotonically increasing function towards the value 1; (c) supposing the last signi.cant rise in this graph happens from k - 1 to k, the recommended value for the number of clusters is k. after this value, increasing k will not result in signi.cant gains in terms of CRR [16].
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 2.2 Re.nement of design The re.nement relation between designs with the same alpha­ def bet is de.ned as logical implication.
Sentence 2: let D1 = p1 f R1 and def D2 = p2 f R2betwodesignsover the alphabet a, D2 isa re.nement of D1, denoted by D1 .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The object type p is < g e t : f l o a t , m o v e : f l o a t -> u n i t > and the object type ap is < g e t : f l o a t , o f f s e t : i n t , m o v e : i n t -> u n i t > OCaml uses structural subtyping to relate object types.
Sentence 2: an object type s is a subtype of an object type t iff (1) s has all the methods of t and (2) for each method m of t, the type of m in s is a subtype of the type of m in t. Method subtyping is de.ned as expected.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In contrast, we share base code elements that are wrapped by a feature implementation using passages and introduce al­ternative paths in the AST using passages and their guards.
Sentence 2: a passage with corresponding passage guards is always introduced at the beginning of such a wrapper (al­ternative paths), while a passage that merely shares an AST element (or introduces additional alternative paths) is al­ways introduced at the end of the wrapper.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Given a set of forbidden tuples F , a given t-set encoded as a boolean formula, s, is F -consistent if ^ ^ ( ft) .
Sentence 2: ( .f ) .. s t.F f.F act if the conjunction of forbidden tuples and the at least con­straints do not imply a t-set, then it is F -consistent.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The SLP-CF versions of Chroma, Sobel,and EPIC-unquantizeall effectively exploit the parallelism available in these kernels, yielding speedups of more than 6.21X.
Sentence 2: the 15.07 speedup on Chroma is because the data type size of the operands is 8 bits, which results in 16 operations on 8-bit objects per super­word operation.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The owned assignments are executed while the rest of them are simply skipped.
Sentence 2: the reduction/s in the f A init next f A A init n~xt i~t t2 A p i-, (a) (b) Figure 2: Graphical depiction for the irregular data access to the reduction array (a), and the write data affinity-based access to it by usin9 the loop-index prefetchin9 data struc- ture (~ threads are assumed) (b) histogram loop is (are) guarded by a conditional.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: For example, within the same class C, one .eld may save most from bit-width reduction, another .eld may save most from dominant-value hashing.
Sentence 2: the maximal hybrid uses the technique that saves the maximum amount of memory for each particular .eld f of class C. Savings are: maxFieldSavings(C) = max savings(C, f, o) o.FieldOpts f.Fields(C) we sum the savings from each .eld f when us­ing the optimization o with maximum savings for that .eld.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: TDE/UML supports the generation of test cases based on UML models such as Activity and Sequence diagrams.
Sentence 2: it supports: 1) model design and importing; 2) model verification based on a set of extensible rules; 3) test generation, where a set of abstract test procedures and steps are created; and 4) code generation, where language­specific plug-ins are used to convert the abstract test model into executable code.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We carried out the study reported here in the framework of the QualiPSo project [3], which is funded by the European Union in the 6th Framework Program.
Sentence 2: qualiPSo involved the collection of a large amount of subjective user evaluations of OSS products qualities, the measurement of the code of such products, and the analysis of the collected data.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In our case studies, for example, the co-change graphs have densities ranging from 2% (Geronimo and Lucene) to 4% (Eclipse JDT Core).
Sentence 2: in traditional clustering algo­rithms, like K-Means [22], the mapping of data items to clusters is a total function, i.e., each data item is allocated to a speci.c cluster.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: While we do not claim that API is the only additional factor needed to improve contention management, we Figure 2: Normalized performance (MPI, API, IPC, and running-time) of use it to demonstrate thatFACT can be effectively used for model­ mcf with different co-runners Based on this observation, researchers proposed schedulers that separate memory-intensive threads on different core groups[4,5, 6, 25].
Sentence 2: these schedulers combine threads in a way that minimizes total contention.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In bag patterns, the stricter rule that all children are disjoint suf­.ces even in the face of star patterns.
Sentence 2: for example, the pattern #readings[*#info(#temp[int]), *#info(#humidity[int])] is not legal, because the children of #readings overlap on values of type #info(#temp[int],#humidity[int]) if the #readings tree begins with a child with the above type, it is unclear whether this child should be matched against *#info(#id[int]), or instead against #info(#temp[int]).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: One last, not very well documented, detail is that when a process terminates due to an exception, and the exception was not caused by a call to exit(Term), this event will be reported by the Erlang runtime system to the error logger service.
Sentence 2: (as long as a process terminates normally, or through a call to exit, it is considered a normal event from the runtime system s point of view.)
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We require that each constraint is in quadratic form (§4).
Sentence 2: constraint j has the form pj,A(W)·pj,B(W) = pj,C(W), where pj,A, pj,B, and pj,C are degree-1 polynomials over W. Now, for variable Wi (which will be a member of X, Y, or Z), let ai,j be the coef.cient of Wi in pj,A.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: A concept is a set of requirements on a type or group of types.
Sentence 2: concepts can in general be treated as ar­bitrary containers of requirements;this paper adds two new kinds of requirements into concepts, as is shown in Section 3.1.Atype (or group of types) is said to model a concept when it satis.es the requirementsin the concept.Ageneric algorithmisa function that can operateonavarietyoftypes.itis parametrically polymorphic: it has slots for input types, and these type parame­ters are used within the function.Forexample,a generic algorithm sum that computes the sum of a sequence of objects using iterators might have one type parameter Iterator, and two parameters begin and end of type Iterator: template  requires InputIterator // and more InputIterator::value type sum(Iterator begin, Iterator end) { InputIterator::value type s = 0; for (; begin != end; ++begin) { s += *begin; } return s; } Not all types can be used in generic functions, though; thus, con­cepts are used to constrain the input types.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The issues include how a developer starts from a novice and becomes an expert, how she grows her expertise, and what kind of expertise she has to master (and in what order) to become central [29].
Sentence 2: it s interesting to investigate how developers proceed from the role of a newcomer to the role of a core team member in the OSS projects, since there is an absence of a hierarchical organization, training plan, and a centralized environment for people to be nurtured.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: For example under the following program class D{int f; D(int f){this.f=f;}} class C{D f; C(D f){this.f=f;}} we can write the following expression: C x=new C(new D(80)); C y=x; x.f=new D(y.f.f+8); y.f 1An interesting exception is [16], see Section 6.
Sentence 2: 2the execution model of most languages rely on concepts that are absent from the source code itself, often called run-time expressions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: During our experiments, we measured noticeabledi.erencesfor thequality of the .nal results,depending ontheordering inwhich a.nities with equal weights are considered.
Sentence 2: we ver­i.ed that guiding this ordering, using for example the program structure and simple considerations such as a lexicographic order, provides better results in average.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In order to successfully evolve large-scale sys­tems it is essential to understand their architecture before delving into details of the implementation, which is a time and e.ort consuming activity.
Sentence 2: large amounts of data (e.g., several millions lines of code) have to be anal­ysed and abstracted to an architectural level and important information is often hidden among irrelevant data.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: An extension that required all this to be re-engineered would be a non­starter, and it is here that the simplicity of our GADT inference algorithm pays off.
Sentence 2: we have successfully extended GHC to support both GADTs and impredicative polymorphism (described in a companion paper in this volume [22]), without undesirable interactions with each other, or with existing features.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Nevertheless this is not enough, in fact compounds with putative pharmacological value have not only to show a good target binding, but also have to reach the target in vivo.
Sentence 2: it is necessary that compounds follow the appropriate way into the human body 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: For example, t7 involves L = (1, 2, 3, 4, 5, 6) in the body of serach, whereas t6 in­volves L = (1, 2, 1, 2) which is of the same length as L in t2.
Sentence 2: the basis of Convergence Debugging is that looking at the di.erences between the test cases in T " is better for isolating the fault in search than T "" .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 3.3.1 Step I: Decoupling the Commonalities from theVariabilities In GReAT, we supported the constraint speci.cation notation by exploiting the C++ code embedding feature (see Attribute Mapping block feature in Figure 5).
Sentence 2: we use C++ comments within the embedded code as a means to capture variability.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: It would also be helpful to have already seen a .-interpreter written in a functional lan­guage [20, 31, 35, 39].
Sentence 2: we make use of Strachey s notions of expressible values, i.e., the values obtained by evaluat­ing an expression, and denotable values, i.e., the values denoted by identi.ers [38].
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We represent the input sentence and productions as tables in i3QL: val sentence : Table[Token] val terminals : Table[Terminal] val rules : Table[Rule]  Users can add, remove, and update any of the three tables.
Sentence 2: they can trigger updates for changes to the input sentence: sentence += Token( ideas , 5) sentence.update(Token( sleep , 3), Token( green , 3)) sentence -= Token( colorless , 0)  5.2 Chart Parsing Before we de.ne the incremental parser, we brie.y describe chart parsing [21], which is the underlying approach our parser uses.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Hence, compiler optimizers work with suf.cient conditions such as that of non-negative depen­dence components: this was from the pioneering works of Irigoin and Triolet [17] and a large amount of literature on the validity of tiling relates to or derives from it [37, 25, 20, 1, 5].
Sentence 2: the condition involves checking if all components corresponding to (yet unsatis.ed) dependences are non-negative for the set of con­tiguous loop nest dimensions that are being tiled.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Because the compiler optimizations targeting these two patterns have different objectives and requirements, we have designed two distinct cache structures that best respond to these distinct access patterns and optimization requirements.
Sentence 2: our design includes: (1) a high-locality cache with a variable configuration, lines that can be pinned, and a sophisticated eager write-back mechanism; and (2) a transaction cache with fast, fully associative lookup, short lines, and an efficient write-through policy.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Static AOP mechanism: Although AOP mechanism similar to the inter-type declarations in AspectJ would be useful, they should be carefully designed because functional programs usually rep­resent structured data by using variant types, whereas object­oriented programs do by using classes.
Sentence 2: the inter­type declarations in AspectJ relies on the type compatibility of classes with additional instance variables and methods, which is not guaranteed for the variant types.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We demonstrate the performance and scalability of this scheme by applying it to startup Charm++ appli­cations.
Sentence 2: starting up a Charm++ program on 16,384 cores ofRanger(atTACC) withEthernet as the un­derlying communication layer takes only 25 seconds and at­tains a speedup of over 400% compared to MPICH2 startup (using hydra as process manager) and over 800% compared to Open MPI startup on Ranger.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The block distance between two accesses ax and ay, where t(ay) < t(ax), is the number of distinct memory blocks that can be mapped to the same set of cache blocks as x and accessed during time period [t(ay),t(ax)-1].
Sentence 2: when t(ay) = t(a-), x dis(ay, ax) is referred to as the block reuse distance of ax.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Although there are large amount of work on embeddings for various topologies, we found relatively few techniques for ef.cient/scalable embeddings among three-dimensional grids/tori.
Sentence 2: techniques based on graph­partitioning and/or searching would .nd fairly good embed­dings for different topologies, they are hard to be parallelized and scalable [12; 20; 6].
Relationship: entailment
Domain: Software and its engineering
Sentence 1: message-oriented model of concurrency.
Sentence 2: being [12] J. M. Hellerstein, M. J. Franklin, S. Chandrasekaran, able to customize the scheduler such that it can take account A. Deshpande, K. Hildrum, S. Madden, V. Raman, of synopses of the content of messages allows the application and M. A. Shah.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Using multiple constraints, the requirements for the G parameter could be written as:         G.{VERTEX LIST GRAPH[V]; INCIDENCE GRAPH[V, E]}  7.2.2 Static Type Safety  Eiffel has been criticized for type-safety problems [8, 12].
Sentence 2: type conformance checking is based on the subclass re­lation, which allows instance variables and parameters of routines to change covariantly.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Implementation This section describes the non-trivial elements of our implementation.
Sentence 2: it includes information on ñ The simulation defining interfaces ñ The hardware model ñ Test script highlights ñ The regression framework ñ Changes in the system software  5.1 Simulation Defining Interfaces The real product architecture can be abstracted as shown in Figure 3: Figure 3: Components of the real system The controller s machine state is the combination of the hardware states (including location and status), the contents of the ODM, and the contents of the RMC objects.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: While this is reasonably easy for a human to eyeball, thevaluenumbererhas nochanceofdiscoveringthis unless the expressions are shaped so that the subexpressions become apparent.
Sentence 2: the algorithm must reshape the operators so that redundancies are explicit in the AST: (+ (*X (+ (+ABC I)H H))) (*Y (+ (+ABC I) (+ABC I) (+DEF G))) (*Z (+ (+DEF G) (+DEF G))) In this way, the redundancies can now be easily discovered by the value numberer.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: If H1 and H2 are heaps, then H2 has more aliasing if it identi.es locations that are distinct in H1 and merges the contents of the objects in these locations.
Sentence 2: if o ' and o '' are distinct objects in H1 which are merged to object o in H2,then o has all properties from o ' and o '' .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Figure 1 Example: a large block case 2.2 New Features in Large Block Flash Memory 2.2.1 Multiple Sector Read and Write Differently from small block flash memory, the basic chunk of read/write in large block flash memory is larger than the data sector size used in the file system.
Sentence 2: large block flash devices physically read and write data in chunks of 1~4 Kbytes.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We then had a named entity that Eclipse could usetobuilda listof entity references.
Sentence 2: we re­viewed this list to determine if anyof those uses of contains were puns: checks for the presence of dots that had nothing to do with quali.ed names one reasonable case would be when the Strings represented numbers,andthe checkwouldbe better written as isFloatingPoint(t).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We tested the performance impact of our extensions within the Xen hy­pervisor by creating a benchmarking program that accesses context sults indicate that our modi.cations incur only a slight performance penalty over programs running on unmodi.ed guest operating sys­tems in the normal case.
Sentence 2: we see that the technique scales well in the number of context sensitive pages within a pro­gram, even in pathological cases such as interleaved data and exe­cution accesses.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Templates are used to generate the UI views and the navigational bars that allow users to visit the application contents.
Sentence 2: « IMPORT data » « DEFINE Root FOR ServiceModel » « EXPAND EmitEntities FOR this » « EXPAND DAOUtilityClass FOR this » « EXPAND TypeConverters FOR this » « EXPAND PersistenceManager FOR this » « ENDDEFINE » « DEFINE EmitEntities FOR Root » « FOREACH this.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: As we have seen, the HS interpretation elaborates datatype declarations as opaquely sealed structures; datatype speci.cations are translated into speci.cations of structures.
Sentence 2: for example, the signature signature S = sig datatype intlist = Nil | Cons of int * intlist end contains a datatype speci.cation, and elaborates as follows: signature S = sig struct Intlist : sig type intlist val intlist in : unit + int * intlist -> intlist val intlist out : intlist -> unit + int * intlist end end A structure M will match S if M contains a structure Intlist of the appropriate signature.1 it is clear that the struc­ture de.nition produced by the HS interpretation for the datatype intlist de.ned in Section 1 has this signature, so that datatype declaration matches the speci.cation above.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Even if the receiver has no previous trust in one or more entities in the chain or no knowledge of their public keys, it can verify that they have limited transitive trust to manage the resources for speci.ed time intervals.
Sentence 2: the site authority can verify its own limited transitive trust in the ticket holder to control the resources named in the ticket without contacting the agent that issued it.
Relationship: entailment