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 |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| unisql/x unified relational and object-oriented database system | won kim   | sigmod conference |   1994 |

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: 2497
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 |
|:----------------------------------------------------------------|:----------|:--------|-------:|
| multiple-view self-maintenance in data warehousing environments | nam huyn  | vldb    |   1997 |

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: 1440
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 |
|:-----------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| anipqo : almost non-intrusive parametric query optimization for nonlinear cost functions | arvind hulgeri , s. sudarshan | vldb    |   2003 |

Entity B:
| title                                                           | authors       | venue                 |   year |
|:----------------------------------------------------------------|:--------------|:----------------------|-------:|
| design and analysis of parametric query optimization algorithms | sumit ganguly | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 1011
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 |
|:--------------------------------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| mdm : a multiple-data-model tool for the management of heterogeneous database schemes | paolo atzeni , riccardo torlone | sigmod conference |   1997 |

Entity B:
| title                                                                                 | authors                         | venue                                          |   year |
|:--------------------------------------------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| mdm : a multiple-data model tool for the management of heterogeneous database schemes | paolo atzeni , riccardo torlone | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1332
rtable_id: 1841
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 |
|:------------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| accessing a relational database through an object-oriented database interface | jack a. orenstein , d. n. kamber | vldb    |   1995 |

Entity B:
| title                                                                     | authors                                             | venue                                          |   year |
|:--------------------------------------------------------------------------|:----------------------------------------------------|:-----------------------------------------------|-------:|
| structures for manipulating proposed updates in object-oriented databases | michael doherty , richard hull , mohammed rupawalla | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1304
rtable_id: 1976
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 predicate-based caching scheme for client-server database architectures | julie basu , arthur m. keller | vldb j. |   1996 |

Entity B:
| title                                                                             | authors                                 | venue                                          |   year |
|:----------------------------------------------------------------------------------|:----------------------------------------|:-----------------------------------------------|-------:|
| highly concurrent cache consistency for indices in client-server database systems | markos zaharioudakis , michael j. carey | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2410
rtable_id: 1933
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 |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| 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: 0
original: ltable_id: 2429
rtable_id: 70
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 |
|:--------------------------------------------|:--------------------|:--------|-------:|
| an introduction to spatial database systems | ralf hartmut güting | vldb j. |   1994 |

Entity B:
| title                                                            | authors                        | venue                 |   year |
|:-----------------------------------------------------------------|:-------------------------------|:----------------------|-------:|
| managing intra-operator parallelism in parallel database systems | manish mehta , david j. dewitt | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1753
rtable_id: 1472
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 and critique of advanced transaction models | c. mohan  | sigmod conference |   1994 |

Entity B:
| title                                   | authors                                                                                   | venue                                          |   year |
|:----------------------------------------|:------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| a critique of ansi sql isolation levels | hal berenson , phil bernstein , jim gray , jim melton , elizabeth o'neil , patrick o'neil | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1820
rtable_id: 1593
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 |
|:--------------------------------|:---------------------------------------------------------------------------------|:------------------|-------:|
| exchanging intensional xml data | omar benjelloun , tova milo , serge abiteboul , frederic dang ngoc , bernd amann | sigmod conference |   2003 |

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: 1783
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 |
|:---------------------------------------------------|:------------------------------------------|:--------|-------:|
| efficient mining of xml query patterns for caching | liang huai yang , mong-li lee , wynne hsu | vldb    |   2003 |

Entity B:
| title                                           | authors                  | venue                                          |   year |
|:------------------------------------------------|:-------------------------|:-----------------------------------------------|-------:|
| efficiently mining long patterns from databases | roberto j. bayardo , jr. | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 879
rtable_id: 1784
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 |
|:---------------------------------------------------|:-------------------------------------|:--------|-------:|
| transaction timestamping in ( temporal ) databases | christian s. jensen , david b. lomet | vldb    |   2001 |

Entity B:
| title                                                           | authors                                                     | venue             |   year |
|:----------------------------------------------------------------|:------------------------------------------------------------|:------------------|-------:|
| report on the 1995 international workshop on temporal databases | arie segev , christian s. jensen , richard thomas snodgrass | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2069
rtable_id: 1601
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 |
|:------------------------------------------|:----------------------------------------------------------------------------|:----------------------------|-------:|
| space optimization in deductive databases | s. sudarshan , divesh srivastava , raghu ramakrishnan , jeffrey f. naughton | acm trans . database syst . |   1995 |

