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

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 wrapping query languages and efficient xml integration | v christophides , s cluet , j simщon | sigmod conference |   2000 |

Entity B:
| title                                                           | authors                   | venue                                                                 | year   |
|:----------------------------------------------------------------|:--------------------------|:----------------------------------------------------------------------|:-------|
| j. sim eon . onwrappingquerylanguages andecient xml integration | v christophides , s cluet | proceedings of acm sigmod conf . on management of data , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 851
rtable_id: 40274
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------|:-----------|:--------|-------:|
| user-adaptive exploration of multidimensional data | s sarawagi | vldb    |   2000 |

Entity B:
| title                                      | authors                                    | venue   | year   |
|:-------------------------------------------|:-------------------------------------------|:--------|:-------|
| computation of multidimensional aggregates | pm deshpande , s agarwal , jf naughton , r |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1364
rtable_id: 22725
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 retrieval of similar shapes | d rafiei , a mendelzon | vldb j. |   2002 |

Entity B:
| title                                      | authors                           | venue                                                                    |   year |
|:-------------------------------------------|:----------------------------------|:-------------------------------------------------------------------------|-------:|
| efficient and tumble similar set retrieval | a gionis , d gunopulos , n koudas | proceedings of the 2001 acm sigmod international conference & hellip ; , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2449
rtable_id: 64146
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------|:-----------|:--------|-------:|
| explaining differences in multidimensional aggregates | s sarawagi | vldb    |   1999 |

Entity B:
| title                                           | authors                           | venue   | year   |
|:------------------------------------------------|:----------------------------------|:--------|:-------|
| set-derivability of multidimensional aggregates | j albrecht , h guenzel , w lehner |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1526
rtable_id: 35409
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                       | authors            | venue             |   year |
|:----------------------------|:-------------------|:------------------|-------:|
| optimizing queries on files | m consens , t milo | sigmod conference |   1994 |

Entity B:
| title                                     | authors                                 | venue                                                    | year   |
|:------------------------------------------|:----------------------------------------|:---------------------------------------------------------|:-------|
| optimizing queries across diverse sources | l haas , d kossmann , e wimmers , j yan | & hellip ; of the 23rd vldb conference , athens , greece |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1770
rtable_id: 62474
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 mariposa distributed database management system | j sidell  | sigmod record |   1996 |

Entity B:
| title                                                     | authors                                           | venue                    | year   |
|:----------------------------------------------------------|:--------------------------------------------------|:-------------------------|:-------|
| deeds towards a distributed and real-time database system | sa andler , j hansson , j eriksson , j mellin , m | sigmod record 25 ( 1 ) , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 758
rtable_id: 34485
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                                           | authors                                    | venue             |   year |
|:----------------------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| semantic assumptions and query evaluation in temporal databases | c bettini , x wang , e bertino , s jajodia | sigmod conference |   1995 |

Entity B:
| title                                                              | authors                                 | venue               |   year |
|:-------------------------------------------------------------------|:----------------------------------------|:--------------------|-------:|
| adaptable query optimization and evaluation in temporal middleware | g slivinskas , cs jensen , rt snodgrass | sigmod conference , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1603
rtable_id: 60996
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                     | authors                               | venue             |   year |
|:--------------------------|:--------------------------------------|:------------------|-------:|
| sequence query processing | p seshadri , m livny , r ramakrishnan | sigmod conference |   1994 |

Entity B:
| title                                    | authors                                     | venue                   | year   |
|:-----------------------------------------|:--------------------------------------------|:------------------------|:-------|
| extensible query processing in starburst | g lohman , lm haas , j freytag , h pirahesh | proceedings of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1785
rtable_id: 59379
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| m-tree : an efficient access method for similarity search in metric spaces | p ciaccia , m patella , p zezula | vldb    |   1997 |

Entity B:
| title                                                                           | authors                                          | venue                                            | year   |
|:--------------------------------------------------------------------------------|:-------------------------------------------------|:-------------------------------------------------|:-------|
| the r * - tree : an efficient anf robust access mehod for points and rectangles | n beckmann , hp kriegel , r schneider , b seeger | proc . acm sigmod conf . on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1912
rtable_id: 40663
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| evolution of groupware for business applications : a database perspective on lotus domino/notes | c mohan , r barber , s watts , a somani , m zaharioudakis | vldb    |   2000 |

Entity B:
| title                                        | authors   | venue               |   year |
|:---------------------------------------------|:----------|:--------------------|-------:|
| a database perspective on lotus domino/notes | c mohan   | sigmod conference , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1177
rtable_id: 28184
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------|:------------|:--------------|-------:|
| advances in real-time database systems research | a bestavros | sigmod record |   1996 |

Entity B:
| title                                       | authors     | venue           | year   |
|:--------------------------------------------|:------------|:----------------|:-------|
| special issue on real-time database systems | a bestavros | sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 667
rtable_id: 8795
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 experimental system for object-based sharing in federated databases | d fang , s ghandeharizadeh | vldb j. |   1996 |

