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 |
|:-------------------------------------------------------------------------|:---------------------|:------------------|-------:|
| temporal conditions and integrity constraints in active database systems | a sistla , o wolfson | sigmod conference |   1995 |

Entity B:
| title                                                             | authors               | venue                                                     | year   |
|:------------------------------------------------------------------|:----------------------|:----------------------------------------------------------|:-------|
| temporal conditions and integrity constraints in active databases | ap sistla , o wolfson | proc . of the 1995 sigmod international conference on the |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1610
rtable_id: 21763
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 |
|:-------------------------------------------------------------------------------|:----------------------|:--------------|-------:|
| an aspect of query optimization in multidatabase systems ( extended abstract ) | c lee , c chen , h lu | sigmod record |   1995 |

Entity B:
| title                                                    | authors                | venue           |   year |
|:---------------------------------------------------------|:-----------------------|:----------------|-------:|
| an aspect of query optimization in multidatabase systems | c lee , cj chen , h lu | sigmod record , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 882
rtable_id: 41952
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 |
|:--------------------------------------------|:----------|:----------------------------|-------:|
| declarative updates of relational databases | w chen    | acm trans . database syst . |   1995 |

Entity B:
| title                                                                | authors              | venue   | year   |
|:---------------------------------------------------------------------|:---------------------|:--------|:-------|
| the importance of declarative semantics for mls relational databases | k smith , m winslett |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2249
rtable_id: 28134
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 aggregation | j hellerstein , p haas , h wang | sigmod conference |   1997 |

Entity B:
| title                      | authors                  | venue              | year   |
|:---------------------------|:-------------------------|:-------------------|:-------|
| h. wang online aggregation | jm hellerstein , pj haas | proc . of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1283
rtable_id: 48549
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 |
|:--------------------------------------------------------------------------------|:-----------------|:------------------|-------:|
| semint : a system prototype for semantic integration in heterogeneous databases | w li , c clifton | sigmod conference |   1995 |

Entity B:
| title                                                            | authors                          | venue                    | year   |
|:-----------------------------------------------------------------|:---------------------------------|:-------------------------|:-------|
| query optimization in heterogeneous databases management systems | w du , r krishnamurthy , mc shan | proc . vldb conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1694
rtable_id: 33240
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 introduction to spatial database systems | r gќting  | vldb j. |   1994 |

Entity B:
| title                                                              | authors                | venue                                       | year   |
|:-------------------------------------------------------------------|:-----------------------|:--------------------------------------------|:-------|
| 1994 . the impact of global clustering on spatial database systems | t brinkho , hp kriegel | proc . 20th int . conf . on very large data |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2538
rtable_id: 29067
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 |
|:---------------------------------------------|:-------------------------------------------|:--------------|-------:|
| constraints for semi-structured data and xml | p buneman , w fan , j simщon , s weinstein | sigmod record |   2001 |

Entity B:
| title                                                  | authors        | venue   | year   |
|:-------------------------------------------------------|:---------------|:--------|:-------|
| path constraints on semistructured and structured data | portal.acm.org |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 153
rtable_id: 36667
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 |
|:-----------------------------------------------|:--------------------|:----------------------------|-------:|
| quorum consensus in nested transaction systems | k goldman , n lynch | acm trans . database syst . |   1994 |

Entity B:
| title                                                    | authors       | venue   | year   |
|:---------------------------------------------------------|:--------------|:--------|:-------|
| concepts for transaction recovery in nested transactions | , k rothermel |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2251
rtable_id: 33728
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 |
|:-----------------------------------------------|:------------------------|:--------|-------:|
| erratum : a database model for object dynamics | m papazoglou , b krфmer | vldb j. |   1997 |

Entity B:
| title                                | authors                      | venue                                                                 |   year |
|:-------------------------------------|:-----------------------------|:----------------------------------------------------------------------|-------:|
| a database model for object dynamics | mp papazoglou , bj krã $ mer | the vldb journal the international journal on very large & hellip ; , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2423
rtable_id: 18275
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 |
|:---------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| disima : a distributed and interoperable image database system | v oria , m жzsu , p iglinski , s lin , b yao | sigmod conference |   2000 |

Entity B:
| title                                              | authors                            | venue                                                                         | year   |
|:---------------------------------------------------|:-----------------------------------|:------------------------------------------------------------------------------|:-------|
| query processing in a distributed data base system | r epstein , m stonebraker , e wong | proc . acm sigmod conf . on management of data , austin , tex. , & hellip ; , |        |



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

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

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

Entity A:
| title                              | authors           | venue             |   year |
|:-----------------------------------|:------------------|:------------------|-------:|
| on-line warehouse view maintenance | d quass , j widom | sigmod conference |   1997 |

