MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: DBLP-ACM)

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 ores temporal database management system | babis theodoulidis , george karvelis , jayant chaudhary , aziz ait-braham , simon sou , george andrianopoulos | sigmod conference |   1994 |

Entity B:
| title                        | authors                            | venue                                          |   year |
|:-----------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| data grid management systems | arun jagatheesan , arcot rajasekar | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 78
rtable_id: 2250
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 impact of technology on commercial transaction processing | edward e. cobb | vldb j. |   1997 |

Entity B:
| title                                                                 | authors           | venue                                          |   year |
|:----------------------------------------------------------------------|:------------------|:-----------------------------------------------|-------:|
| directv and oracle rdb : the challenge of vldb transaction processing | william l. gettys | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2152
rtable_id: 1494
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 database and information system research group at the university of ulm | peter dadam , wolfgang klas | sigmod record |   1997 |

Entity B:
| title                                                       | authors          | venue             |   year |
|:------------------------------------------------------------|:-----------------|:------------------|-------:|
| research in database engineering at the university of namur | jean-luc hainaut | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2091
rtable_id: 2152
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | sang hyuk son , rasikan david , bhavani m. thuraisingham | sigmod record |   1996 |

Entity B:
| title                                                       | authors                                 | venue                                          |   year |
|:------------------------------------------------------------|:----------------------------------------|:-----------------------------------------------|-------:|
| applying update streams in a soft real-time database system | b. adelberg , h. garcia-molina , b. kao | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 925
rtable_id: 1513
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 aggregation in active database rules | iakovos motakis , carlo zaniolo | sigmod conference |   1997 |

Entity B:
| title                                              | authors                              | venue                 |   year |
|:---------------------------------------------------|:-------------------------------------|:----------------------|-------:|
| transaction timestamping in ( temporal ) databases | christian s. jensen , david b. lomet | very large data bases |   2001 |



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

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 |
|:-------------------------|:-----------------------------------------------------|:------------------|-------:|
| nearest neighbor queries | stephen kelley , frédéic vincent , nick roussopoulos | sigmod conference |   1995 |

Entity B:
| title                                        | authors                           | venue                                          |   year |
|:---------------------------------------------|:----------------------------------|:-----------------------------------------------|-------:|
| optimal multi-step k-nearest neighbor search | thomas seidl , hans-peter kriegel | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1722
rtable_id: 1778
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| thémis : a database programming language handling integrity constraints | anne doucet , véronique benzaken | vldb j. |   1995 |

Entity B:
| title                                                            | authors                             | venue             |   year |
|:-----------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| applications of java programming language to database management | bradley f. burton , victor w. marek | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 182
rtable_id: 1769
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------------------------|:---------------------------------------|:--------------|-------:|
| nsf workshop on industrial/academic cooperation in database systems | leonard j. seligman , michael j. carey | sigmod record |   1999 |

Entity B:
| title                                       | authors                    | venue                                                                  |   year |
|:--------------------------------------------|:---------------------------|:-----------------------------------------------------------------------|-------:|
| an introduction to spatial database systems | ralf hartmut g &#252; ting | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 877
rtable_id: 589
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------------------------|:--------------------------------------------------|:------------------|-------:|
| vqbd : exploring semistructured data | jihwang yeo , sudarshan s. chawathe , thomas baby | sigmod conference |   2001 |

Entity B:
| title                                      | authors                                               | venue             |   year |
|:-------------------------------------------|:------------------------------------------------------|:------------------|-------:|
| inferring structure in semistructured data | svetlozer nestorov , serge abiteboul , rajeev motwani | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 747
rtable_id: 1751
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------|:-----------------------------------------------|:--------|-------:|
| dynamic maintenance of wavelet-based histograms | yossi matias , jeffrey scott vitter , min wang | vldb    |   2000 |

Entity B:
| title                               | authors                                                 | venue                                          |   year |
|:------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| dynamic multidimensional histograms | nitin thaper , sudipto guha , piotr indyk , nick koudas | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1926
rtable_id: 677
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------|:--------------------------------------------------------------------|:------------------|-------:|
| maintenance of automatic summary tables | richard sidle , wolfgang lehner , hamid pirahesh , roberta cochrane | sigmod conference |   2000 |

Entity B:
| title                                                       | authors                                                         | venue                                          |   year |
|:------------------------------------------------------------|:----------------------------------------------------------------|:-----------------------------------------------|-------:|
| maintenance of data cubes and summary tables in a warehouse | inderpal singh mumick , dallan quass , barinderpal singh mumick | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2429
rtable_id: 1929
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------------|:----------------|:------------------|-------:|
| upsizing from file server to clent server architectures | the access team | sigmod conference |   1995 |

