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

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

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

Entity A:
| title                                                                              | authors                                                | venue   |   year |
|:-----------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| efficient incremental garbage collection for client-server object database systems | laurent amsaleg , olivier gruber , michael j. franklin | vldb    |   1995 |

Entity B:
| title                                                                              | authors                                                | venue                 |   year |
|:-----------------------------------------------------------------------------------|:-------------------------------------------------------|:----------------------|-------:|
| efficient incremental garbage collection for client-server object database systems | laurent amsaleg , michael j. franklin , olivier gruber | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1285
rtable_id: 1473
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 |
|:-----------------------------|:------------|:--------------|-------:|
| guest editor 's introduction | karl aberer | sigmod record |   2003 |

Entity B:
| title           | authors                                                     | venue                                                                  |   year |
|:----------------|:------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| guest editorial | philip a. bernstein , yannis ioannidis , raghu ramakrishnan | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2244
rtable_id: 2290
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 |
|:-------------------------------------------------------------------------------------------|:--------------|:------------------|-------:|
| nodose - a tool for semi-automatically extracting semi-structured data from text documents | brad adelberg | sigmod conference |   1998 |

Entity B:
| title                                            | authors                                       | venue                 |   year |
|:-------------------------------------------------|:----------------------------------------------|:----------------------|-------:|
| type classification of semi-structured documents | markus tresch , neal palmer , allen luniewski | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1363
rtable_id: 1107
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 |
|:----------------------------------------|:---------------|:--------|-------:|
| dwms : data warehouse management system | narendra mohan | vldb    |   1996 |

Entity B:
| title                                   | authors        | venue                 |   year |
|:----------------------------------------|:---------------|:----------------------|-------:|
| dwms : data warehouse management system | narendra mohan | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 420
rtable_id: 1051
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 |
|:----------------------------------------------------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| optimizing queries with universal quantification in object-oriented and object-relational databases | guido moerkotte , jens claußen , klaus peithner , alfons kemper | vldb    |   1997 |

Entity B:
| title                                                                                      | authors                                               | venue                 |   year |
|:-------------------------------------------------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| cost-based selection of path expression processing algorithms in object-oriented databases | georges gardarin , jean-robert gruser , zhao-hui tang | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 542
rtable_id: 1125
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 |
|:----------------------------------------------------|:------------------------------------------|:--------|-------:|
| approximate query processing : taming the terabytes | minos n. garofalakis , phillip b. gibbons | vldb    |   2001 |

Entity B:
| title                                                            | authors                                                     | venue                                                                  |   year |
|:-----------------------------------------------------------------|:------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| approximate query mapping : accounting for translation closeness | kevin chen-chuan chang , h &#233; ctor garc &#237; a-molina | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 713
rtable_id: 2106
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 |
|:--------------------------------------------------|:---------------------------------------------------------------------------------------------|:------------------|-------:|
| java and relational databases : sqlj ( tutorial ) | johannes klein , richard pledereder , gray clossman , brian becker , phil shaw , mark hapner | sigmod conference |   1998 |

Entity B:
| title                                          | authors             | venue             |   year |
|:-----------------------------------------------|:--------------------|:------------------|-------:|
| constraint databases : a tutorial introduction | jan van den bussche | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 133
rtable_id: 458
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 |
|:-----------------------------------------------|:---------------|:------------------|-------:|
| catalog management in websphere commerce suite | thomas maguire | sigmod conference |   2001 |

Entity B:
| title                                         | authors             | venue                                          |   year |
|:----------------------------------------------|:--------------------|:-----------------------------------------------|-------:|
| data management issues in electronic commerce | m. tamer &#214; zsu | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1908
rtable_id: 56
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 |
|:-------------------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| temporal conditions and integrity constraints in active database systems | ouri wolfson , a. prasad sistla | sigmod conference |   1995 |

Entity B:
| title                                                                                      | authors                       | venue                 |   year |
|:-------------------------------------------------------------------------------------------|:------------------------------|:----------------------|-------:|
| further improvements on integrity constraint checking for stratifiable deductive databases | sin yeung lee , tok wang ling | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2452
rtable_id: 1101
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 piazza peer data management project | gerome miklau , jayant madhavan , igor tatarinov , zachary g. ives , xin dong , yana kadiyska , alon y. halevy , nilesh n. dalvi , dan suciu , peter mork | sigmod record |   2003 |

Entity B:
| title                                   | authors                                                                                                                                                   | venue             |   year |
|:----------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| the piazza peer data management project | igor tatarinov , zachary ives , jayant madhavan , alon halevy , dan suciu , nilesh dalvi , xin ( luna ) dong , yana kadiyska , gerome miklau , peter mork | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1157
rtable_id: 2244
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 |
|:-----------------------------------------|:------------------|:--------------|-------:|
| temporal database system implementations | michael h. böhlen | sigmod record |   1995 |

