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 |
|:-----------------------------------------------------------------|:-------------------|:--------|-------:|
| managing intra-operator parallelism in parallel database systems | m mehta , d dewitt | vldb    |   1995 |

Entity B:
| title                                            | authors               | venue                                                                     |   year |
|:-------------------------------------------------|:----------------------|:--------------------------------------------------------------------------|-------:|
| special issue in parallelism in database systems | m carey , p valduriez | the vldb journalâ ?? the international journal on very large & hellip ; , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 17
rtable_id: 33657
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 |
|:----------------------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| multimediaminer : a system prototype for multimedia data mining | o zaяane , j han , z li , s chee , j chiang | sigmod conference |   1998 |

Entity B:
| title                                                                                       | authors                   | venue   |   year |
|:--------------------------------------------------------------------------------------------|:--------------------------|:--------|-------:|
| multimediaminer : a system prototype for multimedia data mining . proceedings of acm sigmod | or zaiane , j han , zn li |         |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1217
rtable_id: 58482
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 |
|:----------------------------------------------------------------------|:-----------------------------|:------------------|-------:|
| adaptive filters for continuous queries over distributed data streams | c olston , j jiang , j widom | sigmod conference |   2003 |

Entity B:
| title                                                                              | authors    | venue                     | year   |
|:-----------------------------------------------------------------------------------|:-----------|:--------------------------|:-------|
| widomj ( 2003 ) adaptivefiltersforcontinuous queries over distributed data streams | jj olstonc | proceedings of acm sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 291
rtable_id: 4332
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 |
|:-------------------------------------------|:--------------------------------|:--------|-------:|
| toward learning based web query processing | y diao , h lu , s chen , z tian | vldb    |   2000 |

Entity B:
| title                                      | authors                                 | venue                                                                   | year   |
|:-------------------------------------------|:----------------------------------------|:------------------------------------------------------------------------|:-------|
| toward learning based web query processing | d yanlei , l hongjun , c ssongtingâ ? ¦ | proceedings of 26th international conference on very large & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1362
rtable_id: 26545
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 |
|:----------------------------------------------------|:----------------------------------------------|:--------|-------:|
| integration of data mining with database technology | a netz , s chaudhuri , j bernhardt , u fayyad | vldb    |   2000 |

Entity B:
| title                                               | authors                                        | venue                                                                 |   year |
|:----------------------------------------------------|:-----------------------------------------------|:----------------------------------------------------------------------|-------:|
| integration of data mining with database technology | a netz , s chaudhuri , j bernhardt , um fayyad | proceedings of the 26th international conference on very & hellip ; , |   2000 |



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

Entity B:
| title                                                     | authors                             | venue   | year   |
|:----------------------------------------------------------|:------------------------------------|:--------|:-------|
| event specification in an active object-oriented database | nh gehani , hv jagadish , o shmueli |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2564
rtable_id: 16634
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 processing in tertiary memory databases | s sarawagi | vldb    |   1995 |

Entity B:
| title                                                     | authors   | venue           |   year |
|:----------------------------------------------------------|:----------|:----------------|-------:|
| parallel query processing in shared disk database systems | e rahm    | sigmod record , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 104
rtable_id: 8329
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 mlpq/gis constraint database system | p revesz , r chen , p kanjamala , y li , y liu , y wang | sigmod conference |   2000 |

Entity B:
| title                                | authors      | venue                                                                     | year   |
|:-------------------------------------|:-------------|:--------------------------------------------------------------------------|:-------|
| the cedar database management system | m brownâ ? ¦ | proc . 1981 acmsigmod conference on management of data , ann & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 899
rtable_id: 60693
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 |
|:-----------------------------------------------|:------------------------|:------------------|-------:|
| s3 : similarity search in cad database systems | s berchtold , h kriegel | sigmod conference |   1997 |

