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 |
|:---------------------------------------------|:---------------------------------------------------|:--------|-------:|
| visual web information extraction with lixto | georg gottlob , robert baumgartner , sergio flesca | vldb    |   2001 |

Entity B:
| title                             | authors             | venue             |   year |
|:----------------------------------|:--------------------|:------------------|-------:|
| dynamic information visualization | yannis e. ioannidis | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1307
rtable_id: 1888
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 |
|:---------------------------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| hypergraph based reorderings of outer join queries with complex predicates | gautam bhargava , balakrishna r. iyer , piyush goel | sigmod conference |   1995 |

Entity B:
| title                                                | authors                          | venue                                         |   year |
|:-----------------------------------------------------|:---------------------------------|:----------------------------------------------|-------:|
| optimization of queries with user-defined predicates | surajit chaudhuri , kyuseok shim | acm transactions on database systems ( tods ) |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2414
rtable_id: 104
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 |
|:----------------------------------------------|:------------------------------------------------------------------------------------------------------|:------------------|-------:|
| languages for multi-database interoperability | laks v. s. lakshmanan , frédéric gingras , nematollaah shiri , despina papoulis , iyer n. subramanian | sigmod conference |   1997 |

Entity B:
| title                                                                            | authors                                                       | venue                 |   year |
|:---------------------------------------------------------------------------------|:--------------------------------------------------------------|:----------------------|-------:|
| schemasql - a language for interoperability in relational multi-database systems | laks v. s. lakshmanan , fereidoon sadri , iyer n. subramanian | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2573
rtable_id: 1135
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 |
|:-----------------------------------------------------------------------------------------------------------|:--------------------------------------------------|:--------|-------:|
| evaluating functional joins along nested reference sets in object-relational and object-oriented databases | alfons kemper , reinhard braumandl , jens claußen | vldb    |   1998 |

Entity B:
| title                                                                                      | authors                                               | venue                 |   year |
|:-------------------------------------------------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| cost-based selection of path expression processing algorithms in object-oriented databases | georges gardarin , jean-robert gruser , zhao-hui tang | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1471
rtable_id: 1125
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 |
|:--------------------------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| structures for manipulating proposed updates in object-oriented databases | richard hull , mohammed rupawalla , michael doherty | sigmod conference |   1996 |

Entity B:
| title                                                | authors                                               | venue                 |   year |
|:-----------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| a cost model for clustered object-oriented databases | georges gardarin , jean-robert gruser , zhao-hui tang | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1799
rtable_id: 1479
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 |
|:--------------------------------------------|:------------------------------------------------------|:--------|-------:|
| query optimization by predicate move-around | inderpal singh mumick , alon y. levy , yehoshua sagiv | vldb    |   1994 |

Entity B:
| title                                             | authors                                    | venue                                          |   year |
|:--------------------------------------------------|:-------------------------------------------|:-----------------------------------------------|-------:|
| query optimization in compressed database systems | zhiyuan chen , johannes gehrke , flip korn | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 141
rtable_id: 304
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 |
|:----------------------------------------------------|:----------------|:--------|-------:|
| searching in metric spaces by spatial approximation | gonzalo navarro | vldb j. |   2002 |

Entity B:
| title                                               | authors         | venue                                                                  |   year |
|:----------------------------------------------------|:----------------|:-----------------------------------------------------------------------|-------:|
| searching in metric spaces by spatial approximation | gonzalo navarro | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 467
rtable_id: 1197
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 |
|:--------------------------------------|:----------|:--------------|-------:|
| a hypertext query language for images | li yang   | sigmod record |   1994 |

Entity B:
| title                                         | authors         | venue                                         |   year |
|:----------------------------------------------|:----------------|:----------------------------------------------|-------:|
| safe query languages for constraint databases | peter z. revesz | acm transactions on database systems ( tods ) |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 312
rtable_id: 232
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 |
|:-------------------------------------------------------------|:---------------------------------|:--------|-------:|
| storage and retrieval of xml data using relational databases | surajit chaudhuri , kyuseok shim | vldb    |   2001 |

