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 |
|:-----------------------------------------|:--------------------------------------------------------------------------------------|:--------------|-------:|
| database research at columbia university | kenneth a. ross , gail e. kaiser , luis gravano , salvatore j. stolfo , shih-fu chang | sigmod record |   1998 |

Entity B:
| title                                     | authors                                                                      | venue             |   year |
|:------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| the database research group at eth zurich | moira c. norrie , stephen m. blott , hans-j &#246; rg schek , gerhard weikum | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1139
rtable_id: 1704
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 |
|:----------------------------------------------|:--------------------------------|:--------------|-------:|
| phoenix project : fault-tolerant applications | roger s. barga , david b. lomet | sigmod record |   2002 |

Entity B:
| title                                | authors                      | venue                                          |   year |
|:-------------------------------------|:-----------------------------|:-----------------------------------------------|-------:|
| phoenix : making applications robust | roger barga , david b. lomet | international conference on management of data |   1999 |



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

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

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

Entity A:
| title                                             | authors                                    | venue             |   year |
|:--------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| query optimization in compressed database systems | zhiyuan chen , flip korn , johannes gehrke | sigmod conference |   2001 |

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: 1892
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 |
|:--------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| information systems research at george mason university | sushil jajodia , amihai motro , edgar h. sibley , alexander brodsky , larry kerschberg , xiaoyang sean wang , daniel barbará | sigmod record |   1997 |

Entity B:
| title                                                  | authors                                                                                                       | venue             |   year |
|:-------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| research and practice in federated information systems | w. hasselbring , w.-j . van den heuvel , g. j. houben , r.-d . kutsche , b. rieger , m. roantree , k. subieta | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1355
rtable_id: 451
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 |
|:---------------------------------------------------|:------------|:--------------|-------:|
| converting relational to object-oriented databases | joseph fong | sigmod record |   1997 |

Entity B:
| title                                                                                    | authors                  | venue                 |   year |
|:-----------------------------------------------------------------------------------------|:-------------------------|:----------------------|-------:|
| join index hierarchies for supporting efficient navigations in object-oriented databases | zhaohui xie , jiawei han | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 2259
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 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 |
|:--------------------------------------------------------------------------|:--------------------------|:----------------------|-------:|
| the hcc-tree : an efficient index structure for object oriented databases | b. sreenath , s. seshadri | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 272
rtable_id: 1427
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 |
|:--------------------------------------------------------|:-----------------------------------------|:------------------|-------:|
| statistical synopses for graph-structured xml databases | minos n. garofalakis , neoklis polyzotis | sigmod conference |   2002 |

Entity B:
| title                                       | authors                                                                           | venue             |   year |
|:--------------------------------------------|:----------------------------------------------------------------------------------|:------------------|-------:|
| constraints for semistructured data and xml | peter buneman , wenfei fan , j &#233; r &#244; me sim &#233; on , scott weinstein | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2040
rtable_id: 476
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 exploration of large scientific databases | gustavo alonso , etzard stolte | vldb    |   2002 |

Entity B:
| title                                                           | authors                        | venue                                         |   year |
|:----------------------------------------------------------------|:-------------------------------|:----------------------------------------------|-------:|
| fast algorithms for universal quantification in large databases | goetz graefe , richard l. cole | acm transactions on database systems ( tods ) |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2409
rtable_id: 1571
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 |
|:-----------------------------------------------|:-------------------------------|:------------------|-------:|
| optimization of dynamic query evaluation plans | goetz graefe , richard l. cole | sigmod conference |   1994 |

Entity B:
| title                                          | authors                        | venue                                          |   year |
|:-----------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| optimization of dynamic query evaluation plans | richard l. cole , goetz graefe | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 366
rtable_id: 1719
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 |
|:----------------------------------|:---------------|:------------------|-------:|
| data management challenges in crm | george colliat | sigmod conference |   2003 |

Entity B:
| title                                                           | authors                                                                                                                                                                                                                   | venue             |   year |
|:----------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| evolution and change in data management - issues and directions | john f. roddick , lina al-jadir , leopoldo bertossi , marlon dumas , florida estrella , heidi gregersen , kathleen hornsby , jens lufter , federica mandreoli , tomi m &#228; nnist &#246; , enric mayol , lex wedemeijer | acm sigmod record |   2000 |



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

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

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

Entity A:
| title                                       | authors                                       | venue             |   year |
|:--------------------------------------------|:----------------------------------------------|:------------------|-------:|
| an open storage system for abstract objects | lukas relly , stephen blott , hans-jörg schek | sigmod conference |   1996 |