Entity B:
| title                               | authors                          | venue                                          |   year |
|:------------------------------------|:---------------------------------|:-----------------------------------------------|-------:|
| proxy-server architectures for olap | panos kalnis , dimitris papadias | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1814
rtable_id: 312
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------|:------------|:--------------|-------:|
| book review column | karl aberer | sigmod record |   2001 |

Entity B:
| title              | authors     | venue             |   year |
|:-------------------|:------------|:------------------|-------:|
| book review column | karl aberer | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2583
rtable_id: 2202
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | jennifer widom | sigmod record |   1996 |

Entity B:
| title     | authors           | venue                                         |   year |
|:----------|:------------------|:----------------------------------------------|-------:|
| editorial | richard snodgrass | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2548
rtable_id: 342
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| socqet : semantic olap with compressed cube and summarization | yan zhao , laks v. s. lakshmanan , jian pei | sigmod conference |   2003 |

Entity B:
| title                                                         | authors                                     | venue                                          |   year |
|:--------------------------------------------------------------|:--------------------------------------------|:-----------------------------------------------|-------:|
| socqet : semantic olap with compressed cube and summarization | laks v. s. lakshmanan , jian pei , yan zhao | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 887
rtable_id: 2002
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 database group at university of hagen ( fernuniversitaet ) | silke mittrach , gunter schlageter , thomas berkel , andreas scherer , eberhard heuel , wolfgang wilkes | sigmod record |   1995 |

Entity B:
| title                                     | authors                                                                      | venue             |   year |
|:------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| the database research group at eth zurich | moira c. norrie , stephen m. blott , hans-j &#246; rg schek , gerhard weikum | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 240
rtable_id: 1704
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 |
|:----------------------------------------------|:---------------------------------------|:--------|-------:|
| generalized search trees for database systems | j hellerstein , j naughton , a pfeffer | vldb    |   1995 |

Entity B:
| title                                                                              | authors                      | venue                          | year   |
|:-----------------------------------------------------------------------------------|:-----------------------------|:-------------------------------|:-------|
| avi pfeffer generalized search trees for database systems ( 1995 ) proc . 21st int | jm hellerstein , jf naughton | conf . very large data bases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1963
rtable_id: 41208
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 multi-feature queries for image databases | u gќntzer , w balke , w kieпling | vldb    |   2000 |

Entity B:
| title                                          | authors                  | venue                                       | year   |
|:-----------------------------------------------|:-------------------------|:--------------------------------------------|:-------|
| optimizing queries across diverse data sources | kd haaslm , yj wimmersel | proc . ofvery large data bases conference , |        |



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

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

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

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

Entity B:
| title                                              | authors      | venue   |   year |
|:---------------------------------------------------|:-------------|:--------|-------:|
| constraints on null values in relational databases | bs goldstein | vldb ,  |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2431
rtable_id: 28688
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 |
|:-------------------------------------------|:------------|:--------------|-------:|
| repositories and object oriented databases | p bernstein | sigmod record |   1998 |

Entity B:
| title                                                                          | authors                   | venue                                 |   year |
|:-------------------------------------------------------------------------------|:--------------------------|:--------------------------------------|-------:|
| operations and queries in object-oriented databases supporting complex objects | n bhalla , s balasundaram | information and software technology , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 632
rtable_id: 23818
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 efficient algorithm for mining association rules in large databases | a savasere , e omiecinski , s navathe | vldb    |   1995 |

Entity B:
| title                                                             | authors                     | venue                      | year   |
|:------------------------------------------------------------------|:----------------------------|:---------------------------|:-------|
| cure : an efficient clustering algorithm for large data databases | s guha , r rastogi , k shim | proc . of the acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 4376
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 |
|:------------------------------------------------------------------------------------------------|:----------------------------|:--------|-------:|
| l/mrp : a buffer management strategy for interactive continuous data flows in a multimedia dbms | f moser , a kraiss , w klas | vldb    |   1995 |

Entity B:
| title                                                                                                  | authors             | venue                                  | year   |
|:-------------------------------------------------------------------------------------------------------|:--------------------|:---------------------------------------|:-------|
| w ; klas . l/mrp : a buer management strategy for interactive continuous data ows in a multimedia dbms | f moser , a kraisse | international conference on very large |        |



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

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

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

Entity A:
| title                                        | authors                                                                             | venue             |   year |
|:---------------------------------------------|:------------------------------------------------------------------------------------|:------------------|-------:|
| the ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j chaudhary , g karvelis , s sou | sigmod conference |   1994 |

Entity B:
| title                        | authors                  | venue   | year   |
|:-----------------------------|:-------------------------|:--------|:-------|
| data grid management systems | rw moore , a jagatheesan |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1840
rtable_id: 538
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 |
|:-----------------------------------------|:--------------------------------------------------------------------------------------|:------------------|-------:|
| xml-based information mediation with mix | c baru , a gupta , b ludфscher , r marciano , y papakonstantinou , p velikhov , v chu | sigmod conference |   1999 |

