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 |
|:---------------------------------------------------------------|:-----------------------|:------------------|-------:|
| an effective hash based algorithm for mining association rules | j park , m chen , p yu | sigmod conference |   1995 |

Entity B:
| title                                       | authors   | venue   | year   |
|:--------------------------------------------|:----------|:--------|:-------|
| mining fuzzy quantitative association rules | w zhang   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1543
rtable_id: 24994
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 annotated bibliography on active databases | u jaeger , j freytag | sigmod record |   1995 |

Entity B:
| title                    | authors                         | venue                                 |   year |
|:-------------------------|:--------------------------------|:--------------------------------------|-------:|
| annotated z bibliography | jp bowen , s stepney , r barden | information and software technology , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 781
rtable_id: 57113
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   |
|:-----------------------------|:------------------------|:-----------|:-------|
| continous query optimization | r avnur , j hellerstien | acm sigmod |        |



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

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

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

Entity A:
| title                                                       | authors                             | venue             |   year |
|:------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| data-driven understanding and refinement of schema mappings | l yan , r miller , l haas , r fagin | sigmod conference |   2001 |

Entity B:
| title                                                    | authors                                | venue                                                                  | year   |
|:---------------------------------------------------------|:---------------------------------------|:-----------------------------------------------------------------------|:-------|
| data-drivenunderstandingand refinementof schema mappings | ll yan , rj miller , lm haas , r fagin | proceedings of the acm sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 624
rtable_id: 9182
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title           | authors   | venue   |   year |
|:----------------|:----------|:--------|-------:|
| guest editorial |           |         |   2000 |

Entity B:
| title                           | authors          | venue           |   year |
|:--------------------------------|:-----------------|:----------------|-------:|
| guest editorâ ?? s introduction | tnd independence | sigmod record , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2483
rtable_id: 14605
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 effective hash based algorithm for mining association rules | j park , m chen , p yu | sigmod conference |   1995 |

Entity B:
| title                                                                                               | authors   | venue   |   year |
|:----------------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| an effective hash-based algorithm for mining association rules . in : proc . of the 1995 acm sigmod | js park   |         |   1995 |



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

Entity B:
| title                                  | authors                           | venue                                 |   year |
|:---------------------------------------|:----------------------------------|:--------------------------------------|-------:|
| moov + + : modular object-oriented vdm | c leuschen , r plumb , q charatan | information and software technology , |   2000 |



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

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

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

Entity A:
| title                                                                                                    | authors   | venue   |   year |
|:---------------------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| workshop report : the first international workshop on active and real-time database systems ( artdb-95 ) |           |         |   1996 |

Entity B:
| title                                                                                                | authors   | venue           |   year |
|:-----------------------------------------------------------------------------------------------------|:----------|:----------------|-------:|
| report on the 5th international workshop on knowledge representation meets databases ( krdbâ ?? 98 ) | a borgida | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 689
rtable_id: 1055
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 sliding window multi-joins in continuous queries over data streams | l golab , m жzsu | vldb    |   2003 |

Entity B:
| title                                                | authors                                     | venue                | year   |
|:-----------------------------------------------------|:--------------------------------------------|:---------------------|:-------|
| continously adaptive continuous queries over streams | s madden , m shah , j hellerstein , v raman | proc . of acm sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2113
rtable_id: 54465
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 hcc-tree : an efficient index structure for object oriented databases | b sreenath , s seshadri | vldb    |   1994 |

Entity B:
| title                                                     | authors               | venue   |   year |
|:----------------------------------------------------------|:----------------------|:--------|-------:|
| the x-tree : an index structure for high dimensional data | s berchtold , da keim |         |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 156
rtable_id: 48006
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 |
|:-------------------------------------------------------------------|:-----------------------------------------------|:----------------------------|-------:|
| automatic generation of production rules for integrity maintenance | s ceri , p fraternali , s paraboschi , l tanca | acm trans . database syst . |   1994 |

Entity B:
| title                                                                    | authors          | venue                                                             | year   |
|:-------------------------------------------------------------------------|:-----------------|:------------------------------------------------------------------|:-------|
| deriving production rules for incremental view maintenance , '' 17th int | s ceri , j widom | conf . on very large data bases , barcelona , spain , september , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2309
rtable_id: 25486
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 |
|:----------------------------------------------------------------|:----------|:--------|-------:|
| multiple-view self-maintenance in data warehousing environments | n huyn    | vldb    |   1997 |

Entity B:
| title                                                                 | authors                   | venue                                                  | year   |
|:----------------------------------------------------------------------|:--------------------------|:-------------------------------------------------------|:-------|
| j , hammer , j. widom . view maintenance in a warehousing environment | y zhuge , h garcia-molina | proc . of the acm sigmod intl. conf . on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1883
rtable_id: 15003
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 supporting containment queries in relational database management systems | c zhang , j naughton , d dewitt , q luo , g lohman | sigmod conference |   2001 |

