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 |
|:---------------------------------------------|:--------------------------|:--------|-------:|
| optimal clip ordering for multi-clip queries | raymond t. ng , paul shum | vldb j. |   1998 |

Entity B:
| title                                        | authors                   | venue                                                                  |   year |
|:---------------------------------------------|:--------------------------|:-----------------------------------------------------------------------|-------:|
| optimal clip ordering for multi-clip queries | raymond t. ng , paul shum | the vldb journal -- the international journal on very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 768
rtable_id: 1170
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 |
|:----------------------------------------------------------------------------|:-------------|:----------------------------|-------:|
| query evaluation in deductive databases with alternating fixpoint semantics | weidong chen | acm trans . database syst . |   1995 |

Entity B:
| title                                             | authors         | venue                                         |   year |
|:--------------------------------------------------|:----------------|:----------------------------------------------|-------:|
| tail recursion elimination in deductive databases | kenneth a. ross | acm transactions on database systems ( tods ) |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2094
rtable_id: 1945
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 |
|:---------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| lore : a lightweight object repository for semistructured data | janet l. wiener , jason mchugh , serge abiteboul , qingshan luo , anand rajaraman , dallan quass , jeffrey d. ullman , roy goldman , hugo rivero , jennifer widom , svetlozar nestorov , kevin haas | sigmod conference |   1996 |

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



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

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

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

Entity A:
| title                                                       | authors                       | venue   |   year |
|:------------------------------------------------------------|:------------------------------|:--------|-------:|
| using latency-recency profiles for data delivery on the web | louiqa raschid , laura bright | vldb    |   2002 |

Entity B:
| title                                                                      | authors                                   | venue                 |   year |
|:---------------------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| update propagation strategies for improving the quality of data on the web | alexandros labrinidis , nick roussopoulos | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1216
rtable_id: 1347
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 |
|:-----------------------------------------------------------------------------------|:-------------------------------------------------|:--------|-------:|
| bulk-loading techniques for object databases and an application to relational data | claude delobel , sophie cluet , sihem amer-yahia | vldb    |   1998 |

Entity B:
| title                                                                                      | authors    | venue             |   year |
|:-------------------------------------------------------------------------------------------|:-----------|:------------------|-------:|
| application of oodb and sgml techniques in text database : an electronic dictionary system | jian zhang | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 397
rtable_id: 1660
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 |
|:----------------------------------------------------------------------------|:-------------------------------------------------------------------------------|:------------------|-------:|
| on supporting containment queries in relational database management systems | guy m. lohman , david j. dewitt , qiong luo , jeffrey f. naughton , chun zhang | sigmod conference |   2001 |

Entity B:
| title                                                     | authors        | venue             |   year |
|:----------------------------------------------------------|:---------------|:------------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | acm sigmod record |   1996 |



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

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

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

Entity A:
| title                                  | authors           | venue         |   year |
|:---------------------------------------|:------------------|:--------------|-------:|
| materialized views and data warehouses | nick roussopoulos | sigmod record |   1998 |

Entity B:
| title                                                         | authors                                              | venue             |   year |
|:--------------------------------------------------------------|:-----------------------------------------------------|:------------------|-------:|
| efficient materialization and use of views in data warehouses | m &#225; rcio farias de souza , marcus costa sampaio | acm sigmod record |   1999 |



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

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

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

Entity A:
| title                                                                         | authors                             | venue             |   year |
|:------------------------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| optimizing queries using materialized views : a practical , scalable solution | per-åke larson , jonathan goldstein | sigmod conference |   2001 |

Entity B:
| title                                                            | authors                        | venue                                                                  |   year |
|:-----------------------------------------------------------------|:-------------------------------|:-----------------------------------------------------------------------|-------:|
| minicon : a scalable algorithm for answering queries using views | rachel pottinger , alon halevy | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 462
rtable_id: 2105
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 |
|:-------------------------------------------------------|:--------------------------------------------------------------------------------|:------------------|-------:|
| gigascope : a stream database for network applications | theodore johnson , charles d. cranor , oliver spatscheck , vladislav shkapenyuk | sigmod conference |   2003 |

Entity B:
| title                                              | authors                                                          | venue                                          |   year |
|:---------------------------------------------------|:-----------------------------------------------------------------|:-----------------------------------------------|-------:|
| acdn : a content delivery network for applications | pradnya karbhari , michael rabinovich , zhen xiao , fred douglis | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1578
rtable_id: 714
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 |
|:---------------------------------------|:------------------------------------------------------------------------------|:------------------|-------:|
| strudel : a web-site management system | alon y. levy , mary f. fernandez , jaewoo kang , daniela florescu , dan suciu | sigmod conference |   1997 |

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: 688
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 |
|:------------------|:-----------------|:--------------|-------:|
| information rules | dale a. stirling | sigmod record |   2003 |

