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 |
|:----------------------------------------------------------|:---------------|:--------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | sigmod record |   1996 |

Entity B:
| title                                                     | authors                                              | venue                 |   year |
|:----------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| materialized view selection for multidimensional datasets | amit shukla , prasad deshpande , jeffrey f. naughton | very large data bases |   1998 |



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

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

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

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

Entity B:
| title                                                           | authors                               | venue                 |   year |
|:----------------------------------------------------------------|:--------------------------------------|:----------------------|-------:|
| fast algorithms for mining association rules in large databases | rakesh agrawal , ramakrishnan srikant | very large data bases |   1994 |



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

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

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

Entity A:
| title                                                                          | authors                                                | venue   |   year |
|:-------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| index nesting - an efficient approach to indexing in object-oriented databases | jiawei han , beng chin ooi , hongjun lu , kian-lee tan | vldb j. |   1996 |

Entity B:
| title                                                                                         | authors                                                                                                                                                          | venue                 |   year |
|:----------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| xxl - a library approach to supporting efficient implementations of advanced database queries | jochen van den bercken , bj &#246; rn blohsfeld , jens-peter dittrich , j &#252; rgen kr &#228; mer , tobias sch &#228; fer , martin schneider , bernhard seeger | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1118
rtable_id: 2197
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 materialization and use of views in data warehouses | márcio farias de souza , marcus costa sampaio | sigmod record |   1999 |

Entity B:
| title                                               | authors                                                                    | venue                                          |   year |
|:----------------------------------------------------|:---------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| efficient resumption of interrupted warehouse loads | wilburt juan labio , janet l. wiener , hector garcia-molina , vlad gorelik | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 394
rtable_id: 65
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 |
|:--------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| metu object-oriented dbms | cetin ozkan , cem evrendilek , yuksel saygin , ilker altintas , ismailcem budak arpinar , mehmet altinel , tansel okay , ilker durusoy , asuman dogac | sigmod conference |   1994 |

Entity B:
| title                                           | authors                                     | venue                                         |   year |
|:------------------------------------------------|:--------------------------------------------|:----------------------------------------------|-------:|
| a taxonomy for secure object-oriented databases | martin s. olivier , sebastiaan h. von solms | acm transactions on database systems ( tods ) |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 804
rtable_id: 1317
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 oasis multidatabase prototype | john murphy , mark roantree , wilhelm hasselbring | sigmod record |   1999 |

Entity B:
| title                             | authors                                           | venue             |   year |
|:----------------------------------|:--------------------------------------------------|:------------------|-------:|
| the oasis multidatabase prototype | mark roantree , john murphy , wilhelm hasselbring | acm sigmod record |   1999 |



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

Entity B:
| title                                                           | authors                                                                            | venue                                          |   year |
|:----------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| multimediaminer : a system prototype for multimedia data mining | osmar r. za &#239; ane , jiawei han , ze-nian li , sonny h. chee , jenny y. chiang | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 140
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 |
|:--------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| selectivity estimation using probabilistic models | daphne koller , lise getoor , benjamin taskar | sigmod conference |   2001 |

Entity B:
| title                                                               | authors                                          | venue                                                                  |   year |
|:--------------------------------------------------------------------|:-------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| dynamic maintenance of data distribution for selectivity estimation | kyu young whang , sang wook kim , gio wiederhold | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 731
rtable_id: 601
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 database research group at eth zurich | hans-jörg schek , moira c. norrie , gerhard weikum , stephen blott | sigmod record |   1994 |

Entity B:
| title                                    | authors                                                                               | venue             |   year |
|:-----------------------------------------|:--------------------------------------------------------------------------------------|:------------------|-------:|
| database research at columbia university | shih-fu chang , luis gravano , gail e. kaiser , kenneth a. ross , salvatore j. stolfo | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2504
rtable_id: 229
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 hcc-tree : an efficient index structure for object oriented databases | b. sreenath , s. seshadri | vldb    |   1994 |

Entity B:
| title                                                    | authors                                                                   | venue                 |   year |
|:---------------------------------------------------------|:--------------------------------------------------------------------------|:----------------------|-------:|
| pesto : an integrated query/browser for object databases | michael j. carey , laura m. haas , vivekananda maganty , john h. williams | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2392
rtable_id: 1053
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 |
|:---------------------------------|:-------------|:------------------|-------:|
| about quark digital media system | kamar aulakh | sigmod conference |   1998 |