Entity B:
| title                                         | authors                             | venue                                                                  | year   |
|:----------------------------------------------|:------------------------------------|:-----------------------------------------------------------------------|:-------|
| view maintenance in a warehousing environment | y zhung , mh garcia , j hammerâ ? ¦ | proceedings of the acm sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1392
rtable_id: 49415
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 |
|:-------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| revisiting commit processing in distributed database systems | r gupta , j haritsa , k ramamritham | sigmod conference |   1997 |

Entity B:
| title                                                  | authors            | venue                                  |   year |
|:-------------------------------------------------------|:-------------------|:---------------------------------------|-------:|
| set query optimization in distributed database systems | b gavish , a segev | acm transactions on database systems , |   1986 |



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

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

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

Entity A:
| title                                                        | authors                   | venue                       |   year |
|:-------------------------------------------------------------|:--------------------------|:----------------------------|-------:|
| a logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                                          | authors                                     | venue               | year   |
|:---------------------------------------------------------------|:--------------------------------------------|:--------------------|:-------|
| object-oriented databases : definition and research directions | w grosky , f fotouli , i sethi , b capatina | acm sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 38338
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   |
|:------------------------------------------------------------------------------------------|:-----------------------|:--------|:-------|
| on the design of a reliable storage component for distributed database management systems | da menasce , oe landes |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 758
rtable_id: 26775
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 |
|:------------------------------------------------------------------------------------------------------------|:----------------------------------|:--------|-------:|
| deadlock detection in distributed database systems : a new algorithm and a comparative performance analysis | n krivokapic , a kemper , e gudes | vldb j. |   1999 |

Entity B:
| title                                                                    | authors                  | venue           |   year |
|:-------------------------------------------------------------------------|:-------------------------|:----------------|-------:|
| performance evaluation of a new distributed deadlock detection algorithm | c yeung , s hung , k lam | sigmod record , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2383
rtable_id: 35679
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 ir-style keyword search over relational databases | v hristidis , l gravano , y papakonstantinou | vldb    |   2003 |

Entity B:
| title                                                      | authors                           | venue   | year   |
|:-----------------------------------------------------------|:----------------------------------|:--------|:-------|
| efficiency of nesting relational document database systems | j zobel , ja thom , r sacks-davis |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2029
rtable_id: 50687
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 |
|:---------------------------------------------------------|:---------------------------|:---------------------------------------------------------|-------:|
| queries with incomplete answers over semistructured data | y kanza , w nutt , y sagiv | proc acm sigact sigmod sigart symp princ database syst , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 527
rtable_id: 15463
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 |
|:-----------------------------------------------|:---------------------------|:----------------------------|-------:|
| analysis of predictive spatio-temporal queries | y tao , j sun , d papadias | acm trans . database syst . |   2003 |

Entity B:
| title                                          | authors                    | venue                                  |   year |
|:-----------------------------------------------|:---------------------------|:---------------------------------------|-------:|
| analysis of predictive spatio-temporal queries | y tao , j sun , d papadias | acm transactions on database systems , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 901
rtable_id: 21155
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 |
|:------------------------------------------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| automatic subspace clustering of high dimensional data for data mining applications | r agrawal , j gehrke , d gunopulos , p raghavan | sigmod conference |   1998 |

Entity B:
| title                                                                                                  | authors                                         | venue                                                                      | year   |
|:-------------------------------------------------------------------------------------------------------|:------------------------------------------------|:---------------------------------------------------------------------------|:-------|
| automatic subspace clustering of high dimensional data for data mining applications . eds. , haas , lm | r agrawal , j gehrke , d gunopulos , p raghavan | sigmod 1998 , proceedings acm sigmod international conference & hellip ; , |        |



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

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: 1981
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 |
|:-------------------------------------|:-----------------|:--------------|-------:|
| continuous queries over data streams | s babu , j widom | sigmod record |   2001 |

Entity B:
| title                                                                         | authors   | venue                                                                  |   year |
|:------------------------------------------------------------------------------|:----------|:-----------------------------------------------------------------------|-------:|
| processing sliding window multi-joins in continuous queries over data streams | l golab   | proceedings of the international conference on very large & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 178
rtable_id: 30419
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 and effective clustering methods for spatial data mining | r ng , j han | vldb    |   1994 |

Entity B:
| title                                                             | authors   | venue   | year   |
|:------------------------------------------------------------------|:----------|:--------|:-------|
| clarans : a method for clustering objects for spatial data mining | rt ng     |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 72
rtable_id: 435
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 consumer viewpoint on \ '' \ `` mediator languages - a proposal for a standard \ '' \ '' \ '' '' | a rosenthal , e hughes , s renner , l seligman | sigmod record |   1997 |

Entity B:
| title                                                     | authors                          | venue   | year   |
|:----------------------------------------------------------|:---------------------------------|:--------|:-------|
| mediator languages-a proposal for a standard , april 1996 | p buneman , l raschid , j ullman |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 576
rtable_id: 56790
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 |
|:----------------------------------------|:----------------------------------------------|:--------|-------:|
| c2p : clustering based on closest pairs | a nanopoulos , y theodoridis , y manolopoulos | vldb    |   2001 |