Entity B:
| title                                         | authors                                  | venue   |   year |
|:----------------------------------------------|:-----------------------------------------|:--------|-------:|
| generalized search trees for database systems | jm hellerstein , jf naughton , a pfeffer | vldb ,  |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1368
rtable_id: 26608
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 unnesting in object-oriented databases | l fegaras | sigmod conference |   1998 |

Entity B:
| title                                        | authors   | venue   |   year |
|:---------------------------------------------|:----------|:--------|-------:|
| a model for active object oriented databases | , t milo  | vldb ,  |   1991 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1200
rtable_id: 31960
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 |
|:------------------------------------------------------------------------------------|:----------------------------------|:------------------|-------:|
| integrating mining with relational database systems : alternatives and implications | s sarawagi , s thomas , r agrawal | sigmod conference |   1998 |

Entity B:
| title                                                               | authors                                       | venue                                                                |   year |
|:--------------------------------------------------------------------|:----------------------------------------------|:---------------------------------------------------------------------|-------:|
| integrating data mining with sql databases : ole db for data mining | a netz , s chaudhuri , u fayyad , j bernhardt | & hellip ; , 2001 . proceedings . 17th international conference on , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1180
rtable_id: 10462
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 |
|:-------------------------------------------------------------------------------------------------|:---------------------------------------------|:--------|-------:|
| learning response time for websources using query feedback and application in query optimization | j gruser , l raschid , v zadorozhny , t zhan | vldb j. |   2000 |

Entity B:
| title                                                                                            | authors                                       | venue                                                                 |   year |
|:-------------------------------------------------------------------------------------------------|:----------------------------------------------|:----------------------------------------------------------------------|-------:|
| learning response time for websources using query feedback and application in query optimization | jr gruser , l raschid , v zadorozhny , t zhan | the vldb journal the international journal on very large & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2393
rtable_id: 25538
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 |
|:-------------------------------------------------------------|:-------------------------------------|:------------------|-------:|
| distributed file organization with scalable cost/performance | r vingralek , y breitbart , g weikum | sigmod conference |   1994 |

Entity B:
| title                                                                                              | authors                              | venue                   | year   |
|:---------------------------------------------------------------------------------------------------|:-------------------------------------|:------------------------|:-------|
| r. yavatkar . distributed file organization with scalable cost/performance . acm-sigmod int . conf | r vingralek , y breitbart , g weikum | on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1725
rtable_id: 608
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 |
|:----------------------------------------|:----------|:--------|-------:|
| dwms : data warehouse management system | n mohan   | vldb    |   1996 |

Entity B:
| title                                               | authors              | venue   | year   |
|:----------------------------------------------------|:---------------------|:--------|:-------|
| native xml database management systems : the survey | k chatzinas , h meng |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1842
rtable_id: 41762
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 mlpq/gis constraint database system | p revesz , r chen , p kanjamala , y li , y liu , y wang | sigmod conference |   2000 |

Entity B:
| title                                         | authors                                         | venue                                     | year   |
|:----------------------------------------------|:------------------------------------------------|:------------------------------------------|:-------|
| the ccube constraint object-oriented database | a brodsky , ve segal , j chen , pa exarkhopoulo | proc . acm sigmod conf . on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 899
rtable_id: 53378
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 |
|:-----------------------------------------------|:---------------------------------------------------------------------------------|:--------|-------:|
| anatomy of a native xml base management system | t fiebig , s helmer , c kanne , g moerkotte , j neumann , r schiele , t westmann | vldb j. |   2002 |

Entity B:
| title                                                            | authors                    | venue                                                       | year   |
|:-----------------------------------------------------------------|:---------------------------|:------------------------------------------------------------|:-------|
| performance analysis of a relational data base management system | p hawthorn , m stonebraker | proceedings of the 1979 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2468
rtable_id: 6326
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 logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                            | authors   | venue                                                            | year   |
|:-------------------------------------------------|:----------|:-----------------------------------------------------------------|:-------|
| a model of queries for object-oriented databases | kw kun    | proc of the 1989 vldb co @ , amsterdam , the netherlands , aug , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 53286
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 |
|:--------------------------------------------------------------------|:-------------------------------------------------|:--------|-------:|
| incremental clustering for mining in a data warehousing environment | m ester , h kriegel , j sander , m wimmer , x xu | vldb    |   1998 |

