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 |
|:-----------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| metu interoperable database system | sema mancuhan , ismailcem budak arpinar , fatma ozcan , pinar koksal , asuman dogac , gökhan özhan , cevdet dengi , ugur halici , cem evrendilek , sena nural , ebru kilic | sigmod conference |   1996 |

Entity B:
| title                          | authors                                | venue                                          |   year |
|:-------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| the ecrc multi database system | willem jonker , heribert sch &#252; tz | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 206
rtable_id: 1939
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 |
|:----------------------------------------------------------------------|:----------------------------|:--------|-------:|
| semantic integration in heterogeneous databases using neural networks | chris clifton , wen-syan li | vldb    |   1994 |

Entity B:
| title                                                                 | authors                     | venue                 |   year |
|:----------------------------------------------------------------------|:----------------------------|:----------------------|-------:|
| semantic integration in heterogeneous databases using neural networks | wen-syan li , chris clifton | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2570
rtable_id: 2227
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 |
|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| surfing wavelets on streams : one-pass summaries for approximate aggregate queries | anna c. gilbert , martin strauss , yannis kotidis , s. muthukrishnan | vldb    |   2001 |

Entity B:
| title                                                                        | authors                                                                          | venue                                          |   year |
|:-----------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| approximating multi-dimensional aggregate range queries over real attributes | dimitrios gunopulos , george kollios , vassilis j. tsotras , carlotta domeniconi | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1512
rtable_id: 441
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 |
|:---------------------------------------------------------------|:-------------------------------|:------------------|-------:|
| models and languages for describing and discovering e-services | ming-chien shan , fabio casati | sigmod conference |   2001 |

Entity B:
| title                                                     | authors                                    | venue                                          |   year |
|:----------------------------------------------------------|:-------------------------------------------|:-----------------------------------------------|-------:|
| automatic discovery of language models for text databases | jamie callan , margaret connell , aiqun du | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1479
rtable_id: 60
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 database system for real-time event aggregation in telecommunication | henry f. korth , jerry baulier , abraham silberschatz , stephen blott | vldb    |   1998 |

Entity B:
| title                                                                            | authors                       | venue             |   year |
|:---------------------------------------------------------------------------------|:------------------------------|:------------------|-------:|
| research issues for data communication in mobile ad-hoc network database systems | leslie d. fife , le gruenwald | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 470
rtable_id: 2126
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 |
|:-------------------------------------|:-----------------------------------------------------|:--------------|-------:|
| contracting in the days of ebusiness | wolfgang hümmer , wolfgang lehner , hartmut wedekind | sigmod record |   2002 |

Entity B:
| title                                | authors                                    | venue             |   year |
|:-------------------------------------|:-------------------------------------------|:------------------|-------:|
| contracting in the days of ebusiness | w. h &#252; mmer , w. lehner , h. wedekind | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2592
rtable_id: 349
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 |
|:---------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| rule languages and internal algebras for rule-based optimizers | mitch cherniack , stanley b. zdonik | sigmod conference |   1996 |

Entity B:
| title                                                          | authors                             | venue                                          |   year |
|:---------------------------------------------------------------|:------------------------------------|:-----------------------------------------------|-------:|
| rule languages and internal algebras for rule-based optimizers | mitch cherniack , stanley b. zdonik | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1680
rtable_id: 1985
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 |
|:------------------------------------------------------------|:----------------------------------------------------------------------|:------------------|-------:|
| garlic : a new flavor of federated query processing for db2 | peter m. schwarz , laura m. haas , vanja josifovski , eileen tien lin | sigmod conference |   2002 |

Entity B:
| title                                                       | authors                                                    | venue                                          |   year |
|:------------------------------------------------------------|:-----------------------------------------------------------|:-----------------------------------------------|-------:|
| garlic : a new flavor of federated query processing for db2 | vanja josifovski , peter schwarz , laura haas , eileen lin | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2153
rtable_id: 730
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 |
|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------|:--------|-------:|
| storage estimation for multidimensional aggregates in the presence of hierarchies | jeffrey f. naughton , amit shukla , karthikeyan ramasamy , prasad deshpande | vldb    |   1996 |

Entity B:
| title                                                                 | authors                                                 | venue                                          |   year |
|:----------------------------------------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| an array-based algorithm for simultaneous multidimensional aggregates | yihong zhao , prasad m. deshpande , jeffrey f. naughton | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 900
rtable_id: 1818
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 |
|:-------------------------------------------------------------------|:---------------------------------------------------------------|:----------------------------|-------:|
| schemasql : an extension to sql for multidatabase interoperability | fereidoon sadri , laks v. s. lakshmanan , subbu n. subramanian | acm trans . database syst . |   2001 |

Entity B:
| title                                                              | authors                                                        | venue                                         |   year |
|:-------------------------------------------------------------------|:---------------------------------------------------------------|:----------------------------------------------|-------:|
| schemasql : an extension to sql for multidatabase interoperability | laks v. s. lakshmanan , fereidoon sadri , subbu n. subramanian | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2536
rtable_id: 337
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 |
|:-----------------------------------------------------------------------|:------------------|:------------------|-------:|
| directv and oracle rdb : the challenges of vldb transaction processing | william l. gettys | sigmod conference |   1995 |

