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 |
|:---------------------------------------------|:------------------------------------------------------------|:--------------|-------:|
| digital library services in mobile computing | evaggelia pitoura , melliyal annamalai , bharat k. bhargava | sigmod record |   1995 |

Entity B:
| title                                              | authors                                                        | venue             |   year |
|:---------------------------------------------------|:---------------------------------------------------------------|:------------------|-------:|
| quality of service in multimedia digital libraries | elisa bertino , ahmed k. elmagarmid , mohand-sa &#239; d hacid | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2566
rtable_id: 478
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 selection in a multidimensional database | ernest teniente , elena baralis , stefano paraboschi | vldb    |   1997 |

Entity B:
| title                                                                                | authors                                         | venue                                                                  |   year |
|:-------------------------------------------------------------------------------------|:------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| optimizing multiple dimensional queries simultaneously in multidimensional databases | weifa liang , maria e. orlowska , jeffrey x. yu | the vldb journal -- the international journal on very large data bases |   2000 |



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

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

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

Entity A:
| title                                        | authors                                            | venue   |   year |
|:---------------------------------------------|:---------------------------------------------------|:--------|-------:|
| algorithms for querying by spatial structure | nikos mamoulis , dimitris papadias , vasilis delis | vldb    |   1998 |

Entity B:
| title                                        | authors                                            | venue                 |   year |
|:---------------------------------------------|:---------------------------------------------------|:----------------------|-------:|
| algorithms for querying by spatial structure | dimitris papadias , nikos mamoulis , vasilis delis | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 772
rtable_id: 962
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 |
|:----------------------------------------------------------------------------------------|:---------------------------|:------------------|-------:|
| efficient and cost-effective techniques for browsing and indexing large video databases | kien a. hua , jung-hwan oh | sigmod conference |   2000 |

Entity B:
| title                                                                                        | authors                                              | venue                                          |   year |
|:---------------------------------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| efficient and effective metasearch for text databases incorporating linkages among documents | clement yu , weiyi meng , wensheng wu , king-lup liu | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 595
rtable_id: 296
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 |
|:--------------------------------------------------------------------------------|:----------------------------|:------------------|-------:|
| semint : a system prototype for semantic integration in heterogeneous databases | wen-syan li , chris clifton | sigmod conference |   1995 |

Entity B:
| title                                                   | authors                 | venue             |   year |
|:--------------------------------------------------------|:------------------------|:------------------|-------:|
| semantic interoperability in global information systems | a. m. ouksel , a. sheth | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 118
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 |
|:---------------------------------------|:--------------------------------------------------------------------------------------------|:--------|-------:|
| load shedding in a data stream manager | michael stonebraker , nesime tatbul , mitch cherniack , stanley b. zdonik , ugur çetintemel | 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: 991
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 |
|:-----------------------------------------------|:-----------------------------------------------------------------------|:------------------|-------:|
| domino : databases for moving objects tracking | jutai zhou , ouri wolfson , sam chamberlain , a. prasad sistla , bo xu | sigmod conference |   1999 |

Entity B:
| title                                          | authors                                                             | venue                                          |   year |
|:-----------------------------------------------|:--------------------------------------------------------------------|:-----------------------------------------------|-------:|
| domino : databases for moving objects tracking | ouri wolfson , prasad sistla , bo xu , jutai zhou , sam chamberlain | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2017
rtable_id: 19
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 processing techniques for arrays | arunprasad p. marathe , kenneth salem | vldb j. |   2002 |

Entity B:
| title                                                    | authors                                     | venue                                          |   year |
|:---------------------------------------------------------|:--------------------------------------------|:-----------------------------------------------|-------:|
| query execution techniques for caching expensive methods | joseph m. hellerstein , jeffrey f. naughton | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 976
rtable_id: 1991
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 |
|:------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| dynamic multidimensional histograms | piotr indyk , sudipto guha , nitin thaper , nick koudas | sigmod conference |   2002 |

Entity B:
| title                                           | authors                                        | venue                 |   year |
|:------------------------------------------------|:-----------------------------------------------|:----------------------|-------:|
| dynamic maintenance of wavelet-based histograms | yossi matias , jeffrey scott vitter , min wang | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 699
rtable_id: 1392
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 |
|:------------------------------------------------------|:---------------------------------------------------------|:------------------|-------:|
| towards effective and efficient free space management | marvin h. solomon , michael j. carey , mark l. mcauliffe | sigmod conference |   1996 |