Entity B:
| title                                   | authors                                       | venue                                                                  |   year |
|:----------------------------------------|:----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| c2p : clustering based on closest pairs | a nanopoulos , y theodoridis , y manolopoulos | proceedings of the international conference on very large & hellip ; , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1149
rtable_id: 8168
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 |
|:------------------------------------------|:---------------------------------------|:--------------|-------:|
| towards knowledge-based digital libraries | l feng , m jeusfeld , j hoppenbrouwers | sigmod record |   2001 |

Entity B:
| title                                           | authors   | venue   | year   |
|:------------------------------------------------|:----------|:--------|:-------|
| towards a general theory of the digital library | m collier |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 371
rtable_id: 27168
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 |
|:--------------------------------------------------|:----------|:------------------|-------:|
| paradise : a database system for gis applications | p team    | sigmod conference |   1995 |

Entity B:
| title                                   | authors               | venue           |   year |
|:----------------------------------------|:----------------------|:----------------|-------:|
| sap r/3 : a database application system | a kemper , d kossmann | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1692
rtable_id: 61006
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 multiple dimensional queries simultaneously in multidimensional databases | w liang , m orlowska , j yu | vldb j. |   2000 |

Entity B:
| title                                 | authors                          | venue                                                             | year   |
|:--------------------------------------|:---------------------------------|:------------------------------------------------------------------|:-------|
| modeling multidimensional da [ abases | r agrawal , a gupta , s sarawagi | technical report , ibm almaden research center , 650 harry road , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2380
rtable_id: 47694
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 |
|:-------------------------------------------------------------------|:-----------------------|:---------------------------------------------------|-------:|
| a shared , segmented memory system for an object-oriented database | mf hornick , sb zdonik | acm transactions on information systems ( tois ) , |   1987 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 151
rtable_id: 5970
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 oracle warehouse | g hallmark | vldb    |   1995 |

Entity B:
| title                | authors    | venue           | year   |
|:---------------------|:-----------|:----------------|:-------|
| tales from warehouse | j ambrosio | computerworld , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 126
rtable_id: 24066
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 |
|:----------------------------------------------------|:--------------------|:--------|-------:|
| maintaining data privacy in association rule mining | s rizvi , j haritsa | vldb    |   2002 |

Entity B:
| title                                                       | authors                     | venue   | year   |
|:------------------------------------------------------------|:----------------------------|:--------|:-------|
| mining multi-dimensional association rules using data cubes | j han , m kamber , j chiang |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2126
rtable_id: 23531
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 |
|:-------------------------------------------------------------------|:-------------------------|:------------------|-------:|
| partition selection policies in object database garbage collection | j cook , a wolf , b zorn | sigmod conference |   1994 |

Entity B:
| title                                          | authors                 | venue                                                      | year   |
|:-----------------------------------------------|:------------------------|:-----------------------------------------------------------|:-------|
| partitioned collection of a large object store | u maheshwari , b liskov | proc . of sigmod international conference on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1793
rtable_id: 5296
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   |
|:-----------------------------------------------|:----------------------------------|:-------------------------------------------------------------------|:-------|
| sql-like operator for mining association rules | r meo , g psaila , s ceri , a new | proceedings of international conference on very large & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1288
rtable_id: 7046
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 |
|:--------------------------------------------|:----------|:----------------------------|-------:|
| declarative updates of relational databases | w chen    | acm trans . database syst . |   1995 |

Entity B:
| title                                                    | authors             | venue   | year   |
|:---------------------------------------------------------|:--------------------|:--------|:-------|
| incorporating computed relations in relational databases | d maier , ds warren |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2249
rtable_id: 40102
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 |
|:-------------------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| processing complex aggregate queries over data streams | a dobra , m garofalakis , j gehrke , r rastogi | sigmod conference |   2002 |

Entity B:
| title                                 | authors                       | venue         | year   |
|:--------------------------------------|:------------------------------|:--------------|:-------|
| streaming data over streaming queries | s chandrasekaran , m franklin | submitted for |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 515
rtable_id: 48824
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 |
|:-----------------------------------------------------------------|:-------------------------------------------------------------------------------------------------|:------------------|-------:|
| devise : integrated querying and visualization of large datasets | m livny , r ramakrishnan , k beyer , g chen , d donjerkovic , s lawande , j myllymaki , r wenger | sigmod conference |   1997 |

Entity B:
| title                                            | authors                                    | venue                                                 | year   |
|:-------------------------------------------------|:-------------------------------------------|:------------------------------------------------------|:-------|
| dataspace : 3-d visualization of large databases | v anupam , s dar , t leibfried , e petajan | proc . int &#39; l symp . information visualization , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1332
rtable_id: 26179
label: 0