sadat2307/MSciNLI huggingface dataset:
Domain: Software and its engineering
Sentence 1: During the debugging, by comparing the stack frames printed out in Check and Fail, we discovered that the edges of the node referenced by other in one invocation of mergeNode() may be changed by the statement at line 193 in the recursive invocation of mergeNode() that is called at line 186.
Sentence 2: nn at Figure 7: A behavior view for investigating Bug 2. line 186 must point to the same object as other in the .rst invocation of mergeNode().
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In our exploratory study, we collected information on different kinds of feature interactions, one kind per subject system: Structural interactions in LIN U X: With the help of Jörg Liebig and his code-analysis tool C P P S TAT S [37], we analyzed the nesting structure of C-preprocessor directives in the LI N U X kernel.
Sentence 2: we determined the presence condition of each code block.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: SectionIII-B3 showedthat PMf1 0.9 × PMp.Using thisin equation(3), we obtain (0.4 × PSp +0.6 × PSp) × tp (0.9 × 0.4 × PSp + 0.6 × PSp) × ta > 1 (5) Simplifying equation (5) gives .E = tp 0.96 × ta (6) as the system level energy savings.
Sentence 2: equation (6) speci.es how the application level performance ratio impactsthe systemlevel energy ef.ciency.Figures3(a),(b) and (c) show the percentage performance degradations when Mf1 is used instead of Mp.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: EMFMigrate relies on a language to implement migra­tion libraries.
Sentence 2: each library is related to a given metamodel (e.g., the metamodels of ATL, Ecore, and GMF) and is used in programs consisting of migration rules speci.ed as follows: include {library* } migrate A : MM with Delta { rule mr1 [ guard1 ] {rewritingRule* } rule mr2 [ guard2 ] { rewritingRule* } ... rule mrn [ guardn ] { rewritingRule* } } a migration rule mri is applied on an artifact A conforming to the metamodel MM if the corresponding guardi evaluated on the difference model Delta holds.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Hereafter, we simply say (SN-)binding algebra.
Sentence 2: d in a binding algebra M, the carriers satisfy dMs = M[N]s by speci.c isomorphisms given by bind.The map bind is a key ingredient for the notion of binding in this framework of algebraic semantics, that is, binding is the way of transferring an element of type sto that of type [N]s. This will be clear in the case of C = Set and M = TX which is a term algebra de.ned in Section 3.4.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The theory of such analyses is well under­stood, there exist different styles of describing these analyses and ascribing meaning to them and their interrelationships are clear.
Sentence 2: the different styles can concentrate on the questions of whatmakesavalid analysisofaprogramorhowthe strongest anal­ysis canbe computed,butitisknownhowto relatethetwo aspects and thereisanobviousand technically meaningful analogytovalid Hoare triples and strongest postconditions/weakest preconditions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Before describing how the HashRF algorithm improves on this, we must observe that edit distance between trees (number of modi­.cations to transform one to the other) can be reduced to symmetric set difference between sets of bipartitions.
Sentence 2: each intermedi­ate node of a tree can be seen as partitioning the set of leaves into those below and above the node, respectively.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: CONSEQUENCES FOR RUN-TIME CHECKING The main consequence of the behaviour described above is that it causes run-time checking with jmlrac not to be completely transparent, where transparency means that if no annotation violations are reported (to the user), run­ning a program with run-time checking results in the same behaviour as running the program without run-time check­ing [3].
Sentence 2: both the second and the third example pro­gram in Section 2 will behave di.erently when executed with run-time checking enabled or disabled even though no anno­tation violations are reported (to the user): run-time check­ing will ensure that the method decrypt is not executed, while it will be executed when run-time checking is disabled.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 4.4 Leaves of Refinement The rule of thumb is that refinement is finalized when each leaf invariant of the refinement tree is either an assumption or is associated with a real computation activity a process or knowledge exchange.
Sentence 2: an invariant that is referring to a single component captures only the operational normalcy to be maintained by a process of the component.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The formalization phase consists of the following steps: M2.1 Formalization of each requirement fragment by spec­ifying the corresponding UML concepts and diagrams, and/or the CNL constraints; M2.2 Linking the formal elements introduced in the previ­ous step to the textual requirements; the link is used for requirements traceability of the formalization against the informal textual requirements, and to select di­rectly from the domain requirements document a cat­egorized requirement fragment to be validated.
Sentence 2: in the step M2.1, we adopted classes and class diagrams, to formalize the requirements that have been classi.ed as Glossary, and CNL constraints to specify re­quirements that have been classi.ed as Functional, Prop­erty, and Scenario, and to impose constraints on the class diagrams derived by the Glossary requirements.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: However, the feasibility of complex dynamic analyses is often impaired by the large runtime overhead introduced in the base program, which in some cases can run more than 1000x times slower [13, 14].
Sentence 2: this overhead often stems from frequent execution of .ne-grained analysis tasks that do not produce anyresults on which the execution of the base program depends.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In the case of a di.erent trajec­tory, or user, or even if we reach full capacity of the current candidate node, we follow a right-most policy of node inser­tion.
Sentence 2: we .nd the rightest free child, if it does not exist, we create it and add it as a child to the current parent node.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: BRA uses a memory proportional to 1337 Figure 7: Convergence with 30% of random falls Figure 9: Memory usage with 60% of random falls  Figure 8: Convergence with 60% of random falls the number of nodes in the system.
Sentence 2: the higher num­ber of nodes the system has, the higher memory BRA uses.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This is because in that case, any aliases with v can be destroyed by assignment v = w. The only command that affects the type­state is a method call.
Sentence 2: trans(v.m())(h, t, a) performs a strong update on the incoming type-state t according to the type­state function [m] associated with m, when v is in a, and transitions it to the error type-state otherwise.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We wish not to overly constrain implementations of this protocol, allowing implementors to make trade­o.s to re.ect the needs of their users.
Sentence 2:  the Common Lisp implementation supports this proto­col natively for all sequence types) and an implemen­tation where existing code su.ers no run-time perfor­mance penalty; additionally, we do not wish to render a portable implementation impossible, though we be­lieve that such an implementation would necessarily have visible seams.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: While a SAX-based parser would reduce the time/space spent building the in-memory representation of the XML document, the performance gains may be too small to invest the substantial development time required to re-factor the DAnCE con.guration handlers, which serve as a bridge between the XSC generated code and IDL.
Sentence 2: a SAX-based approach would still require a substantial amount of runtime text-based processing.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The method enjoys the typical benefits of formality, i.e., rigor and precision, both in specification and in verification and the possibility of using powerful tools (e.g., to generate (semi) automatically test cases for the implementation).
Sentence 2: the fact that the semantics of both application specification and architectural design is expressed in terms of logic formulas allows one, at least in principle, to prove the correctness of the design as a typical logical implication.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Building an experimental implementation of the hierarchy with types `a la Danvy and Filinski as presented in this article is another task.
Sentence 2: one can use the syntactic correspondence be­tween context-based reduction semantics and abstract machines [6] to obtain an abstract machine equivalent with the reduction seman­tics of this article, or one could adjust the existing abstract machine for the hierarchy [5] accordingly and prove its correctness with re­spect to the reduction semantics.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The validity condition states that the limit of the state trajectory of each cooperative agent exists and is contained in the interval formed by the initial states of cooperative agents, regardless of the adversaries trajectories.
Sentence 2: if we de.ne the interval I0 =[minxi(0),maxxj (0)], i.Vc j.Vc then the validity condition is formulated as lim xi(t).I0, .i.Vc,xa(t).C.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Comebacks For each supported refactoring we formally de.ne a comeback a behavior-preserving transformation, which de.nes how a compensating adapter is constructed.
Sentence 2: we create an adaptation-oriented pattern problem­solution library of transformations, where a problem pattern is the occurrence of a component refactoring and its solution Refactoring History Generator F3 AL1 AL2 P1P2 P3 time Figure 1: Refactoring-based plugin adaptation.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In this paper, we collate and classify techniques for pro­gramming with dependent types in Haskell, and contribute some new ones.
Sentence 2: through extended examples merge-sort and rectangular tilings we show how to exploit Haskell s con­straint solver as a theorem prover, delivering code which, as Agda programmers, we envy.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This execution includes some anomalous requests generated syntheti­cally following the pattern of SQL-injection attacks, which may enable the attackers to bypass authentication and extract sensitive data [3, 18].
Sentence 2: a tautology-based attack is to inject code in one or more SQL conditional statements so that they always evaluate to true (or they are effectively removed from conjunctive conditions).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Di.erent from previous work, our solu­tion is fully distributed and self-organizing without requiring specialized servers or IP multicast support.
Sentence 2: we decouple the stream processing in MVoIP services into two phases: (1) aggregation phase that mixes audio streams from active speakers into a single stream; and (2) distribu­tion phase that distributes the mixed audio stream to all listeners.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Building on the same principles, a generic genotypic Uni­versal Information Distance (UID) for individuals in LGP is proposed.
Sentence 2: considering two individuals Ii and Ij , the UID is de.ned as U I D(Ii, Ij ) = |S(Ii) D S(Ij )| (4) where S(I) represents the set of symbols in individual I, D is the symmetric di.erence as de.ned in Equation 1, and the operator |S| denotes the cardinality of set S. the UID between two individuals is the number of distinct symbols they do not have in common.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The .rst is roulette se­lection [31], a .tness-proportionate selection strategy which assigns a selection probability to each ordering based on its coverage e.ectiveness score.
Sentence 2: the framework contains a regular roulette selection operator (ROU), an ex­ponential transformation operator in which the square root is taken of each .tness value (ROUE), and a linear ranking  Operator Type Abbreviation Full Name Mutation [12] DM EM ISM IVM SIM SM Displacement mutation Exchange Insertion Inversion Simple inversion Scramble Crossover [12] CX MPX OX1 OX2 PMX POS VR Cycle Maximal preservative Order Order-based Partially-mapped Position-based Voting recombination Selection ROU TRU TOU Roulette [31] Truncation [15] Tournament [20, 31] Transformation (Roulette only) ROUE ROUL Exponential [13] Linear ranking [13] Figure 5: Genetic Algorithm Operators.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Formally, latent semantic analysis seeks d orthogonal di­rections in the vector space that capture as much of the variance inside the data as possible.
Sentence 2: one technical way to obtain these d directions is by performing a singular value decomposition (SVD) of the matrix M.M is de­composed into three matrices U,Sand V as follows M US VT = .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 7 Thanks to the constitution function, the system is able to retrieve the traits that make up an object for any given set of active contexts.
Sentence 2: note that the constitution function is not necessarily inject­ive, meaning that two di.erent contexts C1 and C2 can have a same associated trait T(l,C1) = T(l,C2) for a given object l, and also that two di.erent objects l1 and l2 can have the same trait T(l1,C) = T(l2,C) for a given context C. a same trait can be reused as adaptation in di.erent contexts and for di.erent objects.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Crucially, our placement also satis.es the following prop­erty: when uniform slot service assignment is used, all re­quests are satis.ed w.h.p.
Sentence 2: our placement is such that (5) and (6) are not only necessary but also suf­.cient for (4) to hold (c.f.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The result can be used portably across all architectures supporting a CAS-like prim­itive, and thus signi.cantly extends the kinds of operation that can be safely performed in contexts such as user-level signal handlers, where a lock-based solution is not safe.
Sentence 2: 15the CAS operation in the push function must have release semantics, forcing all prior memory operations to become visible before it.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: With this interpretation of inv, our proof obligation for the correctness of compiling statement s is: for any continuation statement k, if we know invpkq is a valid speci.cation for the compilation of k, can we establish that invps; kq is a valid speci.cation for the compilation of s; k?
Sentence 2: abusing the Hoare­triple notation, the proof obligation is: compileps, kq c tinvps; kqu c tinvpkqu the job of a statement s is to take us from a state where we must run s; k before returning, to a state where we only need to run k before returning.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Additional bene.ts include the fact that, having a formal FD opens the way for au­tomated queries and reasoning on the change speci.cation through the use of an FD tool such as FAMA [7] or the one described in [17].
Sentence 2: this allows a safe and e.­cient integration of change-based FOP with those tools.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This forces ParaMEDIC to use algorithms that can gener­ate metadatafrom the result and re-generate the resultfrom the metadata with minimal processing requirements.
Sentence 2: for most applications, the framework ensures that the post-processing cost required to process the metadata and generatethe .nal outputissigni.cantly lessthantheactual computation needed by the application.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The macro debugger does not show the expansion of any opaque macros, but if an occurrence of a macro has subexpressions, it does display the expansions of those subexpressions in the context of the original macro form.
Sentence 2: hiding a macro effectively removes its rewriting rules and adds ex­pansion contexts, as if it were truly a primitive of the language.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The integrity and maintainability stereotypes, although not ex­plicitly shown in Figure 6, are characterized by similar complex NFP attributes.
Sentence 2: the integrity stereotype has an at­tribute of type Error that supports the speci.cation of communica­tion errors (guideline-4)and the maintainability stereotype has an attribute of type Repair to be used for the characterization of the repair process (guideline-2).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: $10.00 David Sands Department of Computer Science and Engineering, Chalmers University of Technology, Sweden dave@chalmers.se many similarities between problems that arise in the access con­trol and information .ow control domains.
Sentence 2: problems regarding policy speci.cation and modelling of principal actors are quite similar, much due to the fact that these issues are not purely technical, but rather relate to the interface between the system and its users (implementor, admins).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: A concept interface, that is, an interface with member types that have not been bound to concrete types, can only be used as type parameters subtype constraints, or as a base interface of another interface or class.
Sentence 2: one can­not declare a variable, function parameter, or a .eld of such a type, nor use it as a type argument to a generic method or type.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: template  struct graph traits {Inside the breadth .rst search function, calls to functions asso-typedef int vertex; ciated with the concepts, such as out edges from Incidence Graph, typedef pair edge; typedef list::const iterator out edge iter; are resolved by the usual function overloading rules for C++.
Sentence 2: ... each is resolved to the best overload for the given argument types.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: If he continues in this manner, (t =(CT )n ci), he will have a complete view of the network after n = large iterations (under the assumptions that C is irreducible and aperiodic, which we guarantee in practice and address in Sec­tion 4.5).
Sentence 2: fortunately, if n is large, the trust vector tpi will converge to the same vector for every peer i. Namely, it will converge to the left principal eigenvector of C. pt is a global trust vector in this model.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Second, while one requirement shock was introduced in previous semester, we felt that having only one shock could not really propel the students to design their systems to be agile and flexible to changes.
Sentence 2: according to our observations, most students still suffered from the tendency to design their systems in a tightly coupled manner and they were less likely to structure their systems using the component-based approach, which has been hailed as a way to significantly lower the barriers for reuse of pre-built self-contained functional blocks and amendment of the system architecture to cater to future changes in requirements [16].
Relationship: entailment
Domain: Software and its engineering
Sentence 1: As we argued in Section 2, we be­lieve that DHTs, while more ef.cient at many tasks, are not well suited for mass-market .le sharing.
Sentence 2: their ability to .nd needles, i.e., exceedingly rare .les, is not needed in a mass­market .le-sharing environment, while their ability to ef.ciently im­plement keyword search, which is crucial for this application, is still unproven.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We propose a novel ranging algorithm that executes q-range estimation and localization in an interleaved and iterative manner.
Sentence 2: feedback from the current localization re­sult is used to constrain the search space of q-range estima­tion, then the new estimates are used in the next localization phase, thereby iteratively re.ning the result.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We demon­strate that the knapsack scheduler is highly con.gurable, presents examples and methodology for tuning the alloca­tion policies, and discuss speci.c results and conclude with recommended deployment practises.
Sentence 2: we ex­plore the e.ects of varying the strengths of an external user­speci.ed monetary metric, an intrinsic estimated response time mediated by nearness to completion time metric, and of varying the shape of a sigmoidal normalizing utility func­tion.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Box interface x extends box interface y if and only if interface handle (x) = interface handle(y), type (x) extends type(y) in Java, and x is a behavioral subtype of y [5].
Sentence 2: the provided interfaces of B should provide at least the operations of A, and the required interfaces of B should be at most as much as that of A.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Sistemas Inform´on, Universidad Complutense de Madrid aticos y Computaci ´ fraguas@sip.ucm.es jrodrigu@fdi.ucm.es jaime@sip.ucm.es Abstract Non-con.uent and non-terminating rewrite systems are interest­ing from the point of view of programming.
Sentence 2: exist­ing functional logic languages use such kind of rewrite systems to de.ne possibly non-strict non-deterministic functions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: (Partial) An imperative implementation, written in Java, of a representation invariant for red-black trees.
Sentence 2: by using information obtained while solving declarative portions of the invariant we are able to help prune the search for partially valid structures from the imperative portion of the speci.cation; and having a declarative invari­ant allows for querying characteristics of the valid structures that lead to reductions in the search space when solving the // empty tree has size 0 (thiz.root = null => thiz.size = 0) and // root is black (thiz.root != null => thiz.root.color = BLACK) and // tree structure is ok (this.root != null => thiz.root.parent = null) and all n:TreeSetNode | { n in thiz.root.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Mobile code is theability to move executable code across the network, on demand, tothe place it is needed, where it is executed securely and reliably.The power of mobile code is in its ability to extend the behavior ofentities on the network dynamically.
Sentence 2: part of theagreement that must occur between two interacting entities movesfrom development time to run time.
Relationship: entailment