MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                        | authors   | venue   |   year |
|:---------------------------------------------|:----------|:--------|-------:|
| foreword : management of semistructured data |           |         |   1997 |

Entity B:
| title                                                                    | authors                 | venue   | year   |
|:-------------------------------------------------------------------------|:------------------------|:--------|:-------|
| resilient logical structures for efficient management of replicated data | d agrawal , a el abbadi |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 528
rtable_id: 2030
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                       | authors                 | venue         |   year |
|:----------------------------------------------------------------------------|:------------------------|:--------------|-------:|
| extraction of object-oriented structures from existing relational databases | s ramanathan , j hodges | sigmod record |   1997 |

Entity B:
| title                                                           | authors   | venue               |   year |
|:----------------------------------------------------------------|:----------|:--------------------|-------:|
| static detection of security flaws in object-oriented databases | k tajima  | sigmod conference , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 563
rtable_id: 2706
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                             | authors                                   | venue         |   year |
|:--------------------------------------------------|:------------------------------------------|:--------------|-------:|
| implementation aspects of an object-oriented dbms | a dogac , m altinel , c ozkan , i durusoy | sigmod record |   1995 |

Entity B:
| title                                                         | authors                        | venue                       |   year |
|:--------------------------------------------------------------|:-------------------------------|:----------------------------|-------:|
| an object-oriented approach to database system implementation | a james baroody jr , dj dewitt | acm trans . database syst , |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 773
rtable_id: 28305
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                     | authors                              | venue         |   year |
|:------------------------------------------|:-------------------------------------|:--------------|-------:|
| infering structure in semistructured data | s nestorov , s abiteboul , r motwani | sigmod record |   1997 |

Entity B:
| title                                                          | authors                            | venue                                                                  |   year |
|:---------------------------------------------------------------|:-----------------------------------|:-----------------------------------------------------------------------|-------:|
| capturing and querying multiple aspects of semistructured data | ce dyreson , mh bohlen , cs jensen | proceedings of the international conference on very large & hellip ; , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 519
rtable_id: 17415
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                        | authors                                                                             | venue             |   year |
|:---------------------------------------------|:------------------------------------------------------------------------------------|:------------------|-------:|
| the ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j chaudhary , g karvelis , s sou | sigmod conference |   1994 |

Entity B:
| title                                                         | authors                                                | venue                   | year   |
|:--------------------------------------------------------------|:-------------------------------------------------------|:------------------------|:-------|
| access path selectwn ma relational database management system | pg sehnger , mm astrahan , dd chamberhn , ra lone , tg | proceedmgs acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1840
rtable_id: 41278
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                    | authors       | venue         |   year |
|:-------------------------------------------------------------------------|:--------------|:--------------|-------:|
| incremental maintenance of recursive views using relational calculus/sql | g dong , j su | sigmod record |   2000 |

Entity B:
| title                                                         | authors     | venue                                 |   year |
|:--------------------------------------------------------------|:------------|:--------------------------------------|-------:|
| incremental view maintenance in extended relational databases | jv harrison | information and software technology , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 272
rtable_id: 21056
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                 | authors                                                  | venue         |   year |
|:--------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| the microsoft database research group | d lomet , r barga , s chaudhuri , p larson , v narasayya | sigmod record |   1998 |

Entity B:
| title                                 | authors                         | venue           |   year |
|:--------------------------------------|:--------------------------------|:----------------|-------:|
| the microsoft database research group | d lomet , r barga , s chaudhuri | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 600
rtable_id: 28335
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                            | authors   | venue   |   year |
|:-------------------------------------------------|:----------|:--------|-------:|
| index configuration in object-oriented databases | e bertino | vldb j. |   1994 |

Entity B:
| title                                                         | authors   | venue   | year   |
|:--------------------------------------------------------------|:----------|:--------|:-------|
| query evaluation in deductive and object-oriented databases . | z xie     |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2564
rtable_id: 43278
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title           | authors   | venue         |   year |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | l liu     | sigmod record |   2002 |

Entity B:
| title           | authors       | venue                                      |   year |
|:----------------|:--------------|:-------------------------------------------|-------:|
| editor 's notes | sm richardson | new directions for teaching and learning , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 115
rtable_id: 25469
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                       | authors                               | venue   |   year |
|:------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| the design and implementation of a sequence database system | p seshadri , m livny , r ramakrishnan | vldb    |   1996 |