Entity B:
| title                            | authors      | venue                                          |   year |
|:---------------------------------|:-------------|:-----------------------------------------------|-------:|
| about quark digital media system | kamar aulakh | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1023
rtable_id: 163
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 |
|:----------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| research and practice in federated information systems , report of the efis ' 2000 international workshop | ralf-detlef kutsche , geert-jan houben , mark roantree , bodo rieger , wilhelm hasselbring , kazimierz subieta , willem-jan van den heuvel | sigmod record |   2000 |

Entity B:
| title                                                                                 | authors                           | venue             |   year |
|:--------------------------------------------------------------------------------------|:----------------------------------|:------------------|-------:|
| report on the first international workshop on efficient web-based information systems | zo &#233; lacroix , omar boucelma | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2473
rtable_id: 913
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 |
|:-----------------------------------------------------|:-----------------------------------------|:--------------|-------:|
| integrating contents and structure in text retrieval | gonzalo navarro , ricardo a. baeza-yates | sigmod record |   1996 |

Entity B:
| title                                                                        | authors         | venue                                          |   year |
|:-----------------------------------------------------------------------------|:----------------|:-----------------------------------------------|-------:|
| use of a component architecture in integrating relational and non-relational | robert atkinson | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 374
rtable_id: 1547
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 |
|:------------------------------------|:---------------------------------|:------------------|-------:|
| proxy-server architectures for olap | panos kalnis , dimitris papadias | sigmod conference |   2001 |

Entity B:
| title                                              | authors      | venue                 |   year |
|:---------------------------------------------------|:-------------|:----------------------|-------:|
| architectures for internal web services deployment | oded shmueli | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1337
rtable_id: 1354
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 |
|:-----------------------------------------------------------------|:--------------------------------------|:------------------|-------:|
| mining quantitative association rules in large relational tables | ramakrishnan srikant , rakesh agrawal | sigmod conference |   1996 |

Entity B:
| title                                                          | authors                                       | venue                                          |   year |
|:---------------------------------------------------------------|:----------------------------------------------|:-----------------------------------------------|-------:|
| an effective hash-based algorithm for mining association rules | jong soo park , ming-syan chen , philip s. yu | international conference on management of data |   1995 |



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

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

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

Entity A:
| title                                      | authors            | venue             |   year |
|:-------------------------------------------|:-------------------|:------------------|-------:|
| indexing multimedia databases ( tutorial ) | christos faloutsos | sigmod conference |   1995 |

Entity B:
| title                             | authors       | venue                                          |   year |
|:----------------------------------|:--------------|:-----------------------------------------------|-------:|
| standard for multimedia databases | john r. smith | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2524
rtable_id: 368
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 logical foundation for deductive object-oriented databases | mengchi liu , tok wang ling , gillian dobbie | acm trans . database syst . |   2002 |

Entity B:
| title                                                           | authors       | venue                                          |   year |
|:----------------------------------------------------------------|:--------------|:-----------------------------------------------|-------:|
| static detection of security flaws in object-oriented databases | keishi tajima | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2302
rtable_id: 1983
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 content-based multimedia server for massively parallel architectures | c. watson , g. linderman , euthimios panagos , t. walters , ion tim ieong , alexandros biliris , j. wang , s. choo , david schrader , p. colin , william o'connell , grace au | sigmod conference |   1996 |

Entity B:
| title                                                                                   | authors                                                                                                                                          | venue                                          |   year |
|:----------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| a teradata content-based multimedia object manager for massively parallel architectures | w. o'connell , i. t. ieong , d. schrader , c. watson , g. au , a. biliris , s. choo , p. colin , g. linderman , e. panagos , j. wang , t. walter | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2588
rtable_id: 1956
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 |
|:--------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| approximate query processing using wavelets | rajeev rastogi , minos n. garofalakis , kyuseok shim , kaushik chakrabarti | vldb j. |   2001 |

Entity B:
| title                                               | authors                                  | venue                 |   year |
|:----------------------------------------------------|:-----------------------------------------|:----------------------|-------:|
| approximate query processing : taming the terabytes | minos n. garofalakis , phillip b. gibbon | very large data bases |   2001 |



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

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

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

Entity A:
| title                                                         | authors                                                       | venue             |   year |
|:--------------------------------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| query optimization in the presence of limited access patterns | dan suciu , ioana manolescu , daniela florescu , alon y. levy | sigmod conference |   1999 |

