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 |
|:-------------------------|:--------------------------------------|:------------------|-------:|
| nearest neighbor queries | n roussopoulos , s kelley , f vincent | sigmod conference |   1995 |

Entity B:
| title                                          | authors              | venue                                                       | year   |
|:-----------------------------------------------|:---------------------|:------------------------------------------------------------|:-------|
| optimal multi-step k-nearest neighbour queries | t seidl , hp kriegel | proceedings of the 1997 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1587
rtable_id: 30352
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 |
|:------------------------------------------------------------|:----------------------------------|:--------|-------:|
| aggregate-query processing in data warehousing environments | a gupta , v harinarayan , d quass | vldb    |   1995 |

Entity B:
| title                                         | authors                             | venue                                                                  | year   |
|:----------------------------------------------|:------------------------------------|:-----------------------------------------------------------------------|:-------|
| view maintenance in a warehousing environment | y zhung , mh garcia , j hammerâ ? ¦ | proceedings of the acm sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1977
rtable_id: 49415
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 |
|:-------------------------------|:--------------------------------|:------------------|-------:|
| relaxed transaction processing | m singh , c tomlinson , d woelk | sigmod conference |   1994 |

Entity B:
| title                      | authors                                          | venue                                                                 |   year |
|:---------------------------|:-------------------------------------------------|:----------------------------------------------------------------------|-------:|
| functional-join processing | r braumandl , j claussen , a kemper , d kossmann | the vldb journal the international journal on very large & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1808
rtable_id: 26463
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 |
|:----------------------------|:-----------|:--------------------------------------|-------:|
| beyond relational databases | ms jackson | information and software technology , |   1990 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 36689
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 |
|:---------------------------------------------------|:------------------------------------------------------------------------------------|:--------|-------:|
| mariposa : a wide-area distributed database system | m stonebraker , p aoki , w litwin , a pfeffer , a sah , j sidell , c staelin , a yu | vldb j. |   1996 |

Entity B:
| title                                                                             | authors                      | venue                                                       | year   |
|:----------------------------------------------------------------------------------|:-----------------------------|:------------------------------------------------------------|:-------|
| mocha : a self-extensible database middleware system for distributed data sources | mr martinez , n roussopoulos | acm sigmod international conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2528
rtable_id: 21161
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 survey of logical models for olap databases | p vassiliadis , t sellis | sigmod record |   1999 |

Entity B:
| title                                            | authors   | venue                                                            | year   |
|:-------------------------------------------------|:----------|:-----------------------------------------------------------------|:-------|
| a model of queries for object-oriented databases | kw kun    | proc of the 1989 vldb co @ , amsterdam , the netherlands , aug , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 258
rtable_id: 53286
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 |
|:----------------------------------------------------|:----------------------|:--------|-------:|
| on the costs of multilingualism in database systems | a kumaran , j haritsa | vldb    |   2003 |

Entity B:
| title                                    | authors   | venue                 | year   |
|:-----------------------------------------|:----------|:----------------------|:-------|
| parallel database systems in the 1990 's | mj carey  | acm computing surveys |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2082
rtable_id: 4146
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 efficient algorithm for mining association rules in large databases | a savasere , e omiecinski , s navathe | vldb    |   1995 |

Entity B:
| title                                                                      | authors   | venue                                                                 | year   |
|:---------------------------------------------------------------------------|:----------|:----------------------------------------------------------------------|:-------|
| agrawal , r. ; srikant , r. : fast algorithms for mining association rules | s agrawal | proceedings of the 20th international conference of very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 17315
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 |
|:----------------------------------|:---------------------------|:--------|-------:|
| modelling and querying video data | r hjelsvold , r midtstraum | vldb    |   1994 |

Entity B:
| title                   | authors   | venue                                 |   year |
|:------------------------|:----------|:--------------------------------------|-------:|
| modelling temporal data | au tansel | information and software technology , |   1990 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 246
rtable_id: 30026
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 |
|:-------------------------------------------------------------------------------------|:-------------------------------|:------------------|-------:|
| oracle media server : providing consumer based interactive access to multimedia data | a laursen , j olkin , m porter | sigmod conference |   1994 |

