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

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 user-adaptable similarity search in large multimedia databases | thomas seidl , hans-peter kriegel | vldb    |   1997 |

Entity B:
| title                                                                    | authors                           | venue                 |   year |
|:-------------------------------------------------------------------------|:----------------------------------|:----------------------|-------:|
| efficient user-adaptable similarity search in large multimedia databases | thomas seidl , hans-peter kriegel | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1117
rtable_id: 1074
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------------------|:-----------------------------|:------------------|-------:|
| electronic commerce : tutorial | nabil r. adam , yelena yesha | sigmod conference |   1998 |

Entity B:
| title                                                      | authors                       | venue             |   year |
|:-----------------------------------------------------------|:------------------------------|:------------------|-------:|
| xml and electronic commerce : enabling the network economy | bart meltzer , robert glushko | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 789
rtable_id: 14
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------|:------------------------------|:--------|-------:|
| unrolling cycles to decide trigger termination | tok wang ling , sin yeung lee | vldb    |   1999 |

Entity B:
| title                                          | authors                       | venue                 |   year |
|:-----------------------------------------------|:------------------------------|:----------------------|-------:|
| unrolling cycles to decide trigger termination | sin yeung lee , tok wang ling | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 409
rtable_id: 788
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | ling liu  | sigmod record |   2003 |

Entity B:
| title     | authors           | venue                                         |   year |
|:----------|:------------------|:----------------------------------------------|-------:|
| editorial | richard snodgrass | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2130
rtable_id: 342
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 database group at university of hagen ( fernuniversitaet ) | silke mittrach , gunter schlageter , thomas berkel , andreas scherer , eberhard heuel , wolfgang wilkes | sigmod record |   1995 |

Entity B:
| title                                                               | authors                                                       | venue             |   year |
|:--------------------------------------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| database research at the university of illinois at urbana-champaign | m. winslett , k. chang , a. doan , j. han , c. zhai , y. zhou | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 240
rtable_id: 562
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------------------------------------------------------------------------|:-----------------------------|:--------|-------:|
| dataguides : enabling query formulation and optimization in semistructured databases | roy goldman , jennifer widom | vldb    |   1997 |

Entity B:
| title                                     | authors                                                                     | venue                                         |   year |
|:------------------------------------------|:----------------------------------------------------------------------------|:----------------------------------------------|-------:|
| space optimization in deductive databases | divesh srivastava , s. sudarshan , raghu ramakrishnan , jeffrey f. naughton | acm transactions on database systems ( tods ) |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1347
rtable_id: 1609
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | leonidas fegaras | sigmod conference |   1998 |

Entity B:
| title                                      | authors                                                            | venue                                          |   year |
|:-------------------------------------------|:-------------------------------------------------------------------|:-----------------------------------------------|-------:|
| on-line reorganization in object databases | mohana k. lakhamraju , rajeev rastogi , s. seshadri , s. sudarshan | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2232
rtable_id: 66
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------------|:-------------------------------------------------|:------------------|-------:|
| stholes : a multidimensional workload-aware histogram | luis gravano , nicolas bruno , surajit chaudhuri | sigmod conference |   2001 |

Entity B:
| title                                                 | authors                                          | venue                                          |   year |
|:------------------------------------------------------|:-------------------------------------------------|:-----------------------------------------------|-------:|
| stholes : a multidimensional workload-aware histogram | nicolas bruno , surajit chaudhuri , luis gravano | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2253
rtable_id: 298
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| modeling high-dimensional index structures using sampling | christian a. lang , ambuj k. singh | sigmod conference |   2001 |

Entity B:
| title                                                     | authors                            | venue                                          |   year |
|:----------------------------------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| modeling high-dimensional index structures using sampling | christian a. lang , ambuj k. singh | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2048
rtable_id: 314
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------------------------|:-------------------------------|:--------------|-------:|
| continuous queries over data streams | jennifer widom , shivnath babu | sigmod record |   2001 |

Entity B:
| title                                                          | authors                                         | venue                                          |   year |
|:---------------------------------------------------------------|:------------------------------------------------|:-----------------------------------------------|-------:|
| on computing correlated aggregates over continual data streams | johannes gehrke , flip korn , divesh srivastava | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 286
rtable_id: 469
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 multiple dimensional queries simultaneously in multidimensional databases | jeffrey xu yu , weifa liang , maria e. orlowska | vldb j. |   2000 |