Entity B:
| title                                 | authors                                                                                       | venue                 |   year |
|:--------------------------------------|:----------------------------------------------------------------------------------------------|:----------------------|-------:|
| querying xml views of relational data | jayavel shanmugasundaram , jerry kiernan , eugene j. shekita , catalina fan , john funderburk | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2518
rtable_id: 1320
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 |
|:---------------------------------------|:----------------------|:--------------|-------:|
| knowledge discovery in data warehouses | themistoklis palpanas | sigmod record |   2000 |

Entity B:
| title                                               | authors                                                              | venue                 |   year |
|:----------------------------------------------------|:---------------------------------------------------------------------|:----------------------|-------:|
| controlling data warehouses with knowledge networks | elvira schaefer , jan-dirk becker , andreas boehmer , matthias jarke | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2155
rtable_id: 895
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 |
|:--------------------------------------------------------|:---------------|:--------------|-------:|
| learning about data integration challenges from day one | alon y. halevy | sigmod record |   2003 |

Entity B:
| title                                                   | authors        | venue             |   year |
|:--------------------------------------------------------|:---------------|:------------------|-------:|
| learning about data integration challenges from day one | alon y. halevy | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1875
rtable_id: 2254
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 |
|:----------------------------------------------------------|:-------------------------------------------------|:------------------|-------:|
| automatic discovery of language models for text databases | aiqun du , james p. callan , margaret e. connell | sigmod conference |   1999 |

Entity B:
| title                                                     | authors                                    | venue                                          |   year |
|:----------------------------------------------------------|:-------------------------------------------|:-----------------------------------------------|-------:|
| automatic discovery of language models for text databases | jamie callan , margaret connell , aiqun du | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1791
rtable_id: 60
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 |
|:-----------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| aggregation algorithms for very large compressed data warehouses | jaideep srivastava , jianzhong li , doron rotem | vldb    |   1999 |

Entity B:
| title                                                           | authors                        | venue                                         |   year |
|:----------------------------------------------------------------|:-------------------------------|:----------------------------------------------|-------:|
| fast algorithms for universal quantification in large databases | goetz graefe , richard l. cole | acm transactions on database systems ( tods ) |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 701
rtable_id: 1571
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 |
|:------------------------------------|:------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | kenneth a. ross , anastassia ailamaki , alfred v. aho | sigmod record |   2002 |

Entity B:
| title                               | authors         | venue             |   year |
|:------------------------------------|:----------------|:------------------|-------:|
| reminiscences on influential papers | kenneth a. ross | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 726
rtable_id: 551
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 |
|:-------------------------------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| improved histograms for selectivity estimation of range predicates | eugene j. shekita , viswanath poosala , yannis e. ioannidis , peter j. haas | sigmod conference |   1996 |

Entity B:
| title                                             | authors                                       | venue                                          |   year |
|:--------------------------------------------------|:----------------------------------------------|:-----------------------------------------------|-------:|
| selectivity estimation using probabilistic models | lise getoor , benjamin taskar , daphne koller | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1808
rtable_id: 259
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 |
|:----------------------------------------------------|:----------------------------------|:--------|-------:|
| a survey of approaches to automatic schema matching | philip a. bernstein , erhard rahm | vldb j. |   2001 |

Entity B:
| title                                               | authors                           | venue                                                                  |   year |
|:----------------------------------------------------|:----------------------------------|:-----------------------------------------------------------------------|-------:|
| a survey of approaches to automatic schema matching | erhard rahm , philip a. bernstein | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 400
rtable_id: 2115
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 |
|:---------------------------------------------------------------------------------------|:-------------------------------|:--------|-------:|
| integrating a structured-text retrieval system with an object-oriented database system | jurgen annevelink , tak w. yan | vldb    |   1994 |