Entity B:
| title                                                                  | authors        | venue            | year   |
|:-----------------------------------------------------------------------|:---------------|:-----------------|:-------|
| a dynamic model for conceptual clustering in object-oriented databases | q li , j smith | proc . of vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2510
rtable_id: 18329
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                              | authors   | venue         |   year |
|:---------------------------------------------------|:----------|:--------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record |   1997 |

Entity B:
| title                                    | authors   | venue                                 |   year |
|:-----------------------------------------|:----------|:--------------------------------------|-------:|
| object systems over relational databases | mk crowe  | information and software technology , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 562
rtable_id: 9979
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------|:--------------------------------|:------------------|-------:|
| enhanced hypertext categorization using hyperlinks | s chakrabarti , b dom , p indyk | sigmod conference |   1998 |

Entity B:
| title                                              | authors               | venue               |   year |
|:---------------------------------------------------|:----------------------|:--------------------|-------:|
| enhanced hypertext categorization using hyperlinks | s chakrabarti , b dom | sigmod conference , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1147
rtable_id: 50578
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------|:--------------------------------------------|:--------|-------:|
| retrieval of composite multimedia objects | s chaudhuri , s ghandeharizadeh , c shahabi | vldb    |   1995 |

Entity B:
| title                                                 | authors                                     | venue   | year   |
|:------------------------------------------------------|:--------------------------------------------|:--------|:-------|
| on scheduling atomic and composite multimedia objects | c shahabi , s ghandeharizadeh , s chaudhuri |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 11
rtable_id: 15678
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 shrinking-based approach for multi-dimensional data analysis | y shi , y song , a zhang | vldb    |   2003 |

Entity B:
| title                                                | authors              | venue   | year   |
|:-----------------------------------------------------|:---------------------|:--------|:-------|
| a view selection tool for multidimensional databases | hm jamil , ga modica |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2093
rtable_id: 15201
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 | j vaghani , k ramamohanarao , d kemp , z somogyi , p stuckey , t leask , j harland | 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 & hellip ; , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2554
rtable_id: 63364
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:----------------------------------|:----------------------|:--------|-------:|
| watermarking relational databases | r agrawal , j kiernan | vldb    |   2002 |

Entity B:
| title                                | authors    | venue   |   year |
|:-------------------------------------|:-----------|:--------|-------:|
| sqlj : java and relational databases | g clossman |         |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2208
rtable_id: 45010
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-----------------|:----------|:--------|-------:|
| chair 's message |           |         |   1998 |

Entity B:
| title                | authors   | venue   |   year |
|:---------------------|:----------|:--------|-------:|
| treasurer 's message | j hammer  | sigmod  |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 580
rtable_id: 45743
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------|:-----------------------------------|:--------------|-------:|
| quality of service in multimedia digital libraries | e bertino , a elmagarmid , m hacid | sigmod record |   2001 |

Entity B:
| title                                                       | authors   | venue   |   year |
|:------------------------------------------------------------|:----------|:--------|-------:|
| quality of service assurances in multihop wireless networks | kc wang   |         |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 369
rtable_id: 47475
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                    | authors   | venue             |   year |
|:-----------------------------------------|:----------|:------------------|-------:|
| parallel database systems in the 1990 's | m carey   | sigmod conference |   1994 |

Entity B:
| title                                               | authors                | venue                                                                  | year   |
|:----------------------------------------------------|:-----------------------|:-----------------------------------------------------------------------|:-------|
| on the costs of multilingualism in database systems | a kumaran , jr haritsa | proceedings of the international conference on very large & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1816
rtable_id: 50313
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 case for enhanced abstract data types | p seshadri , m livny , r ramakrishnan | vldb    |   1997 |

Entity B:
| title                                     | authors                               | venue                                                                  |   year |
|:------------------------------------------|:--------------------------------------|:-----------------------------------------------------------------------|-------:|
| the case for enhanced abstract data types | p seshadri , m livny , r ramakrishnan | proceedings of the international conference on very large & hellip ; , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1873
rtable_id: 2488
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------------------------------|:--------------------|:--------------|-------:|
| power efficient data gathering and aggregation in wireless sensor networks | h tan , i korpeoglu | sigmod record |   2003 |

Entity B:
| title                                                                          | authors           | venue   | year   |
|:-------------------------------------------------------------------------------|:------------------|:--------|:-------|
| cyclops : in situ image sensing and interpretation in wireless sensor networks | m rahimi , r baer |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1856
rtable_id: 5650
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 rewriting for semistructured data | y papakonstantinou , v vassalos | sigmod conference |   1999 |

Entity B:
| title                                              | authors            | venue                            |   year |
|:---------------------------------------------------|:-------------------|:---------------------------------|-------:|
| sal : an algebra for semistructured data and xml . | c beeri , y tzaban | webdb ( informal proceedings ) , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1065
rtable_id: 58607
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 araneus web-base management system | g mecca , p atzeni , a masci , p merialdo , g sindoni | sigmod conference |   1998 |