Entity B:
| title                                                       | authors      | venue                                                                  |   year |
|:------------------------------------------------------------|:-------------|:-----------------------------------------------------------------------|-------:|
| incremental organization for data recording and warehousing | , s seshadri | proceedings of the international conference on very large & hellip ; , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1594
rtable_id: 30233
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 |
|:------------------------------------------------------------------------------------|:----------|:--------|-------:|
| workshop on workflow management in scientific and engineering applications - report |           |         |   1997 |

Entity B:
| title                                             | authors               | venue   | year   |
|:--------------------------------------------------|:----------------------|:--------|:-------|
| workflow management in geoprocessing applications | m weske , cb medeiros |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 540
rtable_id: 34083
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 |
|:---------------------------------------------------|:-----------------------------------|:--------|-------:|
| graphical interaction with heterogeneous databases | t catarci , g santucci , j cardiff | vldb j. |   1997 |

Entity B:
| title                                                            | authors                       | venue           |   year |
|:-----------------------------------------------------------------|:------------------------------|:----------------|-------:|
| determining relationships among names in heterogeneous databases | ct yu , b jia , w sun , s dao | sigmod record , |   1991 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2421
rtable_id: 17242
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 |
|:--------------------------------------------------------------------|:-----------------------------------|:--------|-------:|
| roadrunner : towards automatic data extraction from large web sites | v crescenzi , g mecca , p merialdo | vldb    |   2001 |

Entity B:
| title                                                                                           | authors                            | venue   | year   |
|:------------------------------------------------------------------------------------------------|:-----------------------------------|:--------|:-------|
| datarover : a taxonomy based crawler for automated data extraction from data-intensive websites | h davulcu , s koduri , s nagarajan |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1037
rtable_id: 22341
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 |
|:-------------------------------------------|:-------------------------------------|:------------------|-------:|
| extracting schema from semistructured data | s nestorov , s abiteboul , r motwani | sigmod conference |   1998 |

Entity B:
| title                                   | authors                            | venue              | year   |
|:----------------------------------------|:-----------------------------------|:-------------------|:-------|
| storing semistructured data with stored | a deuntsch , m fernandez , d suciu | proceedings of acm |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1148
rtable_id: 13705
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 |
|:-----------------------------------------------|:-----------|:--------|-------:|
| foundations of preferences in database systems | w kieпling | vldb    |   2002 |

Entity B:
| title                                             | authors                    | venue   | year   |
|:--------------------------------------------------|:---------------------------|:--------|:-------|
| query optimization in compressed database systems | z chen , j gehrke , f korn |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2220
rtable_id: 12263
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 montage extensible datablade achitecture | m ubell   | sigmod conference |   1994 |

Entity B:
| title                                            | authors   | venue                                                     | year   |
|:-------------------------------------------------|:----------|:----------------------------------------------------------|:-------|
| the montage extensible datablade tm architecture | m ubell   | proceedings of the acm sigmod international conference on |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1799
rtable_id: 63051
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 |
|:------------------------------------------|:----------|:--------|-------:|
| cache coherency in oracle parallel server | b klots   | vldb    |   1996 |

Entity B:
| title                                        | authors   | venue       | year   |
|:---------------------------------------------|:----------|:------------|:-------|
| â ?? the oracle parallel server architecture | i lloyd   | proceedings |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1848
rtable_id: 59332
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 |
|:-----------------------------------------|:--------------------------------------------------|:------------------|-------:|
| fast algorithms for projected clustering | c aggarwal , c procopiuc , j wolf , p yu , j park | sigmod conference |   1999 |

Entity B:
| title                                               | authors               | venue   | year   |
|:----------------------------------------------------|:----------------------|:--------|:-------|
| fast algorithms for mining association rules , proc | r agrawal , r srikant | vldb    |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 903
rtable_id: 51361
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 |
|:----------------------------------------|:-------------|:--------------|-------:|
| introduction to the career forum column | a labrinidis | sigmod record |   2001 |