Entity B:
| title                       | authors                                                 | venue                                          |   year |
|:----------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| xsb as a deductive database | konstantinos sagonas , terrance swift , david s. warren | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 94
rtable_id: 1676
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 |
|:---------------------------------------------------------------------|:---------------------------------------------------------------------------|:--------|-------:|
| databases and workflow management : what is it all about ? ( panel ) | jim gray , betty salzberg , stefano ceri , andreas reuter , gerhard weikum | vldb    |   1995 |

Entity B:
| title                                                                | authors                                                                    | venue                 |   year |
|:---------------------------------------------------------------------|:---------------------------------------------------------------------------|:----------------------|-------:|
| databases and workflow management : what is it all about ? ( panel ) | andreas reuter , stefano ceri , jim gray , betty salzberg , gerhard weikum | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2256
rtable_id: 1115
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 |
|:--------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| managing intervals efficiently in object-relational databases | thomas seidl , marco pötke , hans-peter kriegel | vldb    |   2000 |

Entity B:
| title                                                                                                      | authors                                                  | venue                 |   year |
|:-----------------------------------------------------------------------------------------------------------|:---------------------------------------------------------|:----------------------|-------:|
| evaluating functional joins along nested reference sets in object-relational and object-oriented databases | reinhard braumandl , jens clau &#223; en , alfons kemper | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1646
rtable_id: 777
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 unnesting in object-oriented databases | leonidas fegaras | sigmod conference |   1998 |

Entity B:
| title                                         | authors         | venue                 |   year |
|:----------------------------------------------|:----------------|:----------------------|-------:|
| query processing in tertiary memory databases | sunita sarawagi | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2232
rtable_id: 1455
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 |
|:------------------------------------------------------|:-----------------------------------------------------------------------------|:--------|-------:|
| r-tree based indexing of now-relative bitemporal data | simonas saltenis , christian s. jensen , giedrius slivinskas , rasa bliujute | vldb    |   1998 |

Entity B:
| title                                           | authors                                      | venue                                                                  |   year |
|:------------------------------------------------|:---------------------------------------------|:-----------------------------------------------------------------------|-------:|
| indexing of now-relative spatio-bitemporal data | simonas &#352; altenis , christian s. jensen | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 844
rtable_id: 1199
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 implementation and performance of compressed databases | till westmann , sven helmer , guido moerkotte , donald kossmann | sigmod record |   2000 |

Entity B:
| title                                                      | authors                                                         | venue             |   year |
|:-----------------------------------------------------------|:----------------------------------------------------------------|:------------------|-------:|
| the implementation and performance of compressed databases | till westmann , donald kossmann , sven helmer , guido moerkotte | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1644
rtable_id: 459
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 |
|:------------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| accessing a relational database through an object-oriented database interface | jack a. orenstein , d. n. kamber | vldb    |   1995 |

Entity B:
| title                                                               | authors                                                                                                   | venue                                          |   year |
|:--------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| storing and querying ordered xml using a relational database system | igor tatarinov , stratis d. viglas , kevin beyer , jayavel shanmugasundaram , eugene shekita , chun zhang | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1304
rtable_id: 689
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 maintenance of materialized mediated views | james j. lu , guido moerkotte , joachim schü , v. s. subrahmanian | sigmod conference |   1995 |

Entity B:
| title                                            | authors                         | venue                                          |   year |
|:-------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| incremental maintenance of views with duplicates | timothy griffin , leonid libkin | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2261
rtable_id: 1506
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 issues in parallel query optimization | waqar hasan , patrick valduriez , daniela florescu | sigmod record |   1996 |

Entity B:
| title                                                                   | authors                                      | venue                                          |   year |
|:------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| exploiting constraint-like data characterizations in query optimization | parke godfrey , jarek gryz , calisto zuzarte | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 592
rtable_id: 276
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 |
|:-----------------------|:---------------|:------------------|-------:|
| databases for networks | h. v. jagadish | sigmod conference |   1994 |

Entity B:
| title             | authors                                | venue             |   year |
|:------------------|:---------------------------------------|:------------------|-------:|
| databases for gis | claudia bauzer medeiros , fatima pires | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1989
rtable_id: 1707
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 |
|:----------------------------------------------|:---------------------------------------------|:------------------|-------:|
| similarity query processing using disk arrays | apostolos papadopoulos , yannis manolopoulos | sigmod conference |   1998 |