Entity B:
| title                                                            | authors                                                | venue   | year   |
|:-----------------------------------------------------------------|:-------------------------------------------------------|:--------|:-------|
| design and implementation of the hb1 hyperbase management system | jl schnase , jj leggett , dl hicks , pj nuernberg , ja |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1264
rtable_id: 47210
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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-line warehouse view maintenance | d quass , j widom | sigmod conference |   1997 |

Entity B:
| title                                 | authors                             | venue                                                                 |   year |
|:--------------------------------------|:------------------------------------|:----------------------------------------------------------------------|-------:|
| parallel multisource view maintenance | x zhang , l ding , ea rundensteiner | the vldb journal the international journal on very large & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1392
rtable_id: 23461
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------------------------------|:-----------------------|:--------|-------:|
| accessing a relational database through an object-oriented database interface | j orenstein , d kamber | vldb    |   1995 |

Entity B:
| title                                                                                          | authors                      | venue                                                 |   year |
|:-----------------------------------------------------------------------------------------------|:-----------------------------|:------------------------------------------------------|-------:|
| an evaluation of vertical class partitioning for query processing in object-oriented databases | c fung , k karlapalem , q li | ieee transactions on knowledge and data engineering , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 45
rtable_id: 36653
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 for xml | j mchugh , j widom | vldb    |   1999 |

Entity B:
| title                                  | authors                | venue                                                                    |   year |
|:---------------------------------------|:-----------------------|:-------------------------------------------------------------------------|-------:|
| an architecture for query optimization | a rosenthal , d reiner | proceedings of the 1982 acm sigmod international conference & hellip ; , |   1982 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1431
rtable_id: 34372
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 association rule mining | c hidber  | sigmod conference |   1999 |

Entity B:
| title                                       | authors                                       | venue   | year   |
|:--------------------------------------------|:----------------------------------------------|:--------|:-------|
| mining fuzzy association rules in databases | cm kuok , a fu , mh wong , nt shatin , h kong |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1012
rtable_id: 52988
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 overview of data warehousing and olap technology | s chaudhuri , u dayal | sigmod record |   1997 |

Entity B:
| title                                                                   | authors               | venue   |   year |
|:------------------------------------------------------------------------|:----------------------|:--------|-------:|
| an overview of data warehousing and olap technology . ( 1 ) : 65â ?? 74 | s chaudhuri , u dayal |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 566
rtable_id: 40954
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 aggregation | j hellerstein , p haas , h wang | sigmod conference |   1997 |

Entity B:
| title                                  | authors                | venue                                                                 | year   |
|:---------------------------------------|:-----------------------|:----------------------------------------------------------------------|:-------|
| eager aggregation and lazy aggregation | py weipeng , l per-ake | proceedings of the 21st international conference on very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1283
rtable_id: 852
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 case-based approach to information integration | m panti , l spalazzi , a giretti | vldb    |   2000 |

Entity B:
| title                                                                   | authors           | venue                                  |   year |
|:------------------------------------------------------------------------|:------------------|:---------------------------------------|-------:|
| an integrated approach to logical design of relational database schemes | c beeri , m kifer | acm transactions on database systems , |   1986 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1158
rtable_id: 26733
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 system for watermarking relational databases | r agrawal , p haas , j kiernan | sigmod conference |   2003 |

Entity B:
| title                                                   | authors                      | venue                                                                  |   year |
|:--------------------------------------------------------|:-----------------------------|:-----------------------------------------------------------------------|-------:|
| incomplete information in relational temporal databases | sk gadia , ss nair , yc poon | proceedings of the international conference on very large & hellip ; , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 16650
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 general techniques for querying xml documents using a relational database system | j shanmugasundaram , e shekita , j kiernan , r krishnamurthy , s viglas , j naughton , i tatarinov | sigmod record |   2001 |

Entity B:
| title                                                                       | authors                | venue                                            | year   |
|:----------------------------------------------------------------------------|:-----------------------|:-------------------------------------------------|:-------|
| relational databases for query xml documents : limitation and opportunities | j shanmugasundaraâ ? ¦ | proc . of the 25th vldb . edinburgh , scotland , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 182
rtable_id: 53469
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                   | authors   | venue   |   year |
|:----------------------------------------|:----------|:--------|-------:|
| grid data management systems & services |           |         |   2003 |

Entity B:
| title                                               | authors       | venue               |   year |
|:----------------------------------------------------|:--------------|:--------------------|-------:|
| research directions in data base management systems | d tsichritzis | acm sigmod record , |   1977 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2185
rtable_id: 10241
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 overview of repository technology | p bernstein , u dayal | vldb    |   1994 |

Entity B:
| title                                                 | authors              | venue   |   year |
|:------------------------------------------------------|:---------------------|:--------|-------:|
| an overview of data warehousing and olap technology . | s chaudhri , u dayal |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 183
rtable_id: 35892
label: 0