Entity B:
| title                                                            | authors                                   | venue               |   year |
|:-----------------------------------------------------------------|:------------------------------------------|:--------------------|-------:|
| access path selection in a relational database management system | pg selinger , mm astrahan , dd chamberlin | sigmod conference , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 713
rtable_id: 59307
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 |
|:------------------------------------------------------|:--------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | i ilyas , w aref , a elmagarmid | vldb    |   2003 |

Entity B:
| title                                      | authors                      | venue                       | year   |
|:-------------------------------------------|:-----------------------------|:----------------------------|:-------|
| the theory of joins in relatmnal databases | av aho , c berri , jd ullman | acm trans . database syst , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2005
rtable_id: 34500
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 |
|:------------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| continuously adaptive continuous queries over streams | s madden , m shah , j hellerstein , v raman | sigmod conference |   2002 |

Entity B:
| title                                                          | authors             | venue   | year   |
|:---------------------------------------------------------------|:--------------------|:--------|:-------|
| a temporal foundation for continuous queries over data streams | j kramer , b seeger |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 399
rtable_id: 13962
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 |
|:----------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| view maintenance in a warehousing environment | y zhuge , h garcia-molina , j hammer , j widom | sigmod conference |   1995 |

Entity B:
| title                                 | authors                                     | venue                                                                  | year   |
|:--------------------------------------|:--------------------------------------------|:-----------------------------------------------------------------------|:-------|
| efficient view maintenance warehouses | d agrawal , a el abbadi , a singh , t yurek | proc . of the 1997 acm sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1612
rtable_id: 31146
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 |
|:------------------------------------------------------------|:----------|:--------------|-------:|
| advanced xml data processing - guest editor 's introduction | k aberer  | sigmod record |   2001 |

Entity B:
| title                                           | authors   | venue               | year   |
|:------------------------------------------------|:----------|:--------------------|:-------|
| special section on advanced xml data processing | k aberer  | acm sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 184
rtable_id: 26884
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 |
|:----------------------------------------------------------------------------|:------------------------|:--------------|-------:|
| extraction of object-oriented structures from existing relational databases | s ramanathan , j hodges | sigmod record |   1997 |

Entity B:
| title                                                              | authors      | venue                                                            | year   |
|:-------------------------------------------------------------------|:-------------|:-----------------------------------------------------------------|:-------|
| an approach to storing semistructured data in relational databases | kv magalhaes | msc thesis , department of computer science , federal university |        |



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

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

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

Entity A:
| title                                                        | authors               | venue             |   year |
|:-------------------------------------------------------------|:----------------------|:------------------|-------:|
| image mining in iris : integrated retinal information system | w hsu , m lee , k goh | sigmod conference |   2000 |

Entity B:
| title                                          | authors                                | venue   | year   |
|:-----------------------------------------------|:---------------------------------------|:--------|:-------|
| infomaster : an information integration system | mr genesereth , am keller , om duschka |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 904
rtable_id: 54028
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 ccube constraint object-oriented database system | a brodsky , v segal , j chen , p exarkhopoulo | sigmod conference |   1999 |

Entity B:
| title                                | authors      | venue                                                                    | year   |
|:-------------------------------------|:-------------|:-------------------------------------------------------------------------|:-------|
| metu object-oriented database system | a dogacâ ? ¦ | demo description , in the proc . acm sigmod intl. conf . on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1049
rtable_id: 4615
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 |
|:-------------------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| principles of optimally placing data in tertiary storage libraries | s christodoulakis , p triantafillou , f zioga | vldb    |   1997 |

Entity B:
| title                                                              | authors                                       | venue                                                                  |   year |
|:-------------------------------------------------------------------|:----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| principles of optimally placing data in tertiary storage libraries | s christodoulakis , p triantafillou , f zioga | proceedings of the international conference on very large & hellip ; , |   1997 |



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

Entity B:
| title                                                                               | authors   | venue                                            | year   |
|:------------------------------------------------------------------------------------|:----------|:-------------------------------------------------|:-------|
| supporting multi-media object management in a relational database management system | lm haas   | technical report . ibm almaden research center , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 657
rtable_id: 41223
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 |
|:------------------------------------------------------|:---------------------------|:--------|-------:|
| distance-based outliers : algorithms and applications | e knorr , r ng , v tucakov | vldb j. |   2000 |

Entity B:
| title                                                           | authors          | venue   |   year |
|:----------------------------------------------------------------|:-----------------|:--------|-------:|
| algorithms for mining distance-based outliers in large datasets | em knorr , rt ng | vldb ,  |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2405
rtable_id: 30360
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 |
|:-------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------|:--------|-------:|
| supporting state-wide immunisation tracking using multi-paradigm workflow technology | a sheth , k kochut , j miller , d worah , s das , c lin , d palaniswami , j lynch , i shevchenko | vldb    |   1996 |

