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 |
|:-----------------------------------------|:------------------------------------------------------------------------------------------|:------------------|-------:|
| algorithms for deferred view maintenance | leonid libkin , inderpal singh mumick , latha s. colby , howard trickey , timothy griffin | sigmod conference |   1996 |

Entity B:
| title                              | authors                       | venue                                          |   year |
|:-----------------------------------|:------------------------------|:-----------------------------------------------|-------:|
| on-line warehouse view maintenance | dallan quass , jennifer widom | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 194
rtable_id: 1839
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 lowell report | hans-jörg schek , michael stonebraker , jim gray , jeffrey d. ullman | sigmod conference |   2003 |

Entity B:
| title             | authors                                                   | venue                                          |   year |
|:------------------|:----------------------------------------------------------|:-----------------------------------------------|-------:|
| the lowell report | jim gray , hans schek , michael stonebraker , jeff ullman | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 555
rtable_id: 2025
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 |
|:------------------------------------|:-----------------------------------------------------------|:--------|-------:|
| effective timestamping in databases | christian s. jensen , kristian torp , richard t. snodgrass | vldb j. |   2000 |

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: 198
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 |
|:-----------------------------------------------------------------|:-----------------|:------------------|-------:|
| filenet integrated document management database usage and issues | daniel s. whelan | sigmod conference |   1998 |

Entity B:
| title                                                   | authors                                                                                                 | venue                                          |   year |
|:--------------------------------------------------------|:--------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| structural matching and discovery in document databases | jason tsong-li wang , dennis shasha , george j. s. chang , liam relihan , kaizhong zhang , girish patel | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 348
rtable_id: 1865
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 |
|:-----------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| anipqo : almost non-intrusive parametric query optimization for nonlinear cost functions | arvind hulgeri , s. sudarshan | vldb    |   2003 |

Entity B:
| title                         | authors                                                              | venue                                                                  |   year |
|:------------------------------|:---------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| parametric query optimization | yannis e. ioannidis , raymond t. ng , kyuseok shim , timos k. sellis | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 1164
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 |
|:------------------------------------|:-------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | hector garcia-molina , patricia g. selinger , tomasz imielinski , david maier , jeffrey d. ullman , richard t. snodgrass | sigmod record |   1998 |

Entity B:
| title              | authors   | venue             |   year |
|:-------------------|:----------|:------------------|-------:|
| influential papers | ken ross  | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 472
rtable_id: 650
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 |
|:-----------------------------------------------|:-----------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| lambda-db : an odmg-based object-oriented dbms | leonidas fegaras , chandrasekhar srinivasan , arvind rajendran , david maier | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 644
rtable_id: 384
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 ecrc multi database system | heribert schütz , willem jonker | sigmod conference |   1995 |

Entity B:
| title                                    | authors                  | venue             |   year |
|:-----------------------------------------|:-------------------------|:------------------|-------:|
| temporal database system implementations | michael h. b &#246; hlen | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1107
rtable_id: 1600
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 |
|:-------------------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| fast , randomized join-order selection - why use transformations ? | arjan pellenkoft , césar a. galindo-legaria , martin l. kersten | vldb    |   1994 |

Entity B:
| title                                                              | authors                                                                | venue                 |   year |
|:-------------------------------------------------------------------|:-----------------------------------------------------------------------|:----------------------|-------:|
| fast , randomized join-order selection - why use transformations ? | c &#233; sar a. galindo-legaria , arjan pellenkoft , martin l. kersten | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 600
rtable_id: 2235
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 |
|:---------------------------------------------|:-------------------------------------------------------------|:--------------|-------:|
| constraints for semi-structured data and xml | wenfei fan , peter buneman , scott weinstein , jérôme siméon | sigmod record |   2001 |

Entity B:
| title                                | authors                                                                               | venue                 |   year |
|:-------------------------------------|:--------------------------------------------------------------------------------------|:----------------------|-------:|
| a fast index for semistructured data | brian cooper , neal sample , michael j. franklin , gisli r. hjaltason , moshe shadmon | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1448
rtable_id: 1313
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 |
|:--------------------------------------------|:-----------------------------------------------|:--------------|-------:|
| mining fuzzy association rules in databases | ada wai-chee fu , man hon wong , chan man kuok | sigmod record |   1998 |

Entity B:
| title                                          | authors        | venue                 |   year |
|:-----------------------------------------------|:---------------|:----------------------|-------:|
| sampling large databases for association rules | hannu toivonen | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2313
rtable_id: 1088
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 management issues in electronic commerce ( panel ) | m. tamer özsu | sigmod conference |   1999 |

