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 |
|:-----------------------------------------------|:-----------|:--------|-------:|
| sampling large databases for association rules | h toivonen | vldb    |   1996 |

Entity B:
| title                                                      | authors      | venue   | year   |
|:-----------------------------------------------------------|:-------------|:--------|:-------|
| mining multiple-level association rules in large databases | j han , y fu |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2568
rtable_id: 44542
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 |
|:---------------------------------------------------------------------|:----------|:--------|-------:|
| report on first international workshop on real-time database systems |           |         |   1996 |

Entity B:
| title                                       | authors   | venue               | year   |
|:--------------------------------------------|:----------|:--------------------|:-------|
| special issue on real-time database systems | sh son    | acm sigmod record , |        |



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

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

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

Entity A:
| title                                                                              | authors   | venue   |   year |
|:-----------------------------------------------------------------------------------|:----------|:--------|-------:|
| query decomposition and view maintenance for query languages for unstructured data | d suciu   | vldb    |   1996 |

Entity B:
| title                                                              | authors                                         | venue               |   year |
|:-------------------------------------------------------------------|:------------------------------------------------|:--------------------|-------:|
| a query language and optimization techniques for unstructured data | p buneman , s davidson , g hillebrand , d suciu | sigmod conference , |   1996 |



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

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

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

Entity A:
| title                                   | authors                         | venue             |   year |
|:----------------------------------------|:--------------------------------|:------------------|-------:|
| query rewriting for semistructured data | y papakonstantinou , v vassalos | sigmod conference |   1999 |

Entity B:
| title                                    | authors                           | venue   | year   |
|:-----------------------------------------|:----------------------------------|:--------|:-------|
| storing semistructured data in relations | a deutsch , m fernandez , d suciu |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1065
rtable_id: 31823
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 |
|:-----------------------------------------------------------------------------|:-------------------------------------|:------------------|-------:|
| optimization of constrained frequent set queries with 2-variable constraints | l lakshmanan , r ng , j han , a pang | sigmod conference |   1999 |

Entity B:
| title                                                | authors              | venue                                  |   year |
|:-----------------------------------------------------|:---------------------|:---------------------------------------|-------:|
| optimization of queries with user-defined predicates | s chaudhuri , k shim | acm transactions on database systems , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1010
rtable_id: 10586
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 editorial |           |         |   2000 |

Entity B:
| title     | authors   | venue                                          | year   |
|:----------|:----------|:-----------------------------------------------|:-------|
| editorial | ca insko  | journal of personality and social psychology , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2483
rtable_id: 48536
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 |
|:--------------------------------------------------------------|:----------|:--------|-------:|
| information management challenges from the aerospace industry | s sripada | vldb    |   2002 |

Entity B:
| title                                                                     | authors    | venue   |   year |
|:--------------------------------------------------------------------------|:-----------|:--------|-------:|
| information security management : global challenges in the new millennium | gs dhillon |         |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2159
rtable_id: 26476
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   |
|:-------------------------------------------------|:---------------------|:------------------------------------------------------------|:-------|
| query processing in main memory database systems | tj lehman , mj carey | proc . of the acm sigmod intâ ?? l. conf . on management of |        |



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

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

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

Entity A:
| title                               | authors                                                                            | venue   |   year |
|:------------------------------------|:-----------------------------------------------------------------------------------|:--------|-------:|
| the aditi deductive database system | j vaghani , k ramamohanarao , d kemp , z somogyi , p stuckey , t leask , j harland | vldb j. |   1994 |

Entity B:
| title                                                                          | authors                                           | venue                                 |   year |
|:-------------------------------------------------------------------------------|:--------------------------------------------------|:--------------------------------------|-------:|
| the formalisation of rock & roll : a deductive object-oriented database system | aaa fernandes , ml barja , nw paton , mh williams | information and software technology , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2554
rtable_id: 19619
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 |
|:---------------------------------------------------------------------|:----------|:--------|-------:|
| report on first international workshop on real-time database systems |           |         |   1996 |

Entity B:
| title                                                         | authors               | venue                                |   year |
|:--------------------------------------------------------------|:----------------------|:-------------------------------------|-------:|
| secure concurrency control in firm real-time database systems | b george , jr haritsa | distributed and parallel databases , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 649
rtable_id: 28491
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 editorial |           |         |   2001 |

Entity B:
| title                        | authors   | venue                                           |   year |
|:-----------------------------|:----------|:------------------------------------------------|-------:|
| guest editor 's introduction | wb elley  | international journal of educational research , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2492
rtable_id: 33729
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   |
|:---------------------------------------|:----------|:-------------------------------|:-------|
| data allocation in distributed systems | p apers   | acm trans . database systems , |        |



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

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

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

Entity A:
| title                                   | authors   | venue   |   year |
|:----------------------------------------|:----------|:--------|-------:|
| open object database management systems |           |         |   1994 |