Entity B:
| title                                                                          | authors                            | venue                                     | year   |
|:-------------------------------------------------------------------------------|:-----------------------------------|:------------------------------------------|:-------|
| supporting state-wide immunization tracking using multi-paradigm workflow tech | a sheth , k kochut , j millerâ ? ¦ | proc . 22nd vldb conf. , bombay , india , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2583
rtable_id: 6975
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 |
|:------------------------------------------------|:------------------------------------------------------------|:--------|-------:|
| vxmlr : a visual xml-relational database system | a zhou , h lu , s zheng , y liang , l zhang , w ji , z tian | vldb    |   2001 |

Entity B:
| title                                                       | authors                | venue                                  |   year |
|:------------------------------------------------------------|:-----------------------|:---------------------------------------|-------:|
| an authorization mechanism for a relational database system | pp griffiths , bw wade | acm transactions on database systems , |   1976 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1244
rtable_id: 494
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 |           |         |   2003 |

Entity B:
| title           | authors    | venue                         |   year |
|:----------------|:-----------|:------------------------------|-------:|
| guest editorial | gh rassool | journal of advanced nursing , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2280
rtable_id: 56451
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 |
|:-----------------------------------------|:----------|:--------------|-------:|
| temporal database system implementations | m bіhlen  | sigmod record |   1995 |

Entity B:
| title                                                                  | authors          | venue              | year   |
|:-----------------------------------------------------------------------|:-----------------|:-------------------|:-------|
| carey . programmingconstructs fordatabase systemimplementationinexodus | j richardsonandm | proc . of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 842
rtable_id: 2150
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 |
|:------------------------------------------------------|:----------------------------|:------------------|-------:|
| orthogonal optimization of subqueries and aggregation | c galindo-legaria , m joshi | sigmod conference |   2001 |

Entity B:
| title                                                 | authors                      | venue               |   year |
|:------------------------------------------------------|:-----------------------------|:--------------------|-------:|
| orthogonal optimization of subqueries and aggregation | ca galindo-legaria , m joshi | sigmod conference , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 688
rtable_id: 21830
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                   | authors   | venue   |   year |
|:----------------------------------------|:----------|:--------|-------:|
| dwms : data warehouse management system | n mohan   | vldb    |   1996 |

Entity B:
| title                                  | authors           | venue                              | year   |
|:---------------------------------------|:------------------|:-----------------------------------|:-------|
| parallel systems in the data warehouse | s morse , d isaac | upper saddle river , nj : prentice |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1842
rtable_id: 38567
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 |
|:-----------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| aurora : a data stream management system | d abadi , d carney , u чetintemel , m cherniack , c convey , c erwin , e galvez , m hatoun , a maskey , a rasin , a singer , m stonebraker , n tatbul , y xing , r yan , s zdonik | sigmod conference |   2003 |

Entity B:
| title                                                             | authors                  | venue                                                                    |   year |
|:------------------------------------------------------------------|:-------------------------|:-------------------------------------------------------------------------|-------:|
| medsman : a streaming data management system over live multimedia | b liu , a gupta , r jain | proceedings of the 13th annual acm international conference & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 280
rtable_id: 42091
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 |
|:--------------------------------------------------|:----------------------------------------------------------------------------------------------|:--------|-------:|
| smooth - a distributed multimedia database system | h kosch , l bіszіrmщnyi , a bachlechner , c hanin , c hofbauer , m lang , c riedler , r tusch | vldb    |   2001 |

Entity B:
| title                                  | authors    | venue                   |   year |
|:---------------------------------------|:-----------|:------------------------|-------:|
| multimedia database management systems | a ghafoo17 | acm computing surveys , |   1995 |



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

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

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

Entity A:
| title                                | authors               | venue   |   year |
|:-------------------------------------|:----------------------|:--------|-------:|
| mining generalized association rules | r srikant , r agrawal | vldb    |   1995 |

Entity B:
| title                                | authors               | venue                                                                 | year   |
|:-------------------------------------|:----------------------|:----------------------------------------------------------------------|:-------|
| mining generalized association rules | r agrawal , r srikant | proceedings of the 1995 international conference of very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 19
rtable_id: 27684
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 |
|:----------------|:-----------|:--------------|-------:|
| editor 's notes | m franklin | sigmod record |   1997 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 628
rtable_id: 31216
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 |
|:-----------------|:----------|:--------|-------:|
| chair 's message |           |         |   2000 |

Entity B:
| title                   | authors   | venue                                              | year   |
|:------------------------|:----------|:---------------------------------------------------|:-------|
| needha chair 's message | m hagler  | ieee edsoc/asee ee div . '' newsletter '' , spring |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 278
rtable_id: 3858
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 |
|:----------------------------------------------------|:----------|:--------|-------:|
| vldb workshop on technologies in e-services ( tes ) |           |         |   2000 |

Entity B:
| title                                                                                                  | authors   | venue           |   year |
|:-------------------------------------------------------------------------------------------------------|:----------|:----------------|-------:|
| report on the vldb workshop on technologies for e-services ( tes ) cairo , egypt september 14 and 15 , | f casati  | sigmod record , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 345
rtable_id: 54693
label: 1