Entity B:
| title                                                                                  | authors                        | venue                 |   year |
|:---------------------------------------------------------------------------------------|:-------------------------------|:----------------------|-------:|
| integrating a structured-text retrieval system with an object-oriented database system | tak w. yan , jurgen annevelink | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1116
rtable_id: 2261
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 |
|:-----------------------------------------------------|:---------------------------------|:----------------------------|-------:|
| optimization of queries with user-defined predicates | kyuseok shim , surajit chaudhuri | acm trans . database syst . |   1999 |

Entity B:
| title                                       | authors                                               | venue                 |   year |
|:--------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| query optimization by predicate move-around | alon y. levy , inderpal singh mumick , yehoshua sagiv | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1089
rtable_id: 2201
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 |
|:-----------------------------------------------------------------------|:----------------------------------------------------------------|:------------------|-------:|
| dimensionality reduction for similarity searching in dynamic databases | ambuj k. singh , kothuri venkata ravi kanth , divyakant agrawal | sigmod conference |   1998 |

Entity B:
| title                                                                                                | authors                                                           | venue                 |   year |
|:-----------------------------------------------------------------------------------------------------|:------------------------------------------------------------------|:----------------------|-------:|
| fast similarity search in the presence of noise , scaling , and translation in time-series databases | rakesh agrawal , king-ip lin , harpreet s. sawhney , kyuseok shim | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 215
rtable_id: 1451
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 |
|:------------------------------------------------------------|:-----------------------------------------------------|:--------|-------:|
| materialized views selection in a multidimensional database | ernest teniente , elena baralis , stefano paraboschi | vldb    |   1997 |

Entity B:
| title                        | authors                                                                                                                                                        | venue                 |   year |
|:-----------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| materialized views in oracle | randall g. bello , karl dias , alan downing , james j. feenan , jr. , james l. finnerty , william d. norcott , harry sun , andrew witkowski , mohamed ziauddin | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 988
rtable_id: 771
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 lotus notes storage system | kenneth moore | sigmod conference |   1995 |

Entity B:
| title           | authors                | venue                                          |   year |
|:----------------|:-----------------------|:-----------------------------------------------|-------:|
| the naos system | c. collet , t. coupaye | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 246
rtable_id: 1535
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 |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------------|:--------------|-------:|
| dbglobe : a service-oriented p2p system for global computing | evaggelia pitoura , serge abiteboul , michalis vazirgiannis , dieter pfoser , george samaras | sigmod record |   2003 |

Entity B:
| title                                                        | authors                                                                                      | venue             |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------------|:------------------|-------:|
| dbglobe : a service-oriented p2p system for global computing | evaggelia pitoura , serge abiteboul , dieter pfoser , george samaras , michalis vazirgiannis | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 29
rtable_id: 2280
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 |
|:----------------------|:--------------------------------------------------------------------------|:------------------|-------:|
| approximate xml joins | h. v. jagadish , ting yu , divesh srivastava , sudipto guha , nick koudas | sigmod conference |   2002 |

Entity B:
| title                                         | authors                                            | venue                                          |   year |
|:----------------------------------------------|:---------------------------------------------------|:-----------------------------------------------|-------:|
| approximate join processing over data streams | abhinandan das , johannes gehrke , mirek riedewald | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2039
rtable_id: 2078
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 |
|:---------------------------------------------------------------------|:------------------------------|:--------|-------:|
| efficient testing of high performance transaction processing systems | d. wildfogel , ramana yerneni | vldb    |   1997 |

Entity B:
| title                                                            | authors                       | venue                                          |   year |
|:-----------------------------------------------------------------|:------------------------------|:-----------------------------------------------|-------:|
| secure transaction processing in firm real-time database systems | binto george , jayant haritsa | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 963
rtable_id: 1829
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 |
|:--------------------------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| multi-dimensional selectivity estimation using compressed histogram information | deok-hwan kim , ju-hong lee , chin-wan chung | sigmod conference |   1999 |