Entity B:
| title                                                                | authors        | venue                                                                  |   year |
|:---------------------------------------------------------------------|:---------------|:-----------------------------------------------------------------------|-------:|
| the impact of object technology on commercial transaction processing | edward e. cobb | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 189
rtable_id: 1166
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 processing of joins on set-valued attributes | nikos mamoulis | sigmod conference |   2003 |

Entity B:
| title                                                  | authors        | venue                                          |   year |
|:-------------------------------------------------------|:---------------|:-----------------------------------------------|-------:|
| efficient processing of joins on set-valued attributes | nikos mamoulis | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1323
rtable_id: 2089
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 |
|:----------------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| a scalable and highly available networked database architecture | angelo pruscino , rafiul ahad , roger bamford | vldb    |   1999 |

Entity B:
| title                                                                      | authors                                                   | venue                 |   year |
|:---------------------------------------------------------------------------|:----------------------------------------------------------|:----------------------|-------:|
| a scalable architecture for autonomous heterogeneous database interactions | steven milliner , athman bouguettaya , mike p. papazoglou | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2085
rtable_id: 1441
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 |
|:-----------------------|:-----------------------------------|:----------------------------|-------:|
| multiway spatial joins | dimitris papadias , nikos mamoulis | acm trans . database syst . |   2001 |

Entity B:
| title              | authors                              | venue                                          |   year |
|:-------------------|:-------------------------------------|:-----------------------------------------------|-------:|
| spatial hash-joins | ming-ling lo , chinya v. ravishankar | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 110
rtable_id: 1975
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 |
|:----------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| chorochronos : a research network for spatiotemporal database systems | enrico nardelli , timos k. sellis , andrew u. frank , stéphane grumbach , hans-jörg schek , manolis koubarakis , michel scholl , ralf hartmut güting , barbara pernici , christian s. jensen , nikos a. lorentzos , babis theodoulidis , yannis manolopoulos , peter widmayer | sigmod record |   1999 |

Entity B:
| title                                     | authors     | venue                                                                  |   year |
|:------------------------------------------|:------------|:-----------------------------------------------------------------------|-------:|
| special issue on spatial database systems | h. j. schek | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1353
rtable_id: 588
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 |
|:---------------------------------------|:-------------------------------------------------------------------------|:------------------|-------:|
| multi-step processing of spatial joins | ralf schneider , thomas brinkhoff , bernhard seeger , hans-peter kriegel | sigmod conference |   1994 |

Entity B:
| title                  | authors                            | venue                                         |   year |
|:-----------------------|:-----------------------------------|:----------------------------------------------|-------:|
| multiway spatial joins | nikos mamoulis , dimitris papadias | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1559
rtable_id: 336
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 |
|:--------------------|:--------------------|:--------------|-------:|
| too much middleware | michael stonebraker | sigmod record |   2002 |

Entity B:
| title              | authors          | venue             |   year |
|:-------------------|:-----------------|:------------------|-------:|
| the new middleware | rich finkelstein | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 276
rtable_id: 1592
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 monte carlo algorithm for fast projective clustering | michael jones , pankaj k. agarwal , t. m. murali , cecilia magdalena procopiuc | sigmod conference |   2002 |

Entity B:
| title                                                  | authors                                                                 | venue                                          |   year |
|:-------------------------------------------------------|:------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| a monte carlo algorithm for fast projective clustering | cecilia m. procopiuc , michael jones , pankaj k. agarwal , t. m. murali | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 292
rtable_id: 674
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 |
|:-----------------------------------------------|:----------------|:--------|-------:|
| foundations of preferences in database systems | werner kießling | vldb    |   2002 |

Entity B:
| title                                                                                       | authors                                                                              | venue                                          |   year |
|:--------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| maintaining database consistency in presence of value dependencies in multidatabase systems | claire morpain , mich &#233; le cart , jean ferri &#233; , jean-fran &#231; ois pons | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2162
rtable_id: 1988
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 |
|:------------------------------------------------|:----------------|:--------|-------:|
| research directions in biodiversity informatics | john l. schnase | vldb    |   2000 |

Entity B:
| title                                                                                           | authors                                | venue                 |   year |
|:------------------------------------------------------------------------------------------------|:---------------------------------------|:----------------------|-------:|
| biodiversity informatics infrastructure : an information commons for the biodiversity community | gladys a. cotter , barbara t. bauldock | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 945
rtable_id: 1388
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 |
|:-------------------------------------------------------------------------------------------|:------------------------------------------------------|:--------------|-------:|
| design and user testing of a multi-paradigm query interface to an object-oriented database | dac khoa doan , alistair c. kilgour , norman w. paton | sigmod record |   1995 |