Entity B:
| title             | authors          | venue             |   year |
|:------------------|:-----------------|:------------------|-------:|
| information rules | dale a. stirling | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 405
rtable_id: 2138
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 |
|:-----------|:-----------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| datasplash | vuk ercegovac , allison woodruff , michael stonebraker , mark lin , mybrid spalding , alexander aiken , chris olston , michael chu | sigmod conference |   1998 |

Entity B:
| title      | authors                                                                                                                            | venue                                          |   year |
|:-----------|:-----------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| datasplash | chris olston , allison woodruff , alexander aiken , michael chu , vuk ercegovac , mark lin , mybrid spalding , michael stonebraker | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 619
rtable_id: 154
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 |
|:-------------------------------------------------------------|:---------------------------------------|:------------------|-------:|
| implementation of magic-sets in a relational database system | inderpal singh mumick , hamid pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                                         | authors                                                           | venue                                         |   year |
|:------------------------------------------------------------------------------|:------------------------------------------------------------------|:----------------------------------------------|-------:|
| specification and implementation of exceptions in workflow management systems | fabio casati , stefano ceri , stefano paraboschi , guiseppe pozzi | acm transactions on database systems ( tods ) |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 341
rtable_id: 109
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 |
|:--------------------------------------|:-------------------------------------------------|:------------------|-------:|
| rights protection for relational data | sunil prabhakar , radu sion , mikhail j. atallah | sigmod conference |   2003 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1915
rtable_id: 1320
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 |
|:--------------------------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| structures for manipulating proposed updates in object-oriented databases | richard hull , mohammed rupawalla , michael doherty | sigmod conference |   1996 |

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: 1799
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 |
|:------------------------------------------------------------|:------------------------------------|:----------------------------|-------:|
| a modified random perturbation method for database security | norman s. matloff , patrick tendick | acm trans . database syst . |   1994 |

Entity B:
| title                                        | authors                                     | venue                                         |   year |
|:---------------------------------------------|:--------------------------------------------|:----------------------------------------------|-------:|
| security of random data perturbation methods | krishnamurty muralidhar , rathindra sarathy | acm transactions on database systems ( tods ) |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 126
rtable_id: 80
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 |
|:-----------------------------------------------------------------------|:-----------------------------|:--------------|-------:|
| unisql 's next-generation object-relational database management system | phil janus , albert d'andrea | sigmod record |   1996 |

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: 9
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 |
|:----------------------------------------|:----------------------------------------------------------|:--------|-------:|
| data management for pervasive computing | mitch cherniack , stanley b. zdonik , michael j. franklin | vldb    |   2001 |

Entity B:
| title                                                                 | authors                                            | venue             |   year |
|:----------------------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| business data management for business-to-business electronic commerce | christoph quix , mareike schoop , manfred jeusfeld | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1061
rtable_id: 664
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 nd-tree : a dynamic indexing technique for multidimensional non-ordered discrete data spaces | gang qian , qiang xue , sakti pramanik , qiang zhu | vldb    |   2003 |

Entity B:
| title                                                      | authors                                           | venue                                                                  |   year |
|:-----------------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| the tv-tree : an index structure for high-dimensional data | king ip lin , h. v. jagadish , christos faloutsos | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 203
rtable_id: 585
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 |
|:--------------------------------------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| wavecluster : a multi-resolution clustering approach for very large spatial databases | surojit chatterjee , gholamhosein sheikholeslami , aidong zhang | vldb    |   1998 |

Entity B:
| title                                                                                 | authors                                                         | venue                 |   year |
|:--------------------------------------------------------------------------------------|:----------------------------------------------------------------|:----------------------|-------:|
| wavecluster : a multi-resolution clustering approach for very large spatial databases | gholamhosein sheikholeslami , surojit chatterjee , aidong zhang | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2271
rtable_id: 776
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 multi-feature queries for image databases | ulrich güntzer , werner kießling , wolf-tilo balke | vldb    |   2000 |

Entity B:
| title                                          | authors                                                        | venue                 |   year |
|:-----------------------------------------------|:---------------------------------------------------------------|:----------------------|-------:|
| optimizing queries across diverse data sources | laura m. haas , donald kossmann , edward l. wimmers , jun yang | very large data bases |   1997 |



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

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

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

Entity A:
| title                                                                     | authors                                          | venue   |   year |
|:--------------------------------------------------------------------------|:-------------------------------------------------|:--------|-------:|
| using versions in update transactions : application to integrity checking | dimitri tombroff , eric simon , françois llirbat | vldb    |   1997 |