Entity B:
| title                                                                | authors                                   | venue   | year   |
|:---------------------------------------------------------------------|:------------------------------------------|:--------|:-------|
| a global garbage collector for federated database management systems | m frã © dã © ric , t jean-marc , b pierre |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1829
rtable_id: 31442
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 practical and modular implementation of extended transaction models | r barga , c pu | vldb    |   1995 |

Entity B:
| title                                      | authors         | venue                            | year   |
|:-------------------------------------------|:----------------|:---------------------------------|:-------|
| aformalism for extended transaction models | pkck ramamritam | proc . of 17th vldb conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1973
rtable_id: 55543
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 |
|:----------------------------------------------------------------------|:-------------------------|:--------|-------:|
| heterogeneous database query optimization in db2 universal datajoiner | s venkataraman , t zhang | vldb    |   1998 |

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



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

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

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

Entity A:
| title                      | authors            | venue   |   year |
|:---------------------------|:-------------------|:--------|-------:|
| query optimization for xml | j mchugh , j widom | vldb    |   1999 |

Entity B:
| title                                   | authors            | venue                    | year   |
|:----------------------------------------|:-------------------|:-------------------------|:-------|
| a rule-based view of query optimization | jc freytag freytag | proc . acm sigmod conf , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1431
rtable_id: 29762
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 |
|:------------------------------------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| ensuring relaxed atomicity for flexible transactions in multidatabase systems | a zhang , m nodine , b bhargava , o bukhres | sigmod conference |   1994 |

Entity B:
| title                                                                         | authors                      | venue                                                                   | year   |
|:------------------------------------------------------------------------------|:-----------------------------|:------------------------------------------------------------------------|:-------|
| andg . r. thompson . reliable transactionmanagement in a multidatabase system | y breitbart , a silberschatz | proceedings of acm-sigmod 1990 international conference on & hellip ; , |        |



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

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

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

Entity A:
| title                                            | authors   | venue   |   year |
|:-------------------------------------------------|:----------|:--------|-------:|
| index configuration in object-oriented databases | e bertino | vldb j. |   1994 |

Entity B:
| title                                                  | authors         | venue                               |   year |
|:-------------------------------------------------------|:----------------|:------------------------------------|-------:|
| export database derivation in object-oriented wrappers | ep lim , hk lee | information & software technology , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2564
rtable_id: 35152
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 |
|:-------------------------------------------------------------------------|:----------------------|:--------|-------:|
| qualitative representation of spatial knowledge in two-dimensional space | d papadias , t sellis | vldb j. |   1994 |

Entity B:
| title                                                                 | authors    | venue          | year   |
|:----------------------------------------------------------------------|:-----------|:---------------|:-------|
| qualitative representation ofspatial knowledge intwo-dimensionalspace | dpt sellis | vldb journal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2542
rtable_id: 61465
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 |
|:------------------------------------------------------------------------------------------|:----------------------------------|:--------|-------:|
| unql : a query language and algebra for semistructured data based on structural recursion | p buneman , m fernandez , d suciu | vldb j. |   2000 |

Entity B:
| title                                                                            | authors                                         | venue       | year   |
|:---------------------------------------------------------------------------------|:------------------------------------------------|:------------|:-------|
| a query language and optimization techniques for unstructured dataâ '' in sigmod | p buneman , s davidson , g hillebrand , d suciu | san diego , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2394
rtable_id: 3722
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 |
|:------------------------------------------------------|:----------------------------------------------------------------------------|:--------|-------:|
| sideway value algebra for object-relational databases | g жzsoyoglu , a al-hamdani , i altingіvde , s жzel , ж ulusoy , z жzsoyoglu | vldb    |   2002 |

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: 2203
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 | j widom   | sigmod record |   1996 |

Entity B:
| title           | authors   | venue                                 | year   |
|:----------------|:----------|:--------------------------------------|:-------|
| editor 's notes | dw leslie | new directions for higher education , |        |



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

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

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

Entity A:
| title                        | authors   | venue   |   year |
|:-----------------------------|:----------|:--------|-------:|
| guest editor 's introduction |           |         |   2002 |

Entity B:
| title           | authors                                     | venue                                                                 |   year |
|:----------------|:--------------------------------------------|:----------------------------------------------------------------------|-------:|
| guest editorial | pa bernstein , y ioannidis , r ramakrishnan | the vldb journal the international journal on very large & hellip ; , |   2003 |



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

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

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

Entity A:
| title                                     | authors                   | venue             |   year |
|:------------------------------------------|:--------------------------|:------------------|-------:|
| extracting structured data from web pages | a arasu , h garcia-molina | sigmod conference |   2003 |

Entity B:
| title                                                     | authors                   | venue                                                       | year   |
|:----------------------------------------------------------|:--------------------------|:------------------------------------------------------------|:-------|
| s. university . extracting structured data from web pages | a arasu , h garcia-molina | proceedings of the 2003 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 212
rtable_id: 42916
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 |
|:------------------------------------------------------|:------------------------------|:----------------------------|-------:|
| efficient dynamic mining of constrained frequent sets | l lakshmanan , c leung , r ng | acm trans . database syst . |   2003 |