Entity B:
| title                               | authors              | venue                       | year   |
|:------------------------------------|:---------------------|:----------------------------|:-------|
| pier : using interactive multimedia | m nilsson , u nulden | submitted for publication , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1823
rtable_id: 9748
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 |
|:--------------------------------------------|:---------------------------------------------------|:--------|-------:|
| approximate query processing using wavelets | k chakrabarti , m garofalakis , r rastogi , k shim | vldb j. |   2001 |

Entity B:
| title                                               | authors                    | venue                                                                 |   year |
|:----------------------------------------------------|:---------------------------|:----------------------------------------------------------------------|-------:|
| approximate query processing : taming the terabytes | mn garofalakis , pb gibbon | proceedings of the 27th international conference on very & hellip ; , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2495
rtable_id: 45289
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 |
|:-------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| revisiting commit processing in distributed database systems | r gupta , j haritsa , k ramamritham | sigmod conference |   1997 |

Entity B:
| title                                                       | authors              | venue                                                                    |   year |
|:------------------------------------------------------------|:---------------------|:-------------------------------------------------------------------------|-------:|
| query processing in main memory database management systems | tj lehman , mj carey | proceedings of the 1986 acm sigmod international conference & hellip ; , |   1986 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1401
rtable_id: 16892
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 cougar approach to in-network query processing in sensor networks | y yao , j gehrke | sigmod record |   2002 |

Entity B:
| title                                                                 | authors                                           | venue                                  |   year |
|:----------------------------------------------------------------------|:--------------------------------------------------|:---------------------------------------|-------:|
| tinydb : an acquisitional query processing system for sensor networks | sr madden , mj franklin , jm hellerstein , w hong | acm transactions on database systems , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 66
rtable_id: 31469
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 |
|:--------------------------------------------------|:-------------------------------|:--------|-------:|
| efficient algorithms for processing xpath queries | g gottlob , c koch , r pichler | vldb    |   2002 |

Entity B:
| title                                                     | authors                 | venue                                                 |   year |
|:----------------------------------------------------------|:------------------------|:------------------------------------------------------|-------:|
| an efficient algorithm for discovering frequent subgraphs | m kuramochi , g karypis | ieee transactions on knowledge and data engineering , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2188
rtable_id: 11577
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 impact of global clustering on spatial database systems | t brinkhoff , h kriegel | vldb    |   1994 |

Entity B:
| title                                                       | authors                  | venue                                                                  |   year |
|:------------------------------------------------------------|:-------------------------|:-----------------------------------------------------------------------|-------:|
| the impact of global clustering on spatial database systems | t brinkhoff , hp kriegel | proceedings of the international conference on very large & hellip ; , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 160
rtable_id: 28791
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 |
|:-------------------------------------------------------------|:----------|:--------|-------:|
| storage and retrieval of xml data using relational databases |           |         |   2001 |

Entity B:
| title                                       | authors                 | venue                                           |   year |
|:--------------------------------------------|:------------------------|:------------------------------------------------|-------:|
| efficiently monitoring relational databases | op buneman , ek clemons | acm transactions on database systems ( tods ) , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1082
rtable_id: 19222
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 |
|:----------------------------------------------------|:-----------------------------|:------------------|-------:|
| wavelet-based histograms for selectivity estimation | y matias , j vitter , m wang | sigmod conference |   1998 |

Entity B:
| title                                     | authors                             | venue               | year   |
|:------------------------------------------|:------------------------------------|:--------------------|:-------|
| selectivity estimationinspatial databases | s acharya , v poosala , s ramaswamy | proc . acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1172
rtable_id: 16644
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 |
|:----------------------------------------------------------------------------------|:----------|:--------|-------:|
| agent-oriented software engineering report on the 4th aose workshop ( aose 2003 ) |           |         |   2003 |