Entity B:
| title                                                                     | authors                                                 | venue                 |   year |
|:--------------------------------------------------------------------------|:--------------------------------------------------------|:----------------------|-------:|
| using versions in update transactions : application to integrity checking | fran &#231; ois llirbat , eric simon , dimitri tombroff | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2291
rtable_id: 936
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 |
|:-----------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:------------------|-------:|
| approximating multi-dimensional aggregate range queries over real attributes | carlotta domeniconi , vassilis j. tsotras , george kollios , dimitrios gunopulos | sigmod conference |   2000 |

Entity B:
| title                                                                                | authors                         | venue                                          |   year |
|:-------------------------------------------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| approximate computation of multidimensional aggregates of sparse data using wavelets | jeffrey scott vitter , min wang | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2268
rtable_id: 202
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 |
|:--------------------------------------------------------|:------------------------------------------------------------------------------|:------------------|-------:|
| dna-miner : a system prototype for mining dna sequences | jiawei han , liangyou chen , jian pei , ying lu , yaqin liao , hasan m. jamil | sigmod conference |   2001 |

Entity B:
| title                                                 | authors                                              | venue                                          |   year |
|:------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| geominer : a system prototype for spatial data mining | jaiwei han , krzysztof koperski , nebojsa stefanovic | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 943
rtable_id: 1867
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 |
|:---------------------------------------------------|:---------------------------------|:--------|-------:|
| secure bufering in firm real-time database systems | jayant r. haritsa , binto george | vldb j. |   2000 |

Entity B:
| title                                                     | authors                                             | venue             |   year |
|:----------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| improving timeliness in real-time secure database systems | sang h. son , rasikan david , bhavani thuraisingham | acm sigmod record |   1996 |



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

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

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

Entity A:
| title                                                                        | authors                                            | venue         |   year |
|:-----------------------------------------------------------------------------|:---------------------------------------------------|:--------------|-------:|
| a comparison of three user interfaces to relational microcomputer data bases | carl medsker , margaret christensen , il-yeol song | sigmod record |   1995 |

Entity B:
| title                                                                        | authors                                            | venue             |   year |
|:-----------------------------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| a comparison of three user interfaces to relational microcomputer data bases | carl medsker , margaret christensen , il-yeol song | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1960
rtable_id: 1582
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 |
|:-----------------------------------------------------------------|:--------------------------------------------------------------------------------------------------|:--------------|-------:|
| deeds towards a distributed and active real-time database system | joakim eriksson , jonas mellin , sten andler , mikael berndtsson , bengt eftring , jörgen hansson | sigmod record |   1996 |

Entity B:
| title                                                          | authors                                                                   | venue                                          |   year |
|:---------------------------------------------------------------|:--------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| disima : a distributed and interoperable image database system | vincent oria , m. tamer &#214; zsu , paul j. iglinski , shu lin , bin yao | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2315
rtable_id: 400
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 |
|:-------------------------------------------------------|:-------------------|:--------|-------:|
| searching and mining fine-grained semi-structured data | soumen chakrabarti | vldb    |   2002 |

Entity B:
| title                                                              | authors                                  | venue             |   year |
|:-------------------------------------------------------------------|:-----------------------------------------|:------------------|-------:|
| semantic integration of semistructured and structured data sources | s. bergamaschi , s. castano , m. vincini | acm sigmod record |   1999 |



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

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

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

Entity A:
| title                                                                            | authors                                                       | venue   |   year |
|:---------------------------------------------------------------------------------|:--------------------------------------------------------------|:--------|-------:|
| schemasql - a language for interoperability in relational multi-database systems | fereidoon sadri , laks v. s. lakshmanan , iyer n. subramanian | vldb    |   1996 |

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



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

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

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

Entity A:
| title                                       | authors                                                                    | venue   |   year |
|:--------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| approximate query processing using wavelets | kyuseok shim , kaushik chakrabarti , minos n. garofalakis , rajeev rastogi | vldb    |   2000 |

Entity B:
| title                     | authors                                             | venue                                          |   year |
|:--------------------------|:----------------------------------------------------|:-----------------------------------------------|-------:|
| sequence query processing | praveen seshadri , miron livny , raghu ramakrishnan | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2308
rtable_id: 1640
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 |
|:------------------------------------------------------|:------------------------------------------------------------------------------------------|:------------------|-------:|
| update propagation protocols for replicated databases | raghavan komondoor , abraham silberschatz , yuri breitbart , s. seshadri , rajeev rastogi | sigmod conference |   1999 |

Entity B:
| title                                                                                  | authors                     | venue                                                                  |   year |
|:---------------------------------------------------------------------------------------|:----------------------------|:-----------------------------------------------------------------------|-------:|
| update propagation strategies to improve freshness in lazy master replicated databases | esther pacitti , eric simon | the vldb journal -- the international journal on very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1248
rtable_id: 1222
label: 0