Entity B:
| title                                              | authors               | venue   |   year |
|:---------------------------------------------------|:----------------------|:--------|-------:|
| mining frequent itemsets using support constraints | k wang , y he , j han | vldb ,  |   2000 |



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

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

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

Entity A:
| title                                  | authors             | venue   |   year |
|:---------------------------------------|:--------------------|:--------|-------:|
| query processing techniques for arrays | a marathe , k salem | vldb j. |   2002 |

Entity B:
| title                                                      | authors   | venue                                  |   year |
|:-----------------------------------------------------------|:----------|:---------------------------------------|-------:|
| fragmentation : a technique for efficient query processing | gm sacco  | acm transactions on database systems , |   1986 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2452
rtable_id: 39106
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 | r diem    | social studies and the young learner , |        |



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

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

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

Entity A:
| title                                         | authors    | venue   |   year |
|:----------------------------------------------|:-----------|:--------|-------:|
| query processing in tertiary memory databases | s sarawagi | vldb    |   1995 |

Entity B:
| title                                         | authors   | venue                                                                  | year   |
|:----------------------------------------------|:----------|:-----------------------------------------------------------------------|:-------|
| query processing in tertiary memory databases | s samwagi | proc . of the 19â ?? â ?? vldb conference , switzerland , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 104
rtable_id: 57889
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   |
|:------------------------------------------------------------------------------|:-----------------------------|:----------------------|:-------|
| ps yu . a framework for projected clustering of high dimensional data streams | cc aggarwal , j han , j wang | proceedings of vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1129
rtable_id: 36738
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 nearest neighbor search in medical image databases | f korn , n sidiropoulos , c faloutsos , e siegel , z protopapas | vldb    |   1996 |

Entity B:
| title                                                   | authors                                    | venue                                  |   year |
|:--------------------------------------------------------|:-------------------------------------------|:---------------------------------------|-------:|
| aggregate nearest neighbor queries in spatial databases | d papadias , y tao , k mouratidis , ck hui | acm transactions on database systems , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1807
rtable_id: 39292
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 the minimization of xpath queries | s flesca , f furfaro , e masciari | vldb    |   2003 |

Entity B:
| title                                | authors                                              | venue   | year   |
|:-------------------------------------|:-----------------------------------------------------|:--------|:-------|
| minimization of tree pattern queries | s amer-yahia , s cho , lvs lakshmanan , d srivastava |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2086
rtable_id: 30817
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 progressive skyline computation | k tan , p eng , b ooi | vldb    |   2001 |

Entity B:
| title                                         | authors         | venue                  | year   |
|:----------------------------------------------|:----------------|:-----------------------|:-------|
| bco efficient progressive skyline computation | kl tan , pk eng | vldb ( 2001 ) , morgan |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1151
rtable_id: 47391
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 |
|:-----------------------------------|:-------------------|:------------------|-------:|
| partition based spatial-merge join | j patel , d dewitt | sigmod conference |   1996 |

Entity B:
| title                                                | authors              | venue                              | year   |
|:-----------------------------------------------------|:---------------------|:-----------------------------------|:-------|
| partition based spatial-merge join , acm sigmod intl | jm patel , dj dewitt | conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1532
rtable_id: 14381
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 |
|:-----------------------------------------|:-------------------------|:--------|-------:|
| optimizing queries on compressed bitmaps | s amer-yahia , t johnson | vldb    |   2000 |

Entity B:
| title                           | authors                               | venue                                                         | year   |
|:--------------------------------|:--------------------------------------|:--------------------------------------------------------------|:-------|
| optimizing nonrecursive queries | r krishnamurthy , h boral , c zaniolo | proc 1986 international conference on very large data bases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1361
rtable_id: 38075
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 |
|:------------------------------------------------------|:----------------------------------|:------------------|-------:|
| geominer : a system prototype for spatial data mining | j han , k koperski , n stefanovic | sigmod conference |   1997 |

Entity B:
| title                                                           | authors                                              | venue   | year   |
|:----------------------------------------------------------------|:-----------------------------------------------------|:--------|:-------|
| multimediaminer : a system prototype for multimedia data mining | or zã $ ä ± ane , j han , zn li , jy chiang , s chee | proc .  |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1323
rtable_id: 54568
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 mid-query re-optimization of sub-optimal query execution plans | n kabra , d dewitt | sigmod conference |   1998 |

Entity B:
| title                         | authors           | venue                                            | year   |
|:------------------------------|:------------------|:-------------------------------------------------|:-------|
| dynamic query execution plans | g graefe , k ward | proceedings of the acm sigmod conference , ( may |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1143
rtable_id: 26181
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 |
|:-----------------------------------------------|:------------------------------------|:------------------|-------:|
| infomaster : an information integration system | m genesereth , a keller , o duschka | sigmod conference |   1997 |

Entity B:
| title                                         | authors           | venue   |   year |
|:----------------------------------------------|:------------------|:--------|-------:|
| interoperating geographic information systems | mf goodchildâ ? ¦ |         |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1365
rtable_id: 967
label: 0