Entity B:
| title                                                                  | authors             | venue                                                                     |   year |
|:-----------------------------------------------------------------------|:--------------------|:--------------------------------------------------------------------------|-------:|
| 2 ndworkshop on the state of the art in automated software engineering | a zisman , t ellman | proceedings of the 20th ieee/acm international conference on & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1906
rtable_id: 43304
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 |
|:-------------------------------------------------------------|:-------------------------------------------------|:----------------------------|-------:|
| data mining with optimized two-dimensional association rules | t fukuda , y morimoto , s morishita , t tokuyama | acm trans . database syst . |   2001 |

Entity B:
| title                                                                  | authors   | venue   | year   |
|:-----------------------------------------------------------------------|:----------|:--------|:-------|
| data mining library reuse patterns using generalized association rules | a michail |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2332
rtable_id: 35246
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 multidimensional database system rasdaman | p baumann , a dehmel , p furtado , r ritsch , n widmann | sigmod conference |   1998 |

Entity B:
| title                                     | authors                  | venue                        | year   |
|:------------------------------------------|:-------------------------|:-----------------------------|:-------|
| a fondationfor multidimensional databases | m gyssens , l lakshmanan | proceedings of the 23rd vldb |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1221
rtable_id: 13262
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 |
|:--------------------------------------------------------|:-------------------|:------------------|-------:|
| time-parameterized queries in spatio-temporal databases | y tao , d papadias | sigmod conference |   2002 |

Entity B:
| title                                   | authors                               | venue                                  |   year |
|:----------------------------------------|:--------------------------------------|:---------------------------------------|-------:|
| linear queries in statistical databases | md schwartz , de denning , pj denning | acm transactions on database systems , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 537
rtable_id: 3573
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 |
|:--------------------------------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| storing and querying ordered xml using a relational database system | i tatarinov , s viglas , k beyer , j shanmugasundaram , e shekita , c zhang | sigmod conference |   2002 |

Entity B:
| title                                                        | authors                | venue               |   year |
|:-------------------------------------------------------------|:-----------------------|:--------------------|-------:|
| implementation of magic-sets in a relational database system | is mumick , h pirahesh | sigmod conference , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 526
rtable_id: 41392
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 |
|:--------------------------------------------------------------------|:-------------------------|:--------|-------:|
| os support for vldbs : unix enhancements for the teradata data base | j catozzi , s rabinovici | vldb    |   1995 |

Entity B:
| title                                                               | authors                  | venue                                                                  |   year |
|:--------------------------------------------------------------------|:-------------------------|:-----------------------------------------------------------------------|-------:|
| os support for vldbs : unix enhancements for the teradata data base | j catozzi , s rabinovici | proceedings of the international conference on very large & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 121
rtable_id: 17433
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 |
|:-----------------------------------------------------------------------|:------------------------------|:------------------|-------:|
| dimensionality reduction for similarity searching in dynamic databases | k kanth , d agrawal , a singh | sigmod conference |   1998 |

Entity B:
| title                                                                               | authors     | venue                                                 |   year |
|:------------------------------------------------------------------------------------|:------------|:------------------------------------------------------|-------:|
| dimensionality reduction and similarity computation by inner-product approximations | o egecioglu | ieee transactions on knowledge and data engineering , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1138
rtable_id: 20106
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 |
|:--------------------------------------------------------------|:-------------------------------------|:--------|-------:|
| data partitioning and load balancing in parallel disk systems | p scheuermann , g weikum , p zabback | vldb j. |   1998 |

Entity B:
| title                                                                   | authors       | venue                                                           | year   |
|:------------------------------------------------------------------------|:--------------|:----------------------------------------------------------------|:-------|
| load balancing and data locality in parallel hierarchial n-body methods | jp singhâ ? ¦ | technical report csl-tr-92-505 , stanford university , february |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2437
rtable_id: 9815
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 |
|:-----------------------------------------------------------|:-------------------|:--------|-------:|
| data placement in shared-nothing parallel database systems | m mehta , d dewitt | vldb j. |   1997 |