Entity B:
| title                                                 | authors                                                 | venue   | year   |
|:------------------------------------------------------|:--------------------------------------------------------|:--------|:-------|
| xml-based information mediation for digital libraries | ck baru , v chu , a gupta , b ludaescher , r marciano , |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1123
rtable_id: 23664
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   |
|:-------------------------------------------------------|:------------|:-----------------------------------------------------|:-------|
| query optimization at the crossroads ( panel session ) | s chaudhuri | proc . 1997 acm sigmod int . conf . on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1431
rtable_id: 50973
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 |
|:-------------------------------------------------------------------|:-----------------|:--------|-------:|
| dynamic multi-resource load balancing in parallel database systems | e rahm , r marek | vldb    |   1995 |

Entity B:
| title                                            | authors               | venue                                                                     |   year |
|:-------------------------------------------------|:----------------------|:--------------------------------------------------------------------------|-------:|
| special issue in parallelism in database systems | m carey , p valduriez | the vldb journalâ ?? the international journal on very large & hellip ; , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1957
rtable_id: 33657
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 extraction and transformation for the data warehouse | c squire  | sigmod conference |   1995 |

Entity B:
| title                                                     | authors    | venue   | year   |
|:----------------------------------------------------------|:-----------|:--------|:-------|
| automation in information extraction and data integration | s sarawagi | vldb ,  |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1574
rtable_id: 17701
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 |
|:---------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| cost-based optimization for magic : algebra and implementation | p seshadri , j hellerstein , h pirahesh , t leung , r ramakrishnan , d srivastava , p stuckey , s sudarshan | sigmod conference |   1996 |

Entity B:
| title                             | authors         | venue   |   year |
|:----------------------------------|:----------------|:--------|-------:|
| cost based optimization for magic | p seshadriâ ? ¦ |         |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1462
rtable_id: 57842
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 |
|:-------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| context-based prefetch - an optimization for implementing objects on relations | p bernstein , s pal , d shutt | vldb j. |   2000 |

Entity B:
| title                                                                                                  | authors            | venue   | year   |
|:-------------------------------------------------------------------------------------------------------|:-------------------|:--------|:-------|
| opt + + - an object oriented implementation for extensible database query optimization , submitted for | n kabra , d dewitt | see     |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2476
rtable_id: 59797
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 index selection schemes for nested object hierarchies | s chawathe , m chen , p yu | vldb    |   1994 |

Entity B:
| title                                                                                   | authors       | venue                                                   | year   |
|:----------------------------------------------------------------------------------------|:--------------|:--------------------------------------------------------|:-------|
| join index hierarchies for supporting efficient navigation in object-oriented databases | z xie , j han | proc . int . conf . on very large data bases ( vldb ) , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 241
rtable_id: 3284
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 |
|:--------------------------------------------------|:---------------------------------|:--------|-------:|
| discover : keyword search in relational databases | v hristidis , y papakonstantinou | vldb    |   2002 |

Entity B:
| title                                                 | authors                 | venue                                                       | year   |
|:------------------------------------------------------|:------------------------|:------------------------------------------------------------|:-------|
| set-oriented production rules in relational databases | j widom , s finkelstein | proc . of the acm sigmod conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2125
rtable_id: 39994
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 hyperion project : from data integration to data coordination | m arenas , v kantere , a kementsietsidis , i kiringa , r miller , j mylopoulos | sigmod record |   2003 |

Entity B:
| title                                                             | authors                                                | venue               | year   |
|:------------------------------------------------------------------|:-------------------------------------------------------|:--------------------|:-------|
| the hyperion project : from data integration to data collection . | m arenas , v kantere , a kementsietsidis , i kiringa , | acm sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1942
rtable_id: 63573
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 |
|:--------------------------------------------------------|:-------------------------------|:--------|-------:|
| fibonacci : a programming language for object databases | a albano , g ghelli , r orsini | vldb j. |   1995 |

Entity B:
| title                         | authors                     | venue   |   year |
|:------------------------------|:----------------------------|:--------|-------:|
| storyof programming languages | tj bergin jr , rg gibson jr |         |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2521
rtable_id: 7669
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 |
|:------------------------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| capbased-ams : a capability-based and event-driven activity management system | p hung , h yeung , k karlapalem | sigmod conference |   1996 |

Entity B:
| title                                                                       | authors                 | venue   | year   |
|:----------------------------------------------------------------------------|:------------------------|:--------|:-------|
| implementation of web-based event-driven activity execution in capbased-ams | pck hung , k karlapalem |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1436
rtable_id: 20629
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 editorial | gh rassool | journal of advanced nursing , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2492
rtable_id: 56451
label: 0