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 |
|:-------------------------|:-------------------------------------------------------|:--------|-------:|
| the microsoft repository | p bernstein , b harry , p sanders , d shutt , j zander | vldb    |   1997 |

Entity B:
| title                                 | authors                         | venue           |   year |
|:--------------------------------------|:--------------------------------|:----------------|-------:|
| the microsoft database research group | d lomet , r barga , s chaudhuri | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1724
rtable_id: 28335
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 |
|:---------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| distributed deviation detection in sensor networks | t palpanas , d papadopoulos , v kalogeraki , d gunopulos | sigmod record |   2003 |

Entity B:
| title                                                                          | authors                           | venue   | year   |
|:-------------------------------------------------------------------------------|:----------------------------------|:--------|:-------|
| combinatorial auctions for resource allocation in a distributed sensor network | j ostwald , v lesser , s abdallah |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1875
rtable_id: 62707
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 |
|:-------------------------------------------------------------------------|:----------|:--------|-------:|
| tutorial : ldap directory services - just another database application ? |           |         |   2000 |

Entity B:
| title                                                         | authors                | venue           |   year |
|:--------------------------------------------------------------|:-----------------------|:----------------|-------:|
| ldap directory services : just another database application ? | s shukla , a deshpande | sigmod record , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 920
rtable_id: 37967
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 |
|:----------------------------------------|:----------|:--------|-------:|
| grid data management systems & services |           |         |   2003 |

Entity B:
| title                                            | authors            | venue                                                                      |   year |
|:-------------------------------------------------|:-------------------|:---------------------------------------------------------------------------|-------:|
| data base management systems security and ingres | d downs , gj popek | very large data bases , 1979 . fifth international conference & hellip ; , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2185
rtable_id: 53356
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 for high-volume xml message brokering | y diao , m franklin | vldb    |   2003 |

Entity B:
| title                                                  | authors   | venue   |   year |
|:-------------------------------------------------------|:----------|:--------|-------:|
| query processing for large-scale xml message brokering | y diao    |         |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2079
rtable_id: 26756
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 algorithms for processing xpath queries | g gottlob , c koch , r pichler | vldb    |   2002 |

Entity B:
| title                                                    | authors   | venue               |   year |
|:---------------------------------------------------------|:----------|:--------------------|-------:|
| efficient algorithms for minimizing tree pattern queries | p ramanan | sigmod conference , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2188
rtable_id: 59316
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 dynamic reordering | v raman , b raman , j hellerstein | vldb j. |   2000 |

Entity B:
| title                     | authors                            | venue                                                                 |   year |
|:--------------------------|:-----------------------------------|:----------------------------------------------------------------------|-------:|
| online dynamic reordering | v raman , b raman , jm hellerstein | the vldb journal the international journal on very large & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2487
rtable_id: 42356
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 |
|:----------------------------------------------------------------|:----------------------|:--------|-------:|
| fast algorithms for mining association rules in large databases | r agrawal , r srikant | vldb    |   1994 |

Entity B:
| title                                          | authors    | venue   |   year |
|:-----------------------------------------------|:-----------|:--------|-------:|
| sampling large databases for association rules | h toivonen | vldb ,  |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 95
rtable_id: 25353
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 |
|:--------------------------|:------------------------------------------------------------------------------------------------------|:------------------|-------:|
| metu object-oriented dbms | a dogac , i arpinar , c evrendilek , c ozkan , i altintas , i durusoy , m altinel , t okay , y saygin | sigmod conference |   1994 |

Entity B:
| title                              | authors   | venue   | year   |
|:-----------------------------------|:----------|:--------|:-------|
| querying object-oriented databases | m kifer   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1852
rtable_id: 1845
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 parallel similarity search in multimedia databases | s berchtold , c bіhm , b braunmќller , d keim , h kriegel | sigmod conference |   1997 |

Entity B:
| title                                          | authors                  | venue   | year   |
|:-----------------------------------------------|:-------------------------|:--------|:-------|
| s3 : similarity search in cad database systems | s berchtold , hp kriegel |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1247
rtable_id: 1114
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 foundation for multi-dimensional databases | m gyssens , l lakshmanan | vldb    |   1997 |

Entity B:
| title                                                                           | authors                        | venue                                                                  |   year |
|:--------------------------------------------------------------------------------|:-------------------------------|:-----------------------------------------------------------------------|-------:|
| automated design of multi-dimensional clustering tables in relational databases | s lightstone , b bhattacharjee | proceedings of the international conference on very large & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1792
rtable_id: 12376
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 |
|:----------------------------------------------|:----------------------------------|:--------------|-------:|
| database research at arizona state university | s urban , s dietrich , f golshani | sigmod record |   1996 |

Entity B:
| title                        | authors   | venue           |   year |
|:-----------------------------|:----------|:----------------|-------:|
| database research at hp labs | ma neimat | sigmod record , |   1991 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 696
rtable_id: 46108
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 persistent cache : improving oid indexing in temporal object-oriented database systems | k nјrvхg  | vldb    |   1999 |