Entity B:
| title                                                 | authors                                                  | venue                                          |   year |
|:------------------------------------------------------|:---------------------------------------------------------|:-----------------------------------------------|-------:|
| towards effective and efficient free space management | mark l. mcauliffe , michael j. carey , marvin h. solomon | international conference on management of data |   1996 |



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

Entity B:
| title                                          | authors        | venue                                          |   year |
|:-----------------------------------------------|:---------------|:-----------------------------------------------|-------:|
| catalog management in websphere commerce suite | thomas maguire | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1908
rtable_id: 266
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 for earth system science | james frew , jeff dozier | sigmod record |   1997 |

Entity B:
| title                                   | authors                                                   | venue                 |   year |
|:----------------------------------------|:----------------------------------------------------------|:----------------------|-------:|
| data management for pervasive computing | mitch cherniack , michael j. franklin , stanley b. zdonik | very large data bases |   2001 |



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

Entity B:
| title                                             | authors                                                                                                                        | venue                 |   year |
|:--------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| on the computation of multidimensional aggregates | sameet agarwal , rakesh agrawal , prasad deshpande , ashish gupta , jeffrey f. naughton , raghu ramakrishnan , sunita sarawagi | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 900
rtable_id: 1041
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 computation of iceberg cubes with complex measures | guozhu dong , jian pei , jiawei han , ke wang | sigmod conference |   2001 |

Entity B:
| title                                | authors                             | venue                 |   year |
|:-------------------------------------|:------------------------------------|:----------------------|-------:|
| fast computation of sparse datacubes | kenneth a. ross , divesh srivastava | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 290
rtable_id: 942
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 challenge of process data warehousing | matthias jarke , jörg köller , thomas list | vldb    |   2000 |

Entity B:
| title                                     | authors                                                  | venue                 |   year |
|:------------------------------------------|:---------------------------------------------------------|:----------------------|-------:|
| the challenge of process data warehousing | matthias jarke , thomas list , j &#246; rg k &#246; ller | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2358
rtable_id: 869
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 |
|:-----------------------------------------------------------------------------|:-------------------------------------------|:--------|-------:|
| distributed top-n query processing with possibly uncooperative local systems | clement t. yu , weiyi meng , george philip | vldb    |   2003 |

Entity B:
| title                                                        | authors                                            | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------------------|:-----------------------------------------------|-------:|
| revisiting commit processing in distributed database systems | ramesh gupta , jayant haritsa , krithi ramamritham | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2242
rtable_id: 1831
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 efficient method for checking object-oriented database schema correctness | michele missikoff , anna formica , hans dietmar gröger | acm trans . database syst . |   1998 |

Entity B:
| title                                                                         | authors                          | venue                 |   year |
|:------------------------------------------------------------------------------|:---------------------------------|:----------------------|-------:|
| accessing a relational database through an object-oriented database interface | jack a. orenstein , d. n. kamber | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 639
rtable_id: 1463
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 |
|:--------------------------------------------------------------------------------|:-------------------------------------------------------------|:------------------|-------:|
| storhouse metanoia - new applications for database , storage & data warehousing | felipe cariño , pekka kostamaa , art kaufmann , john burgess | sigmod conference |   2001 |

Entity B:
| title                                                       | authors                                                                            | venue                                          |   year |
|:------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| web caching for database applications with oracle web cache | jesse anton , lawrence jacobs , xiang liu , jordan parker , zheng zeng , tie zhong | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2050
rtable_id: 722
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 |
|:-------------------------------------|:------------|:--------------|-------:|
| implementing deletion in b + - trees | jan jannink | sigmod record |   1995 |

Entity B:
| title               | authors     | venue                                          |   year |
|:--------------------|:------------|:-----------------------------------------------|-------:|
| implementing xquery | paul cotton | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1438
rtable_id: 760
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 |
|:---------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| combining multi-visual features for efficient indexing in a large image database | quan z. sheng , anne h. h. ngu , ron lei , du q. huynh | vldb j. |   2001 |

Entity B:
| title                                                                                   | authors                   | venue                                          |   year |
|:----------------------------------------------------------------------------------------|:--------------------------|:-----------------------------------------------|-------:|
| efficient and cost-effective techniques for browsing and indexing large video databases | junghwan oh , kien a. hua | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1560
rtable_id: 445
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 |
|:-------------------------------------------------|:----------------------------------------------|:--------|-------:|
| type classification of semi-structured documents | allen luniewski , markus tresch , neal palmer | vldb    |   1995 |

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: 1048
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 |
|:--------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| the aqua approximate query answering system | sridhar ramaswamy , swarup acharya , phillip b. gibbons , viswanath poosala | sigmod conference |   1999 |