Entity B:
| title                                               | authors                                        | venue                                          |   year |
|:----------------------------------------------------|:-----------------------------------------------|:-----------------------------------------------|-------:|
| wavelet-based histograms for selectivity estimation | yossi matias , jeffrey scott vitter , min wang | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1670
rtable_id: 184
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 |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------|:------------------|-------:|
| answering complex sql queries using automatic summary tables | roberta cochrane , hamid pirahesh , monica urata , markos zaharioudakis , george lapis | sigmod conference |   2000 |

Entity B:
| title                                                        | authors                                                                                | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| answering complex sql queries using automatic summary tables | markos zaharioudakis , roberta cochrane , george lapis , hamid pirahesh , monica urata | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1284
rtable_id: 70
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 |
|:-------------------------------------------------------------|:-----------------------------------------------------------------------|:------------------|-------:|
| scientific data repositories : designing for a moving target | etzard stolte , thomas r. gross , gustavo alonso , christoph von praun | sigmod conference |   2003 |

Entity B:
| title                                                        | authors                                                             | venue                                          |   year |
|:-------------------------------------------------------------|:--------------------------------------------------------------------|:-----------------------------------------------|-------:|
| scientific data repositories : designing for a moving target | etzard stolte , christoph von praun , gustavo alonso , thomas gross | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1614
rtable_id: 2046
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 |
|:-----------------------------------------------------|:--------------------|:------------------|-------:|
| object-oriented extensions in sql3 : a status report | krishna g. kulkarni | sigmod conference |   1994 |

Entity B:
| title                     | authors                                                                             | venue             |   year |
|:--------------------------|:------------------------------------------------------------------------------------|:------------------|-------:|
| sql/med : a status report | jim melton , jan eike michels , vanja josifovski , krishna kulkarni , peter schwarz | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2053
rtable_id: 525
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 |
|:---------------------------------------------|:-----------------------------------------------|:----------------------------|-------:|
| querying atsql databases with temporal logic | jan chomicki , david toman , michael h. böhlen | acm trans . database syst . |   2001 |

Entity B:
| title                                        | authors                                               | venue                                         |   year |
|:---------------------------------------------|:------------------------------------------------------|:----------------------------------------------|-------:|
| querying atsql databases with temporal logic | jan chomicki , david toman , michael h. b &#246; hlen | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1164
rtable_id: 329
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 |
|:-----------------------------------------------------------|:---------------|:--------------|-------:|
| environment information systems - guest editor 's foreword | oliver günther | sigmod record |   1997 |

Entity B:
| title                                                                                     | authors                                                                                                                                                                                                                                                              | venue             |   year |
|:------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| the ecobase project : database and web technologies for environmental information systems | luc bouganim , maria claudia cavalcanti , fran &#231; oise fabret , maria luiza campos , fran &#231; ois llirbat , marta mattoso , rubens melo , ana maria moura , esther pacitti , fabio porto , margareth simoes , eric simon , asterio tanaka , patrick valduriez | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1977
rtable_id: 544
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 |
|:----------------------------------------|:-----------------|:------------------|-------:|
| open object database management systems | josé a. blakeley | sigmod conference |   1994 |

Entity B:
| title                                                      | authors                        | venue                                                                  |   year |
|:-----------------------------------------------------------|:-------------------------------|:-----------------------------------------------------------------------|-------:|
| data placement in shared-nothing parallel database systems | manish mehta , david j. dewitt | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 987
rtable_id: 1160
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 adaptable similarity query processing by using approximations | hans-peter kriegel , bernhard braunmüller , thomas seidl , mihael ankerst | vldb    |   1998 |

Entity B:
| title                                         | authors                                         | venue                                          |   year |
|:----------------------------------------------|:------------------------------------------------|:-----------------------------------------------|-------:|
| similarity query processing using disk arrays | apostolos n. papadopoulos , yannis manolopoulos | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2553
rtable_id: 1805
label: 0