Entity B:
| title                                                            | authors   | venue                                                                  |   year |
|:-----------------------------------------------------------------|:----------|:-----------------------------------------------------------------------|-------:|
| managing intra-operator parallelism in parallel database systems | m mehta   | proceedings of the international conference on very large & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2515
rtable_id: 35922
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 |
|:--------------------------------------|:-----------|:--------|-------:|
| commercial use of database technology | h schіning | vldb    |   2003 |

Entity B:
| title                                     | authors   | venue          | year   |
|:------------------------------------------|:----------|:---------------|:-------|
| computer technology and the database user | tc chen   | vldb surveys , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2045
rtable_id: 55500
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 data structures and algorithms for dynamic query interfaces | e tanin , r beigel , b shneiderman | sigmod record |   1996 |

Entity B:
| title                                                          | authors                         | venue                                                                  | year   |
|:---------------------------------------------------------------|:--------------------------------|:-----------------------------------------------------------------------|:-------|
| vist : a dynamic index method for querying xml data structures | h wang , s park , w fan , ps yu | proceedings of the acm sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 749
rtable_id: 8719
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 |
|:-------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| optimizing the secure evaluation of twig queries | s cho , s amer-yahia , l lakshmanan , d srivastava | vldb    |   2002 |

Entity B:
| title                              | authors           | venue                                                                  | year   |
|:-----------------------------------|:------------------|:-----------------------------------------------------------------------|:-------|
| optimization of large join queries | a swani , a gupta | proceedings of the acm sigmod conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2232
rtable_id: 10005
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 |
|:-----------------|:----------|:--------|-------:|
| title , foreword |           |         |   1994 |

Entity B:
| title    | authors     | venue                   |   year |
|:---------|:------------|:------------------------|-------:|
| foreword | pb domorski | bt technology journal , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2562
rtable_id: 24944
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 |
|:----------------------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| semantic assumptions and query evaluation in temporal databases | c bettini , x wang , e bertino , s jajodia | sigmod conference |   1995 |

Entity B:
| title                                                           | authors                                     | venue                                                                    |   year |
|:----------------------------------------------------------------|:--------------------------------------------|:-------------------------------------------------------------------------|-------:|
| semantic assumptions and query evaluation in temporal databases | c bettini , xs wang , e bertino , s jajodia | proceedings of the 1995 acm sigmod international conference & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1603
rtable_id: 26806
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 |
|:---------------------------------------------------|:----------|:--------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record |   1997 |

Entity B:
| title                                            | authors   | venue                                                                 |   year |
|:-------------------------------------------------|:----------|:----------------------------------------------------------------------|-------:|
| index configuration in object-oriented databases | e bertino | the vldb journal the international journal on very large & hellip ; , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 562
rtable_id: 7529
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 |
|:---------------------------------------------------------|:--------------------|:--------|-------:|
| some issues in design of distributed deductive databases | m mohania , n sarda | vldb    |   1994 |

Entity B:
| title                                                                        | authors          | venue                       | year   |
|:-----------------------------------------------------------------------------|:-----------------|:----------------------------|:-------|
| â ?? on the design of a query strategy in a distributed database environment | ct yv , cc chang | acm proceedings of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 140
rtable_id: 58925
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 |
|:------------------------------------|:----------|:--------|-------:|
| hypertext databases and data mining |           |         |   1999 |

Entity B:
| title                                       | authors    | venue   | year   |
|:--------------------------------------------|:-----------|:--------|:-------|
| xml 's impact on databases and data sharing | l seligman |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1079
rtable_id: 13740
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 |
|:------------------------------------------------|:-------------------|:------------------|-------:|
| improved query performance with variant indexes | p o'neil , d quass | sigmod conference |   1997 |

Entity B:
| title                                           | authors   | venue   | year   |
|:------------------------------------------------|:----------|:--------|:-------|
| improved query performance with variant indexes | , d quass |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1298
rtable_id: 25507
label: 1