Entity B:
| title                                                      | authors                        | venue                                                                  |   year |
|:-----------------------------------------------------------|:-------------------------------|:-----------------------------------------------------------------------|-------:|
| data placement in shared-nothing parallel database systems | manish mehta , david j. dewitt | the vldb journal -- the international journal on very large data bases |   1997 |



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

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

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

Entity A:
| title                                                                                             | authors                                      | venue   |   year |
|:--------------------------------------------------------------------------------------------------|:---------------------------------------------|:--------|-------:|
| cost models do matter : providing cost information for diverse data sources in a federated system | mary tork roth , laura m. haas , fatma ozcan | vldb    |   1999 |

Entity B:
| title                                                                                             | authors                                      | venue                 |   year |
|:--------------------------------------------------------------------------------------------------|:---------------------------------------------|:----------------------|-------:|
| cost models do matter : providing cost information for diverse data sources in a federated system | mary tork roth , fatma ozcan , laura m. haas | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2002
rtable_id: 800
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 |
|:------------------------------------------------------------------|:----------|:--------|-------:|
| title , preface to the special issue on persistent object systems | ?         | vldb j. |   1995 |

Entity B:
| title                                                     | authors          | venue                                                                  |   year |
|:----------------------------------------------------------|:-----------------|:-----------------------------------------------------------------------|-------:|
| special issue on prototypes of deductive database systems | k. ramamohanarao | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1946
rtable_id: 583
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 wasa2 object-oriented workflow management system | mathias weske , gottfried vossen | sigmod conference |   1999 |

Entity B:
| title                                               | authors     | venue             |   year |
|:----------------------------------------------------|:------------|:------------------|-------:|
| the mariposa distributed database management system | jeff sidell | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2123
rtable_id: 1898
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 power of languages for the manipulation of complex values | serge abiteboul , catriel beeri | vldb j. |   1995 |

Entity B:
| title                                                         | authors                         | venue                                                                  |   year |
|:--------------------------------------------------------------|:--------------------------------|:-----------------------------------------------------------------------|-------:|
| the power of languages for the manipulation of complex values | serge abiteboul , catriel beeri | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1210
rtable_id: 635
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 |
|:----------------------------------------------------------------------|:-----------------------------------------------------|:------------------|-------:|
| an array-based algorithm for simultaneous multidimensional aggregates | jeffrey f. naughton , yihong zhao , prasad deshpande | sigmod conference |   1997 |

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: 1
original: ltable_id: 2292
rtable_id: 1818
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 |
|:----------------------------------------------------------------------|:----------------------------|:--------|-------:|
| semantic integration in heterogeneous databases using neural networks | chris clifton , wen-syan li | vldb    |   1994 |

Entity B:
| title                                                                                  | authors                       | venue                 |   year |
|:---------------------------------------------------------------------------------------|:------------------------------|:----------------------|-------:|
| integrating heterogenous overlapping databases through object-oriented transformations | vanja josifovski , tore risch | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2570
rtable_id: 848
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 ores temporal database management system | babis theodoulidis , george karvelis , jayant chaudhary , aziz ait-braham , simon sou , george andrianopoulos | sigmod conference |   1994 |

Entity B:
| title                                                                                            | authors                             | venue             |   year |
|:-------------------------------------------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| constructing the next 100 database management systems : like the handyman or like the engineer ? | andreas geppert , klaus r. dittrich | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 78
rtable_id: 1697
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 |
|:---------------------------------------------------------------|:---------------------------------------|:--------|-------:|
| synchronization and recovery in a client-server storage system | alexandros biliris , euthimios panagos | vldb j. |   1997 |

Entity B:
| title                                                                           | authors                      | venue                                          |   year |
|:--------------------------------------------------------------------------------|:-----------------------------|:-----------------------------------------------|-------:|
| efficient transparent application recovery in client-server information systems | david lomet , gerhard weikum | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 971
rtable_id: 185
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 |
|:----------------------------------------------------------------------------------------------|:----------------------------------------|:--------|-------:|
| characterization of database access pattern for analytic prediction of buffer hit probability | jen-yao chung , asit dan , philip s. yu | vldb j. |   1995 |

Entity B:
| title                                                                                         | authors                                 | venue                                                                  |   year |
|:----------------------------------------------------------------------------------------------|:----------------------------------------|:-----------------------------------------------------------------------|-------:|
| characterization of database access pattern for analytic prediction of buffer hit probability | asit dan , philip s. yu , jen yao chung | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1928
rtable_id: 630
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 tv-tree : an index structure for high-dimensional data | king-ip lin , h. v. jagadish , christos faloutsos | vldb j. |   1994 |