Entity B:
| title                                                                         | authors                           | venue                                          |   year |
|:------------------------------------------------------------------------------|:----------------------------------|:-----------------------------------------------|-------:|
| new sampling-based summary statistics for improving approximate query answers | phillip b. gibbons , yossi matias | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2022
rtable_id: 1794
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 |
|:----------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| generalized search trees for database systems | jeffrey f. naughton , avi pfeffer , joseph m. hellerstein | vldb    |   1995 |

Entity B:
| title                                                 | authors                              | venue                                          |   year |
|:------------------------------------------------------|:-------------------------------------|:-----------------------------------------------|-------:|
| recovery protocols for shared memory database systems | lory d. molesky , krithi ramamritham | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2210
rtable_id: 1594
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 |
|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| constructing efficient decision trees by using optimized numeric association rules | takeshi fukuda , yasuhiko morimoto , takeshi tokuyama , shinichi morishita | vldb    |   1996 |

Entity B:
| title                                                        | authors                                                                    | venue                                         |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------|:----------------------------------------------|-------:|
| data mining with optimized two-dimensional association rules | takeshi fukuda , yasuhiko morimoto , shimichi morishita , takeshi tokuyama | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2132
rtable_id: 328
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 processing techniques for arrays | kenneth salem , arunprasad p. marathe | sigmod conference |   1999 |

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: 1126
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 |
|:-------------------------------|:--------------|:--------------|-------:|
| describing semistructured data | luca cardelli | sigmod record |   2001 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1310
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 |
|:---------------------------------------|:--------------------------|:----------------------------|-------:|
| answering queries with useful bindings | edward y. chang , chen li | acm trans . database syst . |   2001 |

Entity B:
| title                                                  | authors                         | venue                 |   year |
|:-------------------------------------------------------|:--------------------------------|:----------------------|-------:|
| a scalable algorithm for answering queries using views | rachel pottinger , alon y. levy | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1356
rtable_id: 866
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 aditi deductive database system | kotagiri ramamohanarao , david b. kemp , jayen vaghani , tim s. leask , james harland , peter j. stuckey , zoltan somogyi | vldb j. |   1994 |

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



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

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

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

Entity A:
| title                                                                       | authors                                                 | venue         |   year |
|:----------------------------------------------------------------------------|:--------------------------------------------------------|:--------------|-------:|
| the design and performance evaluation of alternative xml storage strategies | david j. dewitt , jianjun chen , chun zhang , feng tian | sigmod record |   2002 |

Entity B:
| title                                                                       | authors                                                 | venue             |   year |
|:----------------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| the design and performance evaluation of alternative xml storage strategies | feng tian , david j. dewitt , jianjun chen , chun zhang | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 706
rtable_id: 345
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 |
|:-------------------------------------|:-----------------|:--------|-------:|
| high-performance extensible indexing | marcel kornacker | vldb    |   1999 |

Entity B:
| title                                                | authors                                                                                                           | venue                                          |   year |
|:-----------------------------------------------------|:------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| high-performance sorting on networks of workstations | andrea c. arpaci-dusseau , remzi h. arpaci-dusseau , david e. culler , joseph m. hellerstein , david a. patterson | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1344
rtable_id: 1811
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 |
|:------------------------|:--------------------------------------|:------------------|-------:|
| online query processing | peter j. haas , joseph m. hellerstein | sigmod conference |   2001 |

Entity B:
| title                                      | authors                                                  | venue                 |   year |
|:-------------------------------------------|:---------------------------------------------------------|:----------------------|-------:|
| toward learning based web query processing | yanlei diao , hongjun lu , songting chen , zengping tian | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1489
rtable_id: 860
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 |
|:---------------------------------------------------|:-------------------|:------------------|-------:|
| extracting and exploiting structure in text search | prabhakar raghavan | sigmod conference |   2003 |

Entity B:
| title                                      | authors                                               | venue                                          |   year |
|:-------------------------------------------|:------------------------------------------------------|:-----------------------------------------------|-------:|
| extracting schema from semistructured data | svetlozar nestorov , serge abiteboul , rajeev motwani | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 867
rtable_id: 1799
label: 0