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 |
|:------------------------------------------------------------|:--------------------------|:--------|-------:|
| a semantic modeling approach for image retrieval by content | w chu , i ieong , r taira | vldb j. |   1994 |

Entity B:
| title                                                                 | authors                     | venue                   | year   |
|:----------------------------------------------------------------------|:----------------------------|:------------------------|:-------|
| an integrated color-spatial approach to content-based image retrieval | h wynne , ts chua , hk pung | proc . acm multimedia , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2541
rtable_id: 7205
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 |
|:----------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| qursed : querying and reporting semistructured data | y papakonstantinou , m petropoulos , v vassalos | sigmod conference |   2002 |

Entity B:
| title                                                    | authors             | venue                               |   year |
|:---------------------------------------------------------|:--------------------|:------------------------------------|-------:|
| interactive query and search in semistructured databases | r goldman , j widom | lecture notes in computer science , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 527
rtable_id: 24423
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 |
|:----------------------------------------------------------------------------------------------|:-------------------------------------------------------------|:--------|-------:|
| garbage collection in object-oriented databases using transactional cyclic reference counting | p roy , s seshadri , a silberschatz , s sudarshan , s ashwin | vldb j. |   1998 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2428
rtable_id: 1043
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 | l liu     | sigmod record |   2002 |

Entity B:
| title           | authors    | venue                                   | year   |
|:----------------|:-----------|:----------------------------------------|:-------|
| editor 's notes | rh silkman | new directions for program evaluation , |        |



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

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

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

Entity A:
| title                                                       | authors    | venue   |   year |
|:------------------------------------------------------------|:-----------|:--------|-------:|
| enhanced abstract data types in object-relational databases | p seshadri | vldb j. |   1998 |

Entity B:
| title                                     | authors                               | venue            | year   |
|:------------------------------------------|:--------------------------------------|:-----------------|:-------|
| the case for enhanced abstract data types | r ramakrishnan , p seshadri , m livny | proc . of vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2431
rtable_id: 10124
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 editor 's introduction : software metrics | tm khoshgoftaar , p oman | computer , |   1994 |



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

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

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

Entity A:
| title                                                                              | authors                                                                                | venue             |   year |
|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------|:------------------|-------:|
| an ebxml infrastructure implementation through uddi registries and rosettanet pips | a dogac , y tambag , p pembecioglu , s pektas , g laleci , g kurt , s toprak , y kabak | sigmod conference |   2002 |

Entity B:
| title                                                                                             | authors                                           | venue                                                      | year   |
|:--------------------------------------------------------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------------------|:-------|
| y. kabak . an ebxml infrastructure implementation through uddi registries and rosettanet pipsâ ?? | a dogac , y tambag , p pembecioglu , s pektas , g | proceedings of 2002 acm sigmod international conference on |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 480
rtable_id: 47943
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 |
|:---------------------------------------------------------------------|:----------------------------------|:--------|-------:|
| extending practical pre-aggregation in on-line analytical processing | t pedersen , c jensen , c dyreson | vldb    |   1999 |

Entity B:
| title                                                                    | authors                 | venue                                                    | year   |
|:-------------------------------------------------------------------------|:------------------------|:---------------------------------------------------------|:-------|
| dce extending practical pre-aggregation in on-line analytical processing | tb pedersen , cs jensen | proceedings of the 25th international conference on very |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1474
rtable_id: 5717
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 |
|:------------------------------------------------------------------|:-----------------------|:------------------|-------:|
| query by diagram : a graphical environment for querying databases | t catarci , g santucci | sigmod conference |   1994 |

Entity B:
| title                                                               | authors                         | venue   | year   |
|:--------------------------------------------------------------------|:--------------------------------|:--------|:-------|
| a graphical notebook as interaction metaphor for querying databases | sf silva , t catarci , u schiel |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1849
rtable_id: 11498
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 |
|:-------------------------------------------|:------------------------------------------|:--------|-------:|
| composing web services on the semantic web | b medjahed , a bouguettaya , a elmagarmid | vldb j. |   2003 |

Entity B:
| title                                                  | authors                                       | venue   |   year |
|:-------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| learning to map between ontologies on the semantic web | ah doan , j madhavan , p domingos , ay halevy | www ,   |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2294
rtable_id: 36656
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 subsequence matching in time-series databases | c faloutsos , m ranganathan , y manolopoulos | sigmod conference |   1994 |