Entity B:
| title                                  | authors                                              | venue                                          |   year |
|:---------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| an open abstract-object storage system | stephen blott , lukas relly , hans-j &#246; rg schek | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2597
rtable_id: 1982
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 cost model for clustered object-oriented databases | zhao-hui tang , jean-robert gruser , georges gardarin | vldb    |   1995 |

Entity B:
| title                                      | authors             | venue             |   year |
|:-------------------------------------------|:--------------------|:------------------|-------:|
| repositories and object oriented databases | philip a. bernstein | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 69
rtable_id: 1761
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 integrity constraints with indeterminacy | wes cowley , dimitris plexousakis | vldb    |   2000 |

Entity B:
| title                                             | authors                           | venue                 |   year |
|:--------------------------------------------------|:----------------------------------|:----------------------|-------:|
| temporal integrity constraints with indeterminacy | wes cowley , dimitris plexousakis | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 417
rtable_id: 887
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 |
|:---------------------------------------|:---------------------------------|:----------------------------|-------:|
| distance browsing in spatial databases | hanan samet , gísli r. hjaltason | acm trans . database syst . |   1999 |

Entity B:
| title                               | authors                                                        | venue                                                                  |   year |
|:------------------------------------|:---------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| effective timestamping in databases | kristian torp , christian s. jensen , richard thomas snodgrass | the vldb journal -- the international journal on very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1717
rtable_id: 1220
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 |
|:-----------------------------------------------------------------------------|:-----------------------------------------------------|:----------------------------|-------:|
| transactional client-server cache consistency : alternatives and performance | michael j. franklin , michael j. carey , miron livny | acm trans . database syst . |   1997 |

Entity B:
| title                                                    | authors                        | venue             |   year |
|:---------------------------------------------------------|:-------------------------------|:------------------|-------:|
| enhancing external consistency in real-time transactions | kwei-jay lin , ching-shan peng | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1038
rtable_id: 377
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 |
|:----------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| grid data management systems & services | reagan moore , arun jagatheesan , paul watson , norman w. paton | vldb    |   2003 |

Entity B:
| title                                    | authors                                                                                                                                                                                                 | venue                                          |   year |
|:-----------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| aurora : a data stream management system | d. abadi , d. carney , u. &#199; etintemel , m. cherniack , c. convey , c. erwin , e. galvez , m. hatoun , a. maskey , a. rasin , a. singer , m. stonebraker , n. tatbul , y. xing , r. yan , s. zdonik | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1546
rtable_id: 2010
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 |
|:----------------------------------------------------------------|:-------------------------------|:--------------|-------:|
| algebraic change propagation for semijoin and outerjoin queries | timothy griffin , bharat kumar | sigmod record |   1998 |

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



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

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

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

Entity A:
| title                                               | authors                          | venue   |   year |
|:----------------------------------------------------|:---------------------------------|:--------|-------:|
| maintaining data privacy in association rule mining | shariq rizvi , jayant r. haritsa | vldb    |   2002 |

Entity B:
| title                                               | authors                                     | venue                                          |   year |
|:----------------------------------------------------|:--------------------------------------------|:-----------------------------------------------|-------:|
| scalable parallel data mining for association rules | eui-hong han , george karypis , vipin kumar | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1287
rtable_id: 1812
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 ccube constraint object-oriented database system | alexander brodsky , pavel a. exarkhopoulo , victor e. segal , jia chen | sigmod conference |   1999 |

Entity B:
| title                                        | authors                                                                                                       | venue                                          |   year |
|:---------------------------------------------|:--------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the ores temporal database management system | babis theodoulidis , aziz ait-braham , george andrianopoulos , jayant chaudhary , george karvelis , simon sou | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 973
rtable_id: 1667
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-driven vertical class partitioning for methods in object oriented databases | qing li , chi-wai fung , kamalakar karlapalem | vldb j. |   2003 |

Entity B:
| title                                            | authors       | venue                                                                  |   year |
|:-------------------------------------------------|:--------------|:-----------------------------------------------------------------------|-------:|
| index configuration in object-oriented databases | elisa bertino | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 378
rtable_id: 591
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 |
|:--------------------------------------------------------------------------------------------------------------|:-------------|:--------------|-------:|
| report on ngits ' 99 : the 4th international workshop on next generation information technologies and systems | opher etzion | sigmod record |   1999 |

Entity B:
| title                                                                                                            | authors      | venue             |   year |
|:-----------------------------------------------------------------------------------------------------------------|:-------------|:------------------|-------:|
| report on ngits ' 99 : the fourth international workshop on next generation information technologies and systems | opher etzion | acm sigmod record |   1999 |



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

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

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

Entity A:
| title                                                                            | authors                                       | venue   |   year |
|:---------------------------------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| cost-driven vertical class partitioning for methods in object oriented databases | qing li , chi-wai fung , kamalakar karlapalem | vldb j. |   2003 |