Entity B:
| title                                       | authors                                                                 | venue                                                                  |   year |
|:--------------------------------------------|:------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| approximate query processing using wavelets | kaushik chakrabarti , minos garofalakis , rajeev rastogi , kyuseok shim | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2367
rtable_id: 2104
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 |
|:--------------------------------------------------------------|:-------------------------------------------|:--------------|-------:|
| relational data sharing in peer-based data management systems | beng chin ooi , yanfeng shu , kian-lee tan | sigmod record |   2003 |

Entity B:
| title                                                         | authors                                    | venue             |   year |
|:--------------------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| relational data sharing in peer-based data management systems | beng chin ooi , yanfeng shu , kian-lee tan | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2402
rtable_id: 2240
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 |
|:-----------------------------------------------------|:------------------|:------------------|-------:|
| improving the efficiency of database-system teaching | jeffrey d. ullman | sigmod conference |   2003 |

Entity B:
| title                                                | authors           | venue                                          |   year |
|:-----------------------------------------------------|:------------------|:-----------------------------------------------|-------:|
| improving the efficiency of database-system teaching | jeffrey d. ullman | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 528
rtable_id: 2074
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 |
|:------------------------------------------|:--------------|:--------------|-------:|
| database principles column - introduction | leonid libkin | sigmod record |   1999 |

Entity B:
| title               | authors       | venue             |   year |
|:--------------------|:--------------|:------------------|-------:|
| database principles | leonid libkin | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2144
rtable_id: 530
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 |
|:---------------------------------------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| workshop report : the first international workshop on active and real-time database systems ( artdb-95 ) | mikael berndtsson , jörgen hansson | sigmod record |   1996 |

Entity B:
| title                                                  | authors                                                                                  | venue             |   year |
|:-------------------------------------------------------|:-----------------------------------------------------------------------------------------|:------------------|-------:|
| integrating temporal , real-time , an active databases | krithi ramamritham , raju sivasankaran , john a. stankovic , don t. towsley , ming xiong | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1103
rtable_id: 373
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 similarity search and classification via rank aggregation | ravi kumar , d. sivakumar , ronald fagin | sigmod conference |   2003 |

Entity B:
| title                                                               | authors                                  | venue                                          |   year |
|:--------------------------------------------------------------------|:-----------------------------------------|:-----------------------------------------------|-------:|
| efficient similarity search and classification via rank aggregation | ronald fagin , ravi kumar , d. sivakumar | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 257
rtable_id: 2034
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 |
|:---------------------------------------------------------------|:------------------------------------------------------------|:--------|-------:|
| capturing and querying multiple aspects of semistructured data | curtis e. dyreson , michael h. böhlen , christian s. jensen | vldb    |   1999 |

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: 856
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 |
|:------------------------------------|:--------------------------------|:--------------|-------:|
| real-time index concurrency control | s. seshadri , jayant r. haritsa | sigmod record |   1996 |

Entity B:
| title                                                        | authors                                                         | venue                 |   year |
|:-------------------------------------------------------------|:----------------------------------------------------------------|:----------------------|-------:|
| index concurrency control in firm real-time database systems | brajesh goyal , jayant r. haritsa , s. seshadri , v. srinivasan | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1366
rtable_id: 1459
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 |
|:-------------------------------------|:-----------------------------------------------------------------------------------------|:--------|-------:|
| scalable sweeping-based spatial join | lars arge , jeffrey scott vitter , torsten suel , sridhar ramaswamy , octavian procopiuc | vldb    |   1998 |

Entity B:
| title                  | authors                      | venue                                         |   year |
|:-----------------------|:-----------------------------|:----------------------------------------------|-------:|
| iterative spatial join | edwin h. jacox , hanan samet | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1509
rtable_id: 2246
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 |
|:-------------------------------------------------------|:------------------------------------------------------|:----------------------------|-------:|
| fast incremental maintenance of approximate histograms | viswanath poosala , phillip b. gibbons , yossi matias | acm trans . database syst . |   2002 |

Entity B:
| title                                                          | authors                   | venue                                                                  |   year |
|:---------------------------------------------------------------|:--------------------------|:-----------------------------------------------------------------------|-------:|
| incremental computation and maintenance of temporal aggregates | jun yang , jennifer widom | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2451
rtable_id: 2182
label: 0