Entity B:
| title                                                                     | authors                     | venue                                                                    | year   |
|:--------------------------------------------------------------------------|:----------------------------|:-------------------------------------------------------------------------|:-------|
| manolopoulosy ( 1994 ) fast subsequence matching in time-series databases | c faloutsos , m ranganathan | & hellip ; . acm international conference on management of data ( sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1717
rtable_id: 589
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 |
|:-------------------------------------|:--------------------------------------|:--------------|-------:|
| bringing order to query optimization | g slivinskas , c jensen , r snodgrass | sigmod record |   2002 |

Entity B:
| title                        | authors                 | venue      | year   |
|:-----------------------------|:------------------------|:-----------|:-------|
| continous query optimization | r avnur , j hellerstien | acm sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 40
rtable_id: 45113
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 |
|:--------------------------------------------------------|:--------------|:--------------|-------:|
| mining system audit data : opportunities and challenges | w lee , w fan | sigmod record |   2001 |

Entity B:
| title                                                                                 | authors   | venue                                      |   year |
|:--------------------------------------------------------------------------------------|:----------|:-------------------------------------------|-------:|
| expressing cultural identity in the learning community : opportunities and challenges | am ortiz  | new directions for teaching and learning , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 209
rtable_id: 36669
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 |
|:------------------------------------------------------------------|:----------------------------------|:-------------------------------------------------------------------------|-------:|
| xml and relational database management systems : the inside story | m rys , d chamberlin , d florescu | proceedings of the 2005 acm sigmod international conference & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 657
rtable_id: 51481
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 |
|:-------------------------------------------------------------|:----------------------|:------------------|-------:|
| image mining in iris : integrated retinal information system | w hsu , m lee , k goh | sigmod conference |   2000 |

Entity B:
| title                                           | authors                           | venue                               |   year |
|:------------------------------------------------|:----------------------------------|:------------------------------------|-------:|
| knowledge based information integration systems | nw paton , ca goble , s bechhofer | information & software technology , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 904
rtable_id: 4308
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 cost model for clustered object-oriented databases | g gardarin , j gruser , z tang | vldb    |   1995 |

Entity B:
| title                                                                               | authors                           | venue   | year   |
|:------------------------------------------------------------------------------------|:----------------------------------|:--------|:-------|
| a cost model for the evaluation of path expressions in distributed object databases | g ruberg , f baiã # o , m mattoso |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1981
rtable_id: 22359
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 a-tree : an index structure for high-dimensional spaces using relative approximation | y sakurai , m yoshikawa , s uemura , h kojima | vldb    |   2000 |

Entity B:
| title                                                                    | authors                    | venue   | year   |
|:-------------------------------------------------------------------------|:---------------------------|:--------|:-------|
| the hybrid tree : an index structure for high dimensional feature spaces | k chakrabarti , s mehrotra |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1342
rtable_id: 6899
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 cost model for query processing in high dimensional data spaces | c bіhm    | acm trans . database syst . |   2000 |

Entity B:
| title                                                                 | authors    | venue                                                                  |   year |
|:----------------------------------------------------------------------|:-----------|:-----------------------------------------------------------------------|-------:|
| a framework for projected clustering of high dimensional data streams | c aggarwal | proceedings of the international conference on very large & hellip ; , |   2004 |



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

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

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

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

Entity B:
| title                                   | authors       | venue                            |   year |
|:----------------------------------------|:--------------|:---------------------------------|-------:|
| relational data-base management systems | dd chamberlin | acm computing surveys ( csur ) , |   1976 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2185
rtable_id: 26355
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 |
|:-----------------------------------------------------------------|:---------------------|:------------------|-------:|
| secure transaction processing in firm real-time database systems | b george , j haritsa | sigmod conference |   1997 |

Entity B:
| title                                            | authors                            | venue                                    | year   |
|:-------------------------------------------------|:-----------------------------------|:-----------------------------------------|:-------|
| distributed query processing in database systems | r epstein , m stonebraker , e wong | proc . acm sigmod , austin . tx . june , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1407
rtable_id: 47913
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 |
|:-------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| timber : a native xml database | h jagadish , s al-khalifa , a chapman , l lakshmanan , a nierman , s paparizos , j patel , d srivastava , n wiwatwattana , y wu , c yu | vldb j. |   2002 |

Entity B:
| title                          | authors                                      | venue                                                                 |   year |
|:-------------------------------|:---------------------------------------------|:----------------------------------------------------------------------|-------:|
| timber : a native xml database | hv jagadish , s al-khalifa , a chapman , lvs | the vldb journal the international journal on very large & hellip ; , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2467
rtable_id: 52029
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 mariposa distributed database management system | j sidell  | sigmod record |   1996 |

Entity B:
| title                                  | authors       | venue   | year   |
|:---------------------------------------|:--------------|:--------|:-------|
| multimedia database management systems | b prabhakaran |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 758
rtable_id: 32362
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 |
|:-------------------------------------------------|:------------|:--------|-------:|
| an architecture and data model for cad databases | ap buchmann | vldb ,  |   1985 |



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

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

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

Entity A:
| title                                                | authors                          | venue   |   year |
|:-----------------------------------------------------|:---------------------------------|:--------|-------:|
| optimizing multi-feature queries for image databases | u gќntzer , w balke , w kieпling | vldb    |   2000 |

Entity B:
| title                         | authors           | venue                                                       | year   |
|:------------------------------|:------------------|:------------------------------------------------------------|:-------|
| optimizing large join queries | a swami , a gupta | proc . of the acm sigmod intâ ?? l. conf . on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1348
rtable_id: 54419
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 |
|:------------------------------------------------------------|:----------|:--------|-------:|
| data warehousing and olap for decision support ( tutorial ) |           |         |   1997 |

Entity B:
| title                                                                                            | authors                              | venue   | year   |
|:-------------------------------------------------------------------------------------------------|:-------------------------------------|:--------|:-------|
| combining mediator and data warehouse technologies for developing environmental decision support | amc moura , mc victorino , ak tanaka |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1382
rtable_id: 35832
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 |
|:---------------------------------------------------------------|:--------------------------------|:--------|-------:|
| odefs : a file system interface to an object-oriented database | n gehani , h jagadish , w roome | vldb    |   1994 |

Entity B:
| title                                              | authors                             | venue                                                 | year   |
|:---------------------------------------------------|:------------------------------------|:------------------------------------------------------|:-------|
| event specification in an object-oriented database | nh gehani , hv jagadish , o shmueli | proceedings international conference on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 151
rtable_id: 19423
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 hypertext query language for images | l yang    | sigmod record |   1994 |

Entity B:
| title                     | authors                                         | venue                                                           | year   |
|:--------------------------|:------------------------------------------------|:----------------------------------------------------------------|:-------|
| query language for exodus | mj carey , dj dewitt , sl vandenberg , ad model | proc . of the acm sigmod conference on the management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 998
rtable_id: 50637
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 |
|:---------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| querying heterogeneous information sources using source descriptions | a levy , a rajaraman , j ordille | vldb    |   1996 |

Entity B:
| title                                                                     | authors   | venue                                | year   |
|:--------------------------------------------------------------------------|:----------|:-------------------------------------|:-------|
| querying heterogeneous information sources using source descriptions . '' | l ayâ ? ¦ | proceedings of the vldb conference , |        |



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

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



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

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

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

Entity A:
| title                                           | authors                             | venue             |   year |
|:------------------------------------------------|:------------------------------------|:------------------|-------:|
| efficient evaluation of xml middle-ware queries | m fernandez , a morishima , d suciu | sigmod conference |   2001 |

Entity B:
| title                                 | authors                                               | venue                  | year   |
|:--------------------------------------|:------------------------------------------------------|:-----------------------|:-------|
| lazy evaluation of active xml queries | s abiteboul , o benjelloun , b cautis , i manolescu , | proc . of acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 618
rtable_id: 35592
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 |
|:--------------------------------------------------------------|:----------------------|:--------------|-------:|
| relational data sharing in peer-based data management systems | b ooi , y shu , k tan | sigmod record |   2003 |

Entity B:
| title                                                                   | authors                                              | venue         | year   |
|:------------------------------------------------------------------------|:-----------------------------------------------------|:--------------|:-------|
| panel : xml data management : go native or spruce up relational systems | d florescu , g graefe , g moerkotte , h pirahesh , h | proc . sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1944
rtable_id: 41857
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   |
|:----------------|:-----------------------------------------------|:--------------------------------------|:-------|
| editors ' notes | lf goodchild , ke green , el katz , rc kluever | new directions for higher education , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 767
rtable_id: 44766
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 materialization and use of views in data warehouses | m souza , m sampaio | sigmod record |   1999 |

Entity B:
| title                                                           | authors             | venue                                                 |   year |
|:----------------------------------------------------------------|:--------------------|:------------------------------------------------------|-------:|
| efficient aggregation algorithms for compressed data warehouses | j li , j srivastava | ieee transactions on knowledge and data engineering , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 452
rtable_id: 50720
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 |
|:--------------------------------------------------------------------|:----------------------------------|:------------------|-------:|
| congressional samples for approximate answering of group-by queries | s acharya , p gibbons , v poosala | sigmod conference |   2000 |

Entity B:
| title                                                               | authors                            | venue               |   year |
|:--------------------------------------------------------------------|:-----------------------------------|:--------------------|-------:|
| congressional samples for approximate answering of group-by queries | s acharya , pb gibbons , v poosala | sigmod conference , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 779
rtable_id: 2325
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 |
|:-------------------------------------------------------|:----------|:--------|-------:|
| searching and mining fine-grained semi-structured data |           |         |   2002 |

Entity B:
| title                                                  | authors                          | venue                               |   year |
|:-------------------------------------------------------|:---------------------------------|:------------------------------------|-------:|
| ozone : integrating structured and semistructured data | t lahiri , s abiteboul , j widom | lecture notes in computer science , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2196
rtable_id: 5245
label: 0