Entity B:
| title                                                        | authors                                   | venue                 |   year |
|:-------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| querying multiple features of groups in relational databases | damianos chatziantoniou , kenneth a. ross | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2062
rtable_id: 1046
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 introduction to deductive database languages and systems | kotagiri ramamohanarao , james harland | vldb j. |   1994 |

Entity B:
| title                                 | authors                                             | venue                                          |   year |
|:--------------------------------------|:----------------------------------------------------|:-----------------------------------------------|-------:|
| a language based multidatabase system | eva k &#252; hn , thomas tschernko , konrad schwarz | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 183
rtable_id: 1665
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------------------------|:------------------------|:--------|-------:|
| using schema matching to simplify heterogeneous data translation | tova milo , sagit zohar | vldb    |   1998 |

Entity B:
| title                                        | authors               | venue                                          |   year |
|:---------------------------------------------|:----------------------|:-----------------------------------------------|-------:|
| using schematically heterogeneous structures | re &#233; e j. miller | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2331
rtable_id: 1806
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | michael j. franklin | sigmod record |   1999 |

Entity B:
| title     | authors                                        | venue                                                                  |   year |
|:----------|:-----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| editorial | peter apers , stefano ceri , richard snodgrass | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2509
rtable_id: 917
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| aggregation algorithms for very large compressed data warehouses | jaideep srivastava , jianzhong li , doron rotem | vldb    |   1999 |

Entity B:
| title                                                            | authors                                         | venue                 |   year |
|:-----------------------------------------------------------------|:------------------------------------------------|:----------------------|-------:|
| aggregation algorithms for very large compressed data warehouses | jianzhong li , doron rotem , jaideep srivastava | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 701
rtable_id: 789
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| integration of spatial join algorithms for processing multiple inputs | nikos mamoulis , dimitris papadias | sigmod conference |   1999 |

Entity B:
| title                                                                 | authors                            | venue                                          |   year |
|:----------------------------------------------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| integration of spatial join algorithms for processing multiple inputs | nikos mamoulis , dimitris papadias | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 269
rtable_id: 219
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------------------------|:----------------------------------------------------|:--------|-------:|
| dynamic load balancing in hierarchical parallel database systems | luc bouganim , daniela florescu , patrick valduriez | vldb    |   1996 |

Entity B:
| title                                                              | authors                    | venue                 |   year |
|:-------------------------------------------------------------------|:---------------------------|:----------------------|-------:|
| dynamic multi-resource load balancing in parallel database systems | erhard rahm , robert marek | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 391
rtable_id: 1458
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | elisa bertino | vldb j. |   1994 |

Entity B:
| title                                                                                  | authors                                                    | venue                                         |   year |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------|:----------------------------------------------|-------:|
| description logics for semantic query optimization in object-oriented database systems | domenico beneventano , sonia bergamaschi , claudio sartori | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 644
rtable_id: 1236
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------|:---------------|:--------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | sigmod record |   1996 |

Entity B:
| title                                             | authors                         | venue                 |   year |
|:--------------------------------------------------|:--------------------------------|:----------------------|-------:|
| intelligent rollups in multidimensional olap data | gayatri sathe , sunita sarawagi | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2108
rtable_id: 1351
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------|:--------|-------:|
| banks : browsing and keyword searching in relational databases | arvind hulgeri , gaurav bhalotia , soumen chakrabarti , parag , s. sudarshan , charuta nakhe , b. aditya | vldb    |   2002 |

Entity B:
| title                                                        | authors                                   | venue                 |   year |
|:-------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| querying multiple features of groups in relational databases | damianos chatziantoniou , kenneth a. ross | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 316
rtable_id: 1046
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 replication for mobile computers | a. prasad sistla , ouri wolfson , yixiu huang | sigmod conference |   1994 |

Entity B:
| title                                                                      | authors                                                      | venue             |   year |
|:---------------------------------------------------------------------------|:-------------------------------------------------------------|:------------------|-------:|
| cache invalidation scheme for mobile computing systems with real-time data | joe chun-hung yuen , edward chan , kam-yiu lam , h. w. leung | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1587
rtable_id: 454
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | ling liu  | sigmod record |   2002 |

Entity B:
| title     | authors           | venue                                         |   year |
|:----------|:------------------|:----------------------------------------------|-------:|
| editorial | richard snodgrass | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 74
rtable_id: 342
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------|:------------------------------------|:--------|-------:|
| promises and realities of active database systems | eric simon , angelika kotz dittrich | vldb    |   1995 |