Entity B:
| title                                                                        | authors      | venue             |   year |
|:-----------------------------------------------------------------------------|:-------------|:------------------|-------:|
| data management issues in electronic commerce : guest editor 's introduction | asuman dogac | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1180
rtable_id: 344
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 |
|:---------------------------------------------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| materialized view selection and maintenance using multi-query optimization | krithi ramamritham , hoshi mistry , prasan roy , s. sudarshan | sigmod conference |   2001 |

Entity B:
| title                                                                    | authors                                              | venue                                          |   year |
|:-------------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| materialized view and index selection tool for microsoft sql server 2000 | sanjay agrawal , surajit chaudhuri , vivek narasayya | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2364
rtable_id: 280
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 |
|:--------------------------------|:----------------------------------|:------------------|-------:|
| xpath queries on streaming data | sudarshan s. chawathe , feng peng | sigmod conference |   2003 |

Entity B:
| title                                                  | authors                                                           | venue                                          |   year |
|:-------------------------------------------------------|:------------------------------------------------------------------|:-----------------------------------------------|-------:|
| processing complex aggregate queries over data streams | alin dobra , minos garofalakis , johannes gehrke , rajeev rastogi | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2092
rtable_id: 646
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 execution techniques for caching expensive methods | joseph m. hellerstein , jeffrey f. naughton | sigmod conference |   1996 |

Entity B:
| title                                                      | authors               | venue                                         |   year |
|:-----------------------------------------------------------|:----------------------|:----------------------------------------------|-------:|
| optimization techniques for queries with expensive methods | joseph m. hellerstein | acm transactions on database systems ( tods ) |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1488
rtable_id: 139
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 |
|:---------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| mariposa : a wide-area distributed database system | carl staelin , paul m. aoki , witold litwin , michael stonebraker , adam sah , jeff sidell , andrew yu , avi pfeffer | vldb j. |   1996 |

Entity B:
| title                                              | authors                                                                                                              | venue                                                                  |   year |
|:---------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| mariposa : a wide-area distributed database system | michael stonebraker , paul m. aoki , witold litwin , avi pfeffer , adam sah , jeff sidell , carl staelin , andrew yu | the vldb journal -- the international journal on very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1498
rtable_id: 1203
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 |
|:------------------------------------------------------------------|:-------------------------------|:--------------|-------:|
| practical lessons in supporting large-scale computational science | terence critchlow , ron musick | sigmod record |   1999 |

Entity B:
| title                                                             | authors                        | venue             |   year |
|:------------------------------------------------------------------|:-------------------------------|:------------------|-------:|
| practical lessons in supporting large-scale computational science | ron musick , terence critchlow | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2454
rtable_id: 504
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 |
|:----------------------------------------------------------|:--------------------------------------------------------|:--------|-------:|
| concurrency control in hierarchical multidatabase systems | henry f. korth , abraham silberschatz , sharad mehrotra | vldb j. |   1997 |

Entity B:
| title                                                     | authors                                             | venue                                                                  |   year |
|:----------------------------------------------------------|:----------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| concurrency control in hierarchical multidatabase systems | sharad mehrotra , henry f. korth , avi silberschatz | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2558
rtable_id: 1167
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 |
|:------------------------------|:----------|:------------------|-------:|
| parallel database systems 101 | jim gray  | sigmod conference |   1995 |

Entity B:
| title                                  | authors      | venue             |   year |
|:---------------------------------------|:-------------|:------------------|-------:|
| mpeg-7 and multimedia database systems | harald kosch | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 838
rtable_id: 755
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 |
|:--------------------------------------------------------------------------|:----------------------------------------------------|:-----------------------------------------------|-------:|
| contorting high dimensional data for efficient main memory knn processing | bin cui , beng chin ooi , jianwen su , kian-lee tan | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1600
rtable_id: 2050
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 |
|:-------------------------------------------------------------------------------------------------|:--------------------------------------|:--------------|-------:|
| a pictorial query language for querying geographic databases using positional and olap operators | elaheh pourabbas , maurizio rafanelli | sigmod record |   2002 |

Entity B:
| title                                                           | authors                               | venue                                                                  |   year |
|:----------------------------------------------------------------|:--------------------------------------|:-----------------------------------------------------------------------|-------:|
| algebraic query optimisation for database programming languages | alexandra poulovassilis , carol small | the vldb journal -- the international journal on very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2489
rtable_id: 1209
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 |
|:----------------|:-------------------------------------------|:--------|-------:|
| guest editorial | vijay atluri , anupam joshi , yelena yesha | vldb j. |   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: 209
rtable_id: 343
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 |
|:------------------------------------------------|:---------------|:--------------|-------:|
| advances in real-time database systems research | azer bestavros | sigmod record |   1996 |