Entity B:
| title                                                            | authors               | venue                                              |   year |
|:-----------------------------------------------------------------|:----------------------|:---------------------------------------------------|-------:|
| queries and query processing in object-oriented database systems | dd straube , mt ã?zsu | acm transactions on information systems ( tois ) , |   1990 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1465
rtable_id: 43919
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 |
|:----------------------------------------|:----------|:--------|-------:|
| open object database management systems |           |         |   1994 |

Entity B:
| title                                                    | authors                                       | venue                                                          | year   |
|:---------------------------------------------------------|:----------------------------------------------|:---------------------------------------------------------------|:-------|
| file management in the exodus extensible database system | m carey , d dewitt , j richardson , es object | proc . int . conf . on very large data bases , kyoto , japan ( |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1829
rtable_id: 15876
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 |
|:----------------------------------------------------------|:-------------------------------------------------------------------------------------------|:--------|-------:|
| scientific journals : extinction or explosion ? ( panel ) | r ramakrishnan , h garcia-molina , g rossbach , a silberschatz , g wiederhold , j zijlstra | vldb    |   1995 |

Entity B:
| title                                           | authors        | venue                                                                  |   year |
|:------------------------------------------------|:---------------|:-----------------------------------------------------------------------|-------:|
| scientific journals : extinction or explosion ? | r ramakrishnan | proceedings of the international conference on very large & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 108
rtable_id: 23449
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 |
|:------------------------------------------------------|:-----------------------|:--------------|-------:|
| constructing the next 100 database management systems | a geppert , k dittrich | sigmod record |   1994 |

Entity B:
| title                                  | authors                                               | venue                        | year   |
|:---------------------------------------|:------------------------------------------------------|:-----------------------------|:-------|
| the araneus web-base management system | p atzeni , g mecca , p merialdo , a masci , g sindoni | proc . int . conf . sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 996
rtable_id: 3916
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 |
|:------------------------------------------------------------------------------------------|:-----------------------------------------------------|:------------------|-------:|
| aqr-toolkit : an adaptive query routing middleware for distributed data intensive systems | l liu , c pu , d buttler , w han , h paques , w tang | sigmod conference |   2000 |

Entity B:
| title                                                                             | authors                      | venue                                                       | year   |
|:----------------------------------------------------------------------------------|:-----------------------------|:------------------------------------------------------------|:-------|
| mocha : a self-extensible database middleware system for distributed data sources | mr martinez , n roussopoulos | acm sigmod international conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 800
rtable_id: 21161
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 |
|:----------------------------------------------------|:--------------------------------------|:------------------|-------:|
| bringing object-relational technology to mainstream | v krishnamurthy , s banerjee , a nori | sigmod conference |   1999 |

Entity B:
| title                                               | authors                               | venue               |   year |
|:----------------------------------------------------|:--------------------------------------|:--------------------|-------:|
| bringing object-relational technology to mainstream | v krishnamurthy , s banerjee , a nori | sigmod conference , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 987
rtable_id: 915
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 |
|:-------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| the persistent cache : improving oid indexing in temporal object-oriented database systems | k nјrvхg  | vldb    |   1999 |

Entity B:
| title                                                                                      | authors     | venue   |   year |
|:-------------------------------------------------------------------------------------------|:------------|:--------|-------:|
| the persistent cache : improving oid indexing in temporal object-oriented database systems | idt.unit.no | vldb ,  |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1465
rtable_id: 51643
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 |
|:-----------------------------|:----------|:--------|-------:|
| guest editor 's introduction |           |         |   1998 |

Entity B:
| title           | authors   | venue                          |   year |
|:----------------|:----------|:-------------------------------|-------:|
| guest editorial | h simon   | public administration review , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 408
rtable_id: 27909
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 query language for a web-site management system | m fernandez , d florescu , a levy , d suciu | sigmod record |   1997 |

Entity B:
| title             | authors       | venue   | year   |
|:------------------|:--------------|:--------|:-------|
| management system | csd recording |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 554
rtable_id: 45703
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 |
|:---------------------------------------|:-----------------|:--------|-------:|
| eager aggregation and lazy aggregation | w yan , p larson | vldb    |   1995 |

Entity B:
| title                                  | authors            | venue   | year   |
|:---------------------------------------|:-------------------|:--------|:-------|
| eager aggregation and lazy aggregation | pa larson , wp yan |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1979
rtable_id: 4905
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 |
|:--------------------------------------|:----------|:--------|-------:|
| ebusiness standards and architectures |           |         |   2002 |

Entity B:
| title                                            | authors   | venue   | year   |
|:-------------------------------------------------|:----------|:--------|:-------|
| using xml effectively in ebusiness architectures | r bodkin  |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2192
rtable_id: 14584
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 algorithms for processing xpath queries | g gottlob , c koch , r pichler | vldb    |   2002 |

Entity B:
| title                                                            | authors                                | venue              | year   |
|:-----------------------------------------------------------------|:---------------------------------------|:-------------------|:-------|
| efficient and extensible algorithms for multi query optimization | d quass , a gupta , i mumick , j widom | acm sigmod , may , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2188
rtable_id: 15253
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 |
|:-----------------------------------|:----------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| metu interoperable database system | a dogac , c dengi , e kilic , g жzhan , f ozcan , s nural , c evrendilek , u halici , i arpinar , p koksal , n kesim , s mancuhan | sigmod record |   1995 |

Entity B:
| title                     | authors                 | venue           | year   |
|:--------------------------|:------------------------|:----------------|:-------|
| database interoperability | w litwin , a abdellatif | ieee-computer , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 798
rtable_id: 39878
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 |
|:-----------------------------|:----------|:--------|-------:|
| guest editor 's introduction |           |         |   2002 |

Entity B:
| title           | authors   | venue                                     |   year |
|:----------------|:----------|:------------------------------------------|-------:|
| guest editorial | bv gray   | journal of research in science teaching , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2588
rtable_id: 46326
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 |
|:-------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| index concurrency control in firm real-time database systems | b goyal , j haritsa , s seshadri , v srinivasan | vldb    |   1995 |

Entity B:
| title                                                     | authors                           | venue      | year   |
|:----------------------------------------------------------|:----------------------------------|:-----------|:-------|
| concurrency control in a system for distributed databases | bb pa , dw shipman , jb rothnr jr | acm tods , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 56
rtable_id: 23109
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 |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | j widom   | sigmod record |   1996 |

Entity B:
| title           | authors             | venue                                   | year   |
|:----------------|:--------------------|:----------------------------------------|:-------|
| editor 's notes | dj rog , d fournier | new directions for program evaluation , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 661
rtable_id: 33904
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 |
|:------------------------------------------------------------|:---------------------|:--------------------------------------|-------:|
| mdas : heterogeneous distributed database management system | bc desai , r pollock | information and software technology , |   1992 |



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

Entity B:
| title                                                        | authors        | venue                                                           | year   |
|:-------------------------------------------------------------|:---------------|:----------------------------------------------------------------|:-------|
| access path selection ma rela-uwd database management system | p selmgerâ ? ¦ | proceedings of the 1979 sigmod conference , boston , ma , may , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 657
rtable_id: 35023
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 |
|:----------------------------------------------------|:----------------------------|:------------------|-------:|
| scalable parallel data mining for association rules | e han , g karypis , v kumar | sigmod conference |   1997 |

Entity B:
| title                                                          | authors                   | venue                                                   |   year |
|:---------------------------------------------------------------|:--------------------------|:--------------------------------------------------------|-------:|
| efficient mining of association rules in distributed databases | dw cheung , vt ng , aw fu | knowledge and data engineering , ieee transactions on , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1288
rtable_id: 25559
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 x-tree : an index structure for high-dimensional data | s berchtold , d keim , h kriegel | vldb    |   1996 |

Entity B:
| title                                                 | authors   | venue               | year   |
|:------------------------------------------------------|:----------|:--------------------|:-------|
| r-tree : a dynamic index structure for spatial search | a guttman | proc . acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1834
rtable_id: 56743
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 reorganization in object databases | m lakhamraju , r rastogi , s seshadri , s sudarshan | sigmod conference |   2000 |

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: 813
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 |
|:--------------------------------------------------------------|:-------------------------------------------------|:------------------|-------:|
| a data model and data structures for moving objects databases | l forlizzi , r gќting , e nardelli , m schneider | sigmod conference |   2000 |

Entity B:
| title                                            | authors                                          | venue                                                  | year   |
|:-------------------------------------------------|:-------------------------------------------------|:-------------------------------------------------------|:-------|
| classic/db : a structural data model for objects | a borgida , r brachman , d mcguiness , l resnick | proceedings acm sigmod international conference on the |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 797
rtable_id: 50620
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 |
|:--------------------------------------------------------|:----------------------------|:------------------|-------:|
| statistical synopses for graph-structured xml databases | n polyzotis , m garofalakis | sigmod conference |   2002 |

Entity B:
| title                                          | authors                     | venue                   | year   |
|:-----------------------------------------------|:----------------------------|:------------------------|:-------|
| statistical synopses for graph-structured data | n polyzotis , m garofalakis | proceedings of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 541
rtable_id: 7797
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 |
|:----------------------|:-----------------------|:--------------|-------:|
| standards in practice | a eisenberg , j melton | sigmod record |   1998 |

Entity B:
| title                           | authors    | venue        | year   |
|:--------------------------------|:-----------|:-------------|:-------|
| gratings in theory and practice | ha rowland | phil . mag , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 601
rtable_id: 15889
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   |
|:--------------------------|:------------------------------------------------------|:--------|:-------|
| metu object-oriented dbms | a dogac , c ozkan , b arpinar , t okay , c evrendilek |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1200
rtable_id: 40801
label: 0