Entity B:
| title                                                                   | authors                            | venue                                          |   year |
|:------------------------------------------------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| a user-centered interface for querying distributed multimedia databases | isabel f. cruz , kimberly m. james | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 755
rtable_id: 1
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 |
|:------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------|:------------------|-------:|
| world wide database - integrating the web , corba , and databases | kevin smith , athman bouguettaya , mourad ouzzani , james beard , lily hendra , boualem benatallah | sigmod conference |   1999 |

Entity B:
| title                                                                   | authors                                                           | venue                 |   year |
|:------------------------------------------------------------------------|:------------------------------------------------------------------|:----------------------|-------:|
| integrating triggers and declarative constraints in sql database sytems | roberta cochrane , hamid pirahesh , nelson mendon &#231; a mattos | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 440
rtable_id: 1040
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 |
|:----------------------------------------------------------|:-------------------------------------------------------------------|:------------------|-------:|
| robust and efficient fuzzy match for online data cleaning | surajit chaudhuri , kris ganjam , venkatesh ganti , rajeev motwani | sigmod conference |   2003 |

Entity B:
| title                                                     | authors                                                            | venue                                          |   year |
|:----------------------------------------------------------|:-------------------------------------------------------------------|:-----------------------------------------------|-------:|
| robust and efficient fuzzy match for online data cleaning | surajit chaudhuri , kris ganjam , venkatesh ganti , rajeev motwani | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1084
rtable_id: 2033
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 infosleuth project | marek rusinkiewicz , tomasz ksiezyk , richard s. brice , ray shea , vipul kashyap , andrzej cichocki , mosfeq rashid , c. unnikrishnan , abdelsalam helal , amy unruh , marian h. nodine , jerry fowler , darrell woelk , gale martin , roberto j. bayardo jr. , william bohrer | sigmod conference |   1997 |

Entity B:
| title                  | authors                                                                                                                                                                                                           | venue                                          |   year |
|:-----------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the infosleuth project | r. j. bayardo , jr. , w. bohrer , r. brice , a. cichocki , j. fowler , a. halal , v. kashyap , t. ksiezyk , g. martin , m. nodine , m. rashid , m. rusinkiewicz , r. shea , c. unnikrishnan , a. unruh , d. woelk | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1712
rtable_id: 1845
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 |
|:---------------------------------------------------------------------------------|:--------------------------------|:--------|-------:|
| a new passenger support system for public transport using mobile database access | koichi goto , yahiko kambayashi | vldb    |   2002 |

Entity B:
| title                                                 | authors                                                           | venue                                          |   year |
|:------------------------------------------------------|:------------------------------------------------------------------|:-----------------------------------------------|-------:|
| asset : a system for supporting extended transactions | a. biliris , s. dar , n. gehani , h. v. jagadish , k. ramamritham | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2026
rtable_id: 1741
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 nesting - an efficient approach to indexing in object-oriented databases | jiawei han , beng chin ooi , hongjun lu , kian-lee tan | vldb j. |   1996 |

Entity B:
| title                                                          | authors                                              | venue                 |   year |
|:---------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| odefs : a file system interface to an object-oriented database | narain h. gehani , h. v. jagadish , william d. roome | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1118
rtable_id: 2243
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 |
|:-----------------------------------------------------------|:-----------------------------------|:----------------------------|-------:|
| indexing large metric spaces for similarity search queries | z. meral özsoyoglu , tolga bozkaya | acm trans . database syst . |   1999 |

Entity B:
| title                                           | authors                          | venue                                         |   year |
|:------------------------------------------------|:---------------------------------|:----------------------------------------------|-------:|
| index-driven similarity search in metric spaces | gisli r. hjaltason , hanan samet | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2267
rtable_id: 2175
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 semantic web : semantics for data on the web | vipul kashyap , stefan decker | vldb    |   2003 |

Entity B:
| title                                               | authors                      | venue             |   year |
|:----------------------------------------------------|:-----------------------------|:------------------|-------:|
| special section on semantic web and data management | robert meersman , amit sheth | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 834
rtable_id: 608
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 |
|:-----------------------------------------|:-----------------|:------------------|-------:|
| parallel database systems in the 1990 's | michael j. carey | sigmod conference |   1994 |

Entity B:
| title                                    | authors          | venue                                          |   year |
|:-----------------------------------------|:-----------------|:-----------------------------------------------|-------:|
| parallel database systems in the 1990 's | michael j. carey | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1689
rtable_id: 1622
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 |
|:----------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| implementing crash recovery in quickstore : a performance study | seth j. white , david j. dewitt | sigmod conference |   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: 2158
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 |
|:-------------------------------------------|:---------------|:--------|-------:|
| large databases for remote sensing and gis | a. r. dasgupta | vldb    |   1996 |

Entity B:
| title                                                            | authors                                           | venue                                                                  |   year |
|:-----------------------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| database indexing for large dna and protein sequence collections | ela hunt , malcolm p. atkinson , robert w. irving | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1642
rtable_id: 939
label: 0