Entity B:
| title                                                                                    | authors                                         | venue                 |   year |
|:-----------------------------------------------------------------------------------------|:------------------------------------------------|:----------------------|-------:|
| naos - efficient and modular reactive capabilities in an object-oriented database system | christine collet , thierry coupaye , t. svensen | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2129
rtable_id: 1419
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 queries with universal quantification in object-oriented and object-relational databases | guido moerkotte , jens claußen , klaus peithner , alfons kemper | vldb    |   1997 |

Entity B:
| title                                                                   | authors                     | venue                 |   year |
|:------------------------------------------------------------------------|:----------------------------|:----------------------|-------:|
| processing object-oriented queries with invertible late bound functions | staffan flodin , tore risch | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 542
rtable_id: 1106
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------------|:------------------------------------------|:----------------------------|-------:|
| cost models for overlapping and multiversion structures | yufei tao , jun zhang , dimitris papadias | acm trans . database syst . |   2002 |

Entity B:
| title                                                         | authors                                                                         | venue                                          |   year |
|:--------------------------------------------------------------|:--------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| a data model and data structures for moving objects databases | luca forlizzi , ralf hartmut g &#252; ting , enrico nardelli , markus schneider | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1249
rtable_id: 420
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 xml views of relational data | jerry kiernan , jayavel shanmugasundaram , catalina fan , eugene j. shekita , john funderburk | vldb    |   2001 |

Entity B:
| title                                 | authors                                                                                       | venue                 |   year |
|:--------------------------------------|:----------------------------------------------------------------------------------------------|:----------------------|-------:|
| querying xml views of relational data | jayavel shanmugasundaram , jerry kiernan , eugene j. shekita , catalina fan , john funderburk | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1050
rtable_id: 1320
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 semantic web : semantics for data on the web | vipul kashyap , stefan decker | vldb    |   2003 |

Entity B:
| title                                                       | authors                  | venue             |   year |
|:------------------------------------------------------------|:-------------------------|:------------------|-------:|
| agents , trust , and information access on the semantic web | tim finin , anupam joshi | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 834
rtable_id: 620
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------------------|:----------------------------------------------------|:--------|-------:|
| combi-operator : database support for data mining applications | wolfgang lehner , alexander hinneburg , dirk habich | vldb    |   2003 |

Entity B:
| title                                                                 | authors                                       | venue             |   year |
|:----------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| infosphere project : system support for information flow applications | calton pu , karsten schwan , jonathan walpole | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 833
rtable_id: 479
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------|:-----------------------------|:------------------|-------:|
| distributed top-k monitoring | chris olston , brian babcock | sigmod conference |   2003 |

Entity B:
| title                        | authors                      | venue                                          |   year |
|:-----------------------------|:-----------------------------|:-----------------------------------------------|-------:|
| distributed top-k monitoring | brian babcock , chris olston | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1909
rtable_id: 2079
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | joseph fong | sigmod record |   1997 |

Entity B:
| title                                                                          | authors                                                | venue                                                                  |   year |
|:-------------------------------------------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| index nesting - an efficient approach to indexing in object-oriented databases | beng chin ooi , jiawei han , hongjun lu , kian lee tan | the vldb journal -- the international journal on very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 1205
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------|:--------------------------------|:--------|-------:|
| quickstore : a high performance mapped object store | seth j. white , david j. dewitt | vldb j. |   1995 |

Entity B:
| title                                               | authors                         | venue                                          |   year |
|:----------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| quickstore : a high performance mapped object store | seth j. white , david j. dewitt | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1648
rtable_id: 1645
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 prototype of the dare system | tiziana catarci , giuseppe santucci | sigmod conference |   2001 |

Entity B:
| title                             | authors                                           | venue             |   year |
|:----------------------------------|:--------------------------------------------------|:------------------|-------:|
| the oasis multidatabase prototype | mark roantree , john murphy , wilhelm hasselbring | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 381
rtable_id: 97
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 query processing for multi-dimensionally clustered tables in db2 | matthew huras , leslie cranston , bishwaranjan bhattacharjee , sriram padmanabhan , timothy malkemus , tony lai | vldb    |   2003 |

Entity B:
| title                                                          | authors                                                                                          | venue                                          |   year |
|:---------------------------------------------------------------|:-------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| multi-dimensional clustering : a new data layout scheme in db2 | sriram padmanabhan , bishwaranjan bhattacharjee , tim malkemus , leslie cranston , matthew huras | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1600
rtable_id: 2007
label: 0