Entity B:
| title                                                                                      | authors                                                                                  | venue                                          |   year |
|:-------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| epsilon grid order : an algorithm for the similarity join on massive high-dimensional data | christian b &#246; hm , bernhard braunm &#252; ller , florian krebs , hans-peter kriegel | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 272
rtable_id: 313
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 |
|:------------------------------------------------------------------------|:-------------------------------------------|:--------|-------:|
| algorithms for materialized view design in data warehousing environment | kamalakar karlapalem , jian yang , qing li | vldb    |   1997 |

Entity B:
| title                                                                   | authors                                    | venue                 |   year |
|:------------------------------------------------------------------------|:-------------------------------------------|:----------------------|-------:|
| algorithms for materialized view design in data warehousing environment | jian yang , kamalakar karlapalem , qing li | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 744
rtable_id: 1072
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 |
|:------------------------------------------------|:------------------------------------------------------|:------------------|-------:|
| using the calanda time series management system | werner dreyer , angelika kotz dittrich , duri schmidt | sigmod conference |   1995 |

Entity B:
| title                                           | authors                                               | venue                                          |   year |
|:------------------------------------------------|:------------------------------------------------------|:-----------------------------------------------|-------:|
| using the calanda time series management system | werner dreyer , angelika kotz dittrich , duri schmidt | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1870
rtable_id: 1938
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 |
|:--------------------------|:----------------------------------------------------|:------------------|-------:|
| sequence query processing | raghu ramakrishnan , miron livny , praveen seshadri | sigmod conference |   1994 |

Entity B:
| title                                                     | authors                                                                  | venue                                          |   year |
|:----------------------------------------------------------|:-------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| genesys : a system for efficient spatial query processing | thomas brinkhoff , hans-peter kriegel , ralf schneider , bernhard seeger | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1533
rtable_id: 1674
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 algorithms for high-dimensional similarity joins for data mining applications | rakesh agrawal , john c. shafer | vldb    |   1997 |

Entity B:
| title                                                                                      | authors                                                                                  | venue                                          |   year |
|:-------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| epsilon grid order : an algorithm for the similarity join on massive high-dimensional data | christian b &#246; hm , bernhard braunm &#252; ller , florian krebs , hans-peter kriegel | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 103
rtable_id: 313
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 dedale system for complex spatial queries | luc segoufin , philippe rigaux , stéphane grumbach | sigmod conference |   1998 |

Entity B:
| title                                                     | authors                                                                  | venue                                          |   year |
|:----------------------------------------------------------|:-------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| genesys : a system for efficient spatial query processing | thomas brinkhoff , hans-peter kriegel , ralf schneider , bernhard seeger | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 959
rtable_id: 1674
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 |
|:------------------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| exploiting constraint-like data characterizations in query optimization | jarek gryz , calisto zuzarte , parke godfrey | sigmod conference |   2001 |

Entity B:
| title                                                                   | authors                                      | venue                                          |   year |
|:------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| exploiting constraint-like data characterizations in query optimization | parke godfrey , jarek gryz , calisto zuzarte | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 205
rtable_id: 276
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 |
|:---------------------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| geo/environmental and medical data management in the rasdaman system | norbert widmann , paula furtado , peter baumann , roland ritsch | vldb    |   1997 |

Entity B:
| title                                                                          | authors                                 | venue             |   year |
|:-------------------------------------------------------------------------------|:----------------------------------------|:------------------|-------:|
| integrating modelling systems for environmental management information systems | david j. abel , kerry taylor , dean kun | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2426
rtable_id: 1906
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 activities in database management and information retrieval at the university of illinois at chicago | a. prasad sistla , isabel f. cruz , ashfaq a. khokhar , clement t. yu , bing liu , ouri wolfson | sigmod record |   2002 |

Entity B:
| title                                           | authors                                                                                                                 | venue             |   year |
|:------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| database research at the university of oklahoma | le gruenwald , leonard brown , ravi dirckze , sylvain guinepain , carlos sanchez , brian summers , sirirut vanichayobon | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 433
rtable_id: 93
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 |
|:-------------------------------------------------------------------------------|:------------------------------------------------------------------|:--------|-------:|
| coarse-grained optimization : techniques for rewriting sql statement sequences | bernhard mitschang , tobias kraft , holger schwarz , ralf rantzau | vldb    |   2003 |

Entity B:
| title                                         | authors                                          | venue                                          |   year |
|:----------------------------------------------|:-------------------------------------------------|:-----------------------------------------------|-------:|
| fundamental techniques for order optimization | david simmen , eugene shekita , timothy malkemus | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 517
rtable_id: 1957
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 |
|:---------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| birch : an efficient data clustering method for very large databases | raghu ramakrishnan , miron livny , tian zhang | sigmod conference |   1996 |

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: 1
original: ltable_id: 144
rtable_id: 1961
label: 1