Entity B:
| title                      | authors                       | venue                 |   year |
|:---------------------------|:------------------------------|:----------------------|-------:|
| query optimization for xml | jason mchugh , jennifer widom | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 817
rtable_id: 782
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 |
|:----------------|:--------------------|:--------------|-------:|
| editor 's notes | michael j. franklin | sigmod record |   1997 |

Entity B:
| title     | authors           | venue                                         |   year |
|:----------|:------------------|:----------------------------------------------|-------:|
| editorial | richard snodgrass | acm transactions on database systems ( tods ) |   2001 |



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

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

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

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

Entity B:
| title                                                                                      | authors                     | venue                 |   year |
|:-------------------------------------------------------------------------------------------|:----------------------------|:----------------------|-------:|
| the persistent cache : improving oid indexing in temporal object-oriented database systems | kjetil n &#248; rv &#229; g | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 78
rtable_id: 1244
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 |
|:-----------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| data grid management systems | arun jagatheesan , arcot rajasekar | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 690
rtable_id: 2250
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 |
|:------------------------------------------------------------------------|:-------------------------------|:--------|-------:|
| efficiently instantiating view-objects from remote relational databases | gio wiederhold , byung suk lee | vldb j. |   1994 |

Entity B:
| title                                                   | authors                                                                                                                     | venue                                                                  |   year |
|:--------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| efficiently publishing relational data as xml documents | jayavel shanmugasundaram , eugene shekita , rimon barr , michael carey , bruce lindsay , hamid pirahesh , berthold reinwald | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1829
rtable_id: 2107
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 |
|:---------------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| dynamat : a dynamic view management system for data warehouses | nick roussopoulos , yannis kotidis | sigmod conference |   1999 |

Entity B:
| title                                                 | authors                                                        | venue                                                                  |   year |
|:------------------------------------------------------|:---------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| monotonic complements for independent data warehouses | d. laurent , j. lechtenb &#246; rger , n. spyratos , g. vossen | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 799
rtable_id: 2108
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 |
|:------------------------------------------|:--------------------------------------------------------------------------|:--------|-------:|
| challenges for global information systems | alon y. levy , divesh srivastava , abraham silberschatz , maria zemankova | vldb    |   1994 |

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: 2430
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 |
|:------------------------------------------------------------------------------|:---------------------------------------------------------------|:------------------|-------:|
| exploratory mining and pruning optimizations of constrained association rules | alex pang , jiawei han , raymond t. ng , laks v. s. lakshmanan | sigmod conference |   1998 |

Entity B:
| title                                                                          | authors                                                        | venue                                          |   year |
|:-------------------------------------------------------------------------------|:---------------------------------------------------------------|:-----------------------------------------------|-------:|
| exploratory mining and pruning optimizations of constrained associations rules | raymond t. ng , laks v. s. lakshmanan , jiawei han , alex pang | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2051
rtable_id: 1790
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 |
|:-------------------------------------------------|:--------------|:--------|-------:|
| index configuration in object-oriented databases | elisa bertino | vldb j. |   1994 |

Entity B:
| title                                                                            | authors                                       | venue                                                                  |   year |
|:---------------------------------------------------------------------------------|:----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| cost-driven vertical class partitioning for methods in object oriented databases | chi-wai fung , kamalakar karlapalem , qing li | the vldb journal -- the international journal on very large data bases |   2003 |



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

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

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

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

Entity B:
| title                                                                                  | authors                                                    | venue                                         |   year |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------|:----------------------------------------------|-------:|
| description logics for semantic query optimization in object-oriented database systems | domenico beneventano , sonia bergamaschi , claudio sartori | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1892
rtable_id: 1236
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 |
|:------------------------------------------------------|:-----------------------------------------------------------------------------|:--------|-------:|
| monotonic complements for independent data warehouses | gottfried vossen , jens lechtenbörger , dominique laurent , nicolas spyratos | vldb j. |   2001 |

Entity B:
| title                                                          | authors                            | venue                                          |   year |
|:---------------------------------------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| dynamat : a dynamic view management system for data warehouses | yannis kotidis , nick roussopoulos | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1759
rtable_id: 53
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 |
|:----------------------------------------------------|:----------|:----------------------------|-------:|
| distributed query evaluation on semistructured data | dan suciu | acm trans . database syst . |   2002 |

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: 1480
rtable_id: 1799
label: 0