Entity B:
| title                                         | authors                                                   | venue                 |   year |
|:----------------------------------------------|:----------------------------------------------------------|:----------------------|-------:|
| generalized search trees for database systems | joseph m. hellerstein , jeffrey f. naughton , avi pfeffer | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2178
rtable_id: 1440
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 partitioning and load balancing in parallel disk systems | gerhard weikum , peter zabback , peter scheuermann | vldb j. |   1998 |

Entity B:
| title                                                                                       | authors                                 | venue                 |   year |
|:--------------------------------------------------------------------------------------------|:----------------------------------------|:----------------------|-------:|
| estimation of query-result distribution and its application in parallel-join load balancing | viswanath poosala , yannis e. ioannidis | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2320
rtable_id: 1093
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 ir-style keyword search over relational databases | yannis papakonstantinou , luis gravano , vagelis hristidis | vldb    |   2003 |

Entity B:
| title                                       | authors      | venue                                         |   year |
|:--------------------------------------------|:-------------|:----------------------------------------------|-------:|
| declarative updates of relational databases | weidong chen | acm transactions on database systems ( tods ) |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 36
rtable_id: 1650
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 |
|:--------------------------------------------|:------------|:--------|-------:|
| near neighbor search in large metric spaces | sergey brin | vldb    |   1995 |

Entity B:
| title                                                      | authors                         | venue                                         |   year |
|:-----------------------------------------------------------|:--------------------------------|:----------------------------------------------|-------:|
| indexing large metric spaces for similarity search queries | tolga bozkaya , meral ozsoyoglu | acm transactions on database systems ( tods ) |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2281
rtable_id: 108
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 |
|:-------------------------------------------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| 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: 644
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 |
|:--------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| a scalable hash ripple join algorithm | peter j. haas , jeffrey f. naughton , gang luo , curt ellmann | sigmod conference |   2002 |

Entity B:
| title                                 | authors                                                          | venue                                          |   year |
|:--------------------------------------|:-----------------------------------------------------------------|:-----------------------------------------------|-------:|
| a scalable hash ripple join algorithm | gang luo , curt j. ellmann , peter j. haas , jeffrey f. naughton | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1769
rtable_id: 693
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 |
|:---------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| cost-based optimization for magic : algebra and implementation | hamid pirahesh , t. y. cliff leung , s. sudarshan , praveen seshadri , divesh srivastava , raghu ramakrishnan , joseph m. hellerstein , peter j. stuckey | sigmod conference |   1996 |

Entity B:
| title                                                                                  | authors                       | venue                                                                  |   year |
|:---------------------------------------------------------------------------------------|:------------------------------|:-----------------------------------------------------------------------|-------:|
| opt + + : an object-oriented implementation for extensible database query optimization | navin kabra , david j. dewitt | the vldb journal -- the international journal on very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1168
rtable_id: 1254
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 |
|:---------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| opt + + : an object-oriented implementation for extensible database query optimization | david j. dewitt , navin kabra | vldb j. |   1999 |

Entity B:
| title                                                          | authors                                                                                                                                                  | venue                                          |   year |
|:---------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| cost-based optimization for magic : algebra and implementation | praveen seshadri , joseph m. hellerstein , hamid pirahesh , t. y. cliff leung , raghu ramakrishnan , divesh srivastava , peter j. stuckey , s. sudarshan | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2179
rtable_id: 1990
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 |
|:---------------------------------------------------------------------------|:---------------------------------------------|:--------|-------:|
| m-tree : an efficient access method for similarity search in metric spaces | paolo ciaccia , pavel zezula , marco patella | vldb    |   1997 |

Entity B:
| title                                                                | authors                                       | venue                                          |   year |
|:---------------------------------------------------------------------|:----------------------------------------------|:-----------------------------------------------|-------:|
| birch : an efficient data clustering method for very large databases | tian zhang , raghu ramakrishnan , miron livny | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 328
rtable_id: 1961
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 microsoft database research group | roger s. barga , david b. lomet , per-åke larson , surajit chaudhuri , vivek r. narasayya | sigmod record |   1998 |

Entity B:
| title                                       | authors          | venue             |   year |
|:--------------------------------------------|:-----------------|:------------------|-------:|
| predator : a resource for database research | praveen seshadri | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2477
rtable_id: 1775
label: 0