Entity B:
| title                                           | authors      | venue                                      | year   |
|:------------------------------------------------|:-------------|:-------------------------------------------|:-------|
| introduction to the theory of cognitive grammar | rw langacker | university of california , santa barbara , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 176
rtable_id: 18115
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 p operator : discovering and ranking associations on the semantic web | k anyanwu , a sheth | sigmod record |   2002 |

Entity B:
| title                                                        | authors             | venue           |   year |
|:-------------------------------------------------------------|:--------------------|:----------------|-------:|
| the p operator : discovering and ranking on the semantic web | k anyanwu , a sheth | sigmod record , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 111
rtable_id: 6020
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 |
|:-----------------------------------------------------------|:--------------------|:--------|-------:|
| coloring away communication in parallel query optimization | w hasan , r motwani | vldb    |   1995 |

Entity B:
| title                                | authors                     | venue           |   year |
|:-------------------------------------|:----------------------------|:----------------|-------:|
| bringing order to query optimization | gscs jensenl , rt snodgrass | sigmod record , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1969
rtable_id: 38927
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 |
|:--------------------------------------------------|:---------------------|:--------|-------:|
| promises and realities of active database systems | e simon , a dittrich | vldb    |   1995 |

Entity B:
| title                                      | authors       | venue    | year   |
|:-------------------------------------------|:--------------|:---------|:-------|
| principles of distributed database systems | , p valduriez | prentice |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 120
rtable_id: 45879
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 |
|:-------------------------------------------------------|:------------------------------|:----------------------------|-------:|
| formal query languages for secure relational databases | m winslett , k smith , x qian | acm trans . database syst . |   1994 |

Entity B:
| title                                                 | authors                      | venue   |   year |
|:------------------------------------------------------|:-----------------------------|:--------|-------:|
| an interactive query language for external data bases | fh lochovsky , d tsichritzis | vldb ,  |   1982 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2310
rtable_id: 7476
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 completeness of historical relational query languages | j clifford , a croker , a tuzhilin | acm trans . database syst . |   1994 |

Entity B:
| title                                             | authors             | venue                                                                     | year   |
|:--------------------------------------------------|:--------------------|:--------------------------------------------------------------------------|:-------|
| on an algebra for historical relational databases | j cliord , a tansel | proceedings of the international conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2298
rtable_id: 46920
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 |
|:---------------------------------------------------------------|:---------------------|:--------|-------:|
| integrating sql databases with content-specific search engines | s deпloch , n mattos | vldb    |   1997 |

Entity B:
| title                                                                                   | authors                       | venue                                      | year   |
|:----------------------------------------------------------------------------------------|:------------------------------|:-------------------------------------------|:-------|
| automated construction of topic-specific web search engines with data mining techniques | j yi , n sundaresan , a huang | ibm research report . ibm almaden research |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1902
rtable_id: 63384
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 |
|:----------------------------------------------------------|:-----------------------------------|:--------|-------:|
| manipulating interpolated data is easier than you thought | s grumbach , p rigaux , l segoufin | vldb    |   2000 |

Entity B:
| title                                                     | authors                            | venue   |   year |
|:----------------------------------------------------------|:-----------------------------------|:--------|-------:|
| manipulating interpolated data is easier than you thought | s grumbach , p rigaux , l segoufin | vldb ,  |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1387
rtable_id: 25484
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 |
|:----------------------------------|:----------------------|:--------|-------:|
| watermarking relational databases | r agrawal , j kiernan | vldb    |   2002 |

Entity B:
| title                                                            | authors                               | venue   | year   |
|:-----------------------------------------------------------------|:--------------------------------------|:--------|:-------|
| uxquery : building updatable xml views over relational databases | v braganholo , s davidson , ca heuser |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2208
rtable_id: 56484
label: 0