Entity B:
| title                                                      | authors                                     | venue                                                                      | year   |
|:-----------------------------------------------------------|:--------------------------------------------|:---------------------------------------------------------------------------|:-------|
| implementation techniques for main memory database systems | djdwrhkf olken , ldsmr stonebraker , d wood | i > proc . 1984 acm sigmod int &#39; l conf . management of data , < / i , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1826
rtable_id: 53772
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                             | authors   | venue   |   year |
|:----------------------------------|:----------|:--------|-------:|
| concurrency in the data warehouse | r taylor  | vldb    |   2000 |

Entity B:
| title                        | authors                            | venue                                                                  |   year |
|:-----------------------------|:-----------------------------------|:-----------------------------------------------------------------------|-------:|
| expiring data in a warehouse | h garcia-molina , w labio , j yang | proceedings of the international conference on very large & hellip ; , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1400
rtable_id: 3418
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                            | authors                            | venue   |   year |
|:-----------------------------------------------------------------|:-----------------------------------|:--------|-------:|
| managing multiple and distributed ontologies on the semantic web | a maedche , b motik , l stojanovic | vldb j. |   2003 |

Entity B:
| title                                                                        | authors                                | venue   | year   |
|:-----------------------------------------------------------------------------|:---------------------------------------|:--------|:-------|
| mafraâ ?? a mapping framework for distributed ontologies in the semantic web | a maedche , b motik , n silva , r volz |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2292
rtable_id: 56917
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                              | authors                      | venue   |   year |
|:-------------------------------------------------------------------|:-----------------------------|:--------|-------:|
| multi-dimensional database allocation for parallel data warehouses | t stіhr , h mфrtens , e rahm | vldb    |   2000 |

Entity B:
| title                                                    | authors           | venue   |   year |
|:---------------------------------------------------------|:------------------|:--------|-------:|
| warlock : a data allocation tool for parallel warehouses | t stoehr , e rahm | vldb ,  |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1369
rtable_id: 57211
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                | authors                                       | venue             |   year |
|:-----------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| staggered striping in multimedia information systems | s berson , s ghandeharizadeh , r muntz , x ju | sigmod conference |   1994 |

Entity B:
| title                       | authors                    | venue                   | year   |
|:----------------------------|:---------------------------|:------------------------|:-------|
| banking information systems | v shmerko , s yanushkevich | technical university of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1760
rtable_id: 22411
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                     | authors                           | venue         |   year |
|:----------------------------------------------------------|:----------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | s son , r david , b thuraisingham | sigmod record |   1996 |

Entity B:
| title                                                                   | authors          | venue               |   year |
|:------------------------------------------------------------------------|:-----------------|:--------------------|-------:|
| locking protocols for concurrency control in real-time database systems | sl hung , ky lam | acm sigmod record , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 682
rtable_id: 35088
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                | authors           | venue             |   year |
|:-------------------------------------|:------------------|:------------------|-------:|
| association rules over interval data | r miller , y yang | sigmod conference |   1997 |

Entity B:
| title                                        | authors   | venue   |   year |
|:---------------------------------------------|:----------|:--------|-------:|
| yangy . association rules over interval data | rj miller |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1313
rtable_id: 51231
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                     | authors                           | venue         |   year |
|:----------------------------------------------------------|:----------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | s son , r david , b thuraisingham | sigmod record |   1996 |

Entity B:
| title                                           | authors              | venue           |   year |
|:------------------------------------------------|:---------------------|:----------------|-------:|
| advances in real-time database systems research | sigmod record , 1996 | sigmod record , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 682
rtable_id: 9709
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | authors                     | venue             |   year |
|:------------------------------------------------|:----------------------------|:------------------|-------:|
| adapting materialized views after redefinitions | a gupta , i mumick , k ross | sigmod conference |   1995 |

Entity B:
| title                                      | authors                       | venue                       | year   |
|:-------------------------------------------|:------------------------------|:----------------------------|:-------|
| adapting materialized views after renition | a gupta , is mumick , ka ross | proceedings of acm-sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1539
rtable_id: 41701
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | authors               | venue   |   year |
|:------------------------------------------------|:----------------------|:--------|-------:|
| indexing of now-relative spatio-bitemporal data | s saltenis , c jensen | vldb j. |   2002 |