Entity B:
| title                                                                                    | authors                  | venue                 |   year |
|:-----------------------------------------------------------------------------------------|:-------------------------|:----------------------|-------:|
| join index hierarchies for supporting efficient navigations in object-oriented databases | zhaohui xie , jiawei han | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 378
rtable_id: 2259
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 |
|:--------------------------------------------------------|:-------------------------------------------------------------------------------|:--------|-------:|
| performance issues in incremental warehouse maintenance | hector garcia-molina , wilburt labio , yingwei cui , jennifer widom , jun yang | vldb    |   2000 |

Entity B:
| title                                                  | authors                                               | venue                 |   year |
|:-------------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| fast incremental maintenance of approximate histograms | phillip b. gibbons , yossi matias , viswanath poosala | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1975
rtable_id: 1084
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 |
|:---------------------------------------------------------------|:------------------------|:-----------------------------------------------------------------------|-------:|
| synchronization and recovery in a client-server storage system | e. panagos , a. biliris | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 971
rtable_id: 1152
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 flexible and recoverable client/server database event notification system | chun xu , eric n. hanson , roxana dastur , i.-cheng chen , vijay ramaswamy , wendy tan , kurt engel | vldb j. |   1998 |

Entity B:
| title                                                                  | authors                                                               | venue                 |   year |
|:-----------------------------------------------------------------------|:----------------------------------------------------------------------|:----------------------|-------:|
| a database system for real-time event aggregation in telecommunication | jerry baulier , stephen blott , henry f. korth , abraham silberschatz | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1878
rtable_id: 991
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 impact of global clustering on spatial database systems | thomas brinkhoff , hans-peter kriegel | vldb    |   1994 |

Entity B:
| title                                                                | authors                                              | venue                 |   year |
|:---------------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| clustering categorical data : an approach based on dynamical systems | david gibson , jon m. kleinberg , prabhakar raghavan | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1415
rtable_id: 1019
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 |
|:----------------------------------|:-------------------------------|:--------------|-------:|
| metadata for multimedia documents | thomas c. rakow , klemens böhm | sigmod record |   1994 |

Entity B:
| title                           | authors                                                                   | venue             |   year |
|:--------------------------------|:--------------------------------------------------------------------------|:------------------|-------:|
| metadata for mixed-media access | francine chen , marti hearst , julian kupiec , jan pedersen , lynn wilcox | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1090
rtable_id: 1733
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 |
|:-------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| mv3r-tree : a spatio-temporal access method for timestamp and interval queries | dimitris papadias , yufei tao | vldb    |   2001 |

Entity B:
| title                                                                      | authors                                      | venue                 |   year |
|:---------------------------------------------------------------------------|:---------------------------------------------|:----------------------|-------:|
| m-tree : an efficient access method for similarity search in metric spaces | paolo ciaccia , marco patella , pavel zezula | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 616
rtable_id: 955
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 |
|:----------------------------------------------------------------------------------|:---------------------------------------------|:--------------|-------:|
| report on the fourth international conference on flexible query answering systems | gabriella pasi , amihai motro , patrick bosc | sigmod record |   2001 |

Entity B:
| title                                                                                                            | authors      | venue             |   year |
|:-----------------------------------------------------------------------------------------------------------------|:-------------|:------------------|-------:|
| report on ngits ' 99 : the fourth international workshop on next generation information technologies and systems | opher etzion | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1469
rtable_id: 480
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 design and implementation of a sequence database system | raghu ramakrishnan , miron livny , praveen seshadri | vldb    |   1996 |

Entity B:
| title                                                                  | authors       | venue                 |   year |
|:-----------------------------------------------------------------------|:--------------|:----------------------|-------:|
| design and implementation of a genetic-based algorithm for data mining | sunil choenni | very large data bases |   2000 |



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

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

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

Entity A:
| title                          | authors                         | venue             |   year |
|:-------------------------------|:--------------------------------|:------------------|-------:|
| the ecrc multi database system | heribert schütz , willem jonker | sigmod conference |   1995 |

Entity B:
| title                                                | authors                                                                | venue                                          |   year |
|:-----------------------------------------------------|:-----------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the ccube constraint object-oriented database system | alexander brodsky , victor e. segal , jia chen , paval a. exarkhopoulo | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1107
rtable_id: 4
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 |
|:-------------------|:------------|:--------------|-------:|
| book review column | karl aberer | sigmod record |   2002 |

Entity B:
| title        | authors   | venue             |   year |
|:-------------|:----------|:------------------|-------:|
| book reviews |           | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1899
rtable_id: 2129
label: 0