Entity B:
| title                                                 | authors                                            | venue   |   year |
|:------------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| r-tree based indexing of now-relative bitemporal data | r bliujute , cs jensen , s saltenis , g slivinskas | vldb ,  |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2451
rtable_id: 38990
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                 | authors                                   | venue         |   year |
|:----------------------------------------------------------------------|:------------------------------------------|:--------------|-------:|
| a distributed scientific data archive using the web , xml and sql/med | m papiani , j wason , a dunlop , d nicole | sigmod record |   1999 |

Entity B:
| title                                                                 | authors                | venue   | year   |
|:----------------------------------------------------------------------|:-----------------------|:--------|:-------|
| authenticating distributed data using web services and xml signatures | dj polivy , r tamassia |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 494
rtable_id: 32124
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                          | authors                | venue             |   year |
|:---------------------------------------------------------------|:-----------------------|:------------------|-------:|
| an effective hash based algorithm for mining association rules | j park , m chen , p yu | sigmod conference |   1995 |

Entity B:
| title                                                             | authors             | venue   | year   |
|:------------------------------------------------------------------|:--------------------|:--------|:-------|
| set-oriented mining for association rules in relational databases | m houtsma , a swami |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1543
rtable_id: 47315
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                              | authors                                        | venue             |   year |
|:-------------------------------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| the design of an acquisitional query processor for sensor networks | s madden , m franklin , j hellerstein , w hong | sigmod conference |   2003 |

Entity B:
| title                               | authors             | venue   | year   |
|:------------------------------------|:--------------------|:--------|:-------|
| query processing in sensor networks | j gehrke , s madden |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 367
rtable_id: 2845
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                | authors                          | venue   |   year |
|:---------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| querying heterogeneous information sources using source descriptions | a levy , a rajaraman , j ordille | vldb    |   1996 |

Entity B:
| title                                                           | authors                          | venue                                                                  |   year |
|:----------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|-------:|
| quality-driven integration of heterogeneous information systems | f naumann , u leser , jc freytag | proceedings of the international conference on very large & hellip ; , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2581
rtable_id: 20740
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                   | authors               | venue         |   year |
|:----------------------------------------|:----------------------|:--------------|-------:|
| managing uncertainty in sensor database | r cheng , s prabhakar | sigmod record |   2003 |

Entity B:
| title                                                   | authors                                            | venue                               |   year |
|:--------------------------------------------------------|:---------------------------------------------------|:------------------------------------|-------:|
| the geometry of uncertainty in moving objects databases | g trajcevski , o wolfson , f zhang , s chamberlain | lecture notes in computer science , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1885
rtable_id: 60676
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                               | authors                               | venue   |   year |
|:----------------------------------------------------|:--------------------------------------|:--------|-------:|
| answering xml queries on heterogeneous data sources | i manolescu , d florescu , d kossmann | vldb    |   2001 |

Entity B:
| title                                                     | authors                        | venue                                       | year   |
|:----------------------------------------------------------|:-------------------------------|:--------------------------------------------|:-------|
| answering xml queries on heterogeneous data sources [ c ] | m ioana , f daniela , k donald | proceedings of the vldb conference , rome , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1122
rtable_id: 24324
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title           | authors   | venue   |   year |
|:----------------|:----------|:--------|-------:|
| guest editorial |           |         |   2003 |

Entity B:
| title                        | authors                | venue                                           |   year |
|:-----------------------------|:-----------------------|:------------------------------------------------|-------:|
| guest editors ' introduction | dc phillips , e callan | international journal of educational research , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2295
rtable_id: 17082
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                     | authors                                         | venue             |   year |
|:--------------------------------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| the algres testbed of chimera : an active object-oriented database system | s ceri , p fraternali , s paraboschi , g psaila | sigmod conference |   1995 |

Entity B:
| title                                     | authors                  | venue                       |   year |
|:------------------------------------------|:-------------------------|:----------------------------|-------:|
| oz + : an object-oriented database system | sp weiser , fh lochovsky | acm press frontier series , |   1989 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1683
rtable_id: 1183
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                         | authors                         | venue             |   year |
|:--------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| dbxplorer : enabling keyword search over relational databases | s agrawal , s chaudhuri , g das | sigmod conference |   2002 |

Entity B:
| title                       | authors      | venue   | year   |
|:----------------------------|:-------------|:--------|:-------|
| keyword search in databases | sv rajnikant |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 47255
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                        | authors   | venue             |   year |
|:---------------------------------------------|:----------|:------------------|-------:|
| query unnesting in object-oriented databases | l fegaras | sigmod conference |   1998 |

Entity B:
| title                                                           | authors                              | venue                                                   | year   |
|:----------------------------------------------------------------|:-------------------------------------|:--------------------------------------------------------|:-------|
| a new perspective on rule support for object-oriented databases | ea cm941 , l maugis , s chakravarthy | proceedings , international conference on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1200
rtable_id: 28460
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                       | authors             | venue   |   year |
|:----------------------------------------------------------------------------|:--------------------|:--------|-------:|
| database tuning : principles , experiments , and troubleshooting techniques | d shasha , p bonnet | vldb    |   2002 |

Entity B:
| title                                                                                    | authors   | venue   |   year |
|:-----------------------------------------------------------------------------------------|:----------|:--------|-------:|
| d. sha sha : database tuning : principles , experiments , and troubleshooting techniques | p bonnet  |         |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2187
rtable_id: 28005
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                | authors                               | venue         |   year |
|:-------------------------------------|:--------------------------------------|:--------------|-------:|
| bringing order to query optimization | g slivinskas , c jensen , r snodgrass | sigmod record |   2002 |

Entity B:
| title                         | authors   | venue                       | year   |
|:------------------------------|:----------|:----------------------------|:-------|
| multiple queries optimization | t sellis  | acm trans . database syst , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 40
rtable_id: 52549
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                               | authors                                         | venue             |   year |
|:----------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| qursed : querying and reporting semistructured data | y papakonstantinou , m petropoulos , v vassalos | sigmod conference |   2002 |

Entity B:
| title                                                                                       | authors                                   | venue                                                                  |   year |
|:--------------------------------------------------------------------------------------------|:------------------------------------------|:-----------------------------------------------------------------------|-------:|
| xcerpt and visxcerpt : from pattern-based to visual querying of xml and semistructured data | s berger , f bry , s schaffert , c wieser | proceedings of the international conference on very large & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 527
rtable_id: 6915
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                      | authors                                                             | venue   |   year |
|:-------------------------------------------|:--------------------------------------------------------------------|:--------|-------:|
| building knowledge base management systems | j mylopoulos , v chaudhri , d plexousakis , a shrufi , t topaloglou | vldb j. |   1996 |

Entity B:
| title                                 | authors   | venue           | year   |
|:--------------------------------------|:----------|:----------------|:-------|
| knowledge management promotes sharing | j king    | computerworld , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2513
rtable_id: 62297
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | authors              | venue   |   year |
|:------------------------------------------------|:---------------------|:--------|-------:|
| hierarchical prefix cubes for range-sum queries | c chan , y ioannidis | vldb    |   1999 |

Entity B:
| title                                         | authors                | venue                                                    | year   |
|:----------------------------------------------|:-----------------------|:---------------------------------------------------------|:-------|
| hierarchical prex cubes for range-sum queries | cy chan , ye ioannidis | proceedings of the 25th international conference on very |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1488
rtable_id: 26575
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                 | authors                         | venue   |   year |
|:------------------------------------------------------|:--------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | i ilyas , w aref , a elmagarmid | vldb    |   2003 |

Entity B:
| title                         | authors                                      | venue                                                                   | year   |
|:------------------------------|:---------------------------------------------|:------------------------------------------------------------------------|:-------|
| java and relational databases | g clossman , p shaw , m hapner , j klein , r | proceedings of 1998 acm sigmod conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2005
rtable_id: 1506
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                | authors           | venue             |   year |
|:-------------------------------------|:------------------|:------------------|-------:|
| association rules over interval data | r miller , y yang | sigmod conference |   1997 |

Entity B:
| title                                       | authors                                       | venue   | year   |
|:--------------------------------------------|:----------------------------------------------|:--------|:-------|
| mining fuzzy association rules in databases | cm kuok , a fu , mh wong , nt shatin , h kong |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1313
rtable_id: 52988
label: 0