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 |
|:--------------------------------------------------|:----------------------------------|:--------|-------:|
| temporal integrity constraints with indeterminacy | wes cowley , dimitris plexousakis | vldb    |   2000 |

Entity B:
| title                                                        | authors                                | venue                 |   year |
|:-------------------------------------------------------------|:---------------------------------------|:----------------------|-------:|
| the role of integrity constraints in database interoperation | mark w. w. vermeer , peter m. g. apers | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 417
rtable_id: 1055
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 |
|:------------------------------------------------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| a comparison of selectivity estimators for range queries on metric attributes | bj &#246; rn blohsfeld , dieter korus , bernhard seeger | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1808
rtable_id: 206
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 |
|:----------------------------------------------------------------|:-------------------------------------------------------|:------------------|-------:|
| ominisearch : a method for searching dynamic content on the web | henrique paques , ling liu , david buttler , calton pu | sigmod conference |   2001 |

Entity B:
| title                                                           | authors                                                                     | venue                                          |   year |
|:----------------------------------------------------------------|:----------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| ominisearch : a method for searching dynamic content on the web | david buttler , ling liu , calton pu , henrique paques , wei han , wei tang | international conference on management of data |   2001 |



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

Entity B:
| title                                        | authors                              | venue                 |   year |
|:---------------------------------------------|:-------------------------------------|:----------------------|-------:|
| a foundation for multi-dimensional databases | marc gyssens , laks v. s. lakshmanan | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 988
rtable_id: 1026
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 |
|:------------------------------------------------------------------------|:------------|:--------------|-------:|
| mapping extended entity relationship model to object modeling technique | joseph fong | sigmod record |   1995 |

Entity B:
| title                                                             | authors                                | venue             |   year |
|:------------------------------------------------------------------|:---------------------------------------|:------------------|-------:|
| an extended entity-relationship model for geographic applications | thanasis hadzilacos , nectaria tryfona | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1179
rtable_id: 1861
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 |
|:-------------------------------|:--------------|:--------------|-------:|
| describing semistructured data | luca cardelli | sigmod record |   2001 |

Entity B:
| title                                                          | authors                                                            | venue                 |   year |
|:---------------------------------------------------------------|:-------------------------------------------------------------------|:----------------------|-------:|
| capturing and querying multiple aspects of semistructured data | curtis e. dyreson , michael h. b &#246; hlen , christian s. jensen | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1310
rtable_id: 855
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 |
|:-------------------------------------|:------------------------------------|:--------------|-------:|
| distributed transactions in practice | lyman do , pamela drew , prabhu ram | sigmod record |   1999 |

Entity B:
| title                 | authors                       | venue             |   year |
|:----------------------|:------------------------------|:------------------|-------:|
| standards in practice | andrew eisenberg , jim melton | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 891
rtable_id: 231
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 |
|:----------------------------------------------------------------|:-------------------------------------|:------------------|-------:|
| rate-based query optimization for streaming information sources | jeffrey f. naughton , stratis viglas | sigmod conference |   2002 |

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: 727
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 |
|:---------------------------------------------------------------------------------|:--------------------------------------------------------------|:--------|-------:|
| schemasql - a language for interoperability in relational multi-database systems | fereidoon sadri , laks v. s. lakshmanan , iyer n. subramanian | vldb    |   1996 |

Entity B:
| title                                                              | authors                                                        | venue                                         |   year |
|:-------------------------------------------------------------------|:---------------------------------------------------------------|:----------------------------------------------|-------:|
| schemasql : an extension to sql for multidatabase interoperability | laks v. s. lakshmanan , fereidoon sadri , subbu n. subramanian | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 766
rtable_id: 337
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 |
|:-----------------------------------------------------|:------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| high-performance sorting on networks of workstations | david e. culler , joseph m. hellerstein , david a. patterson , andrea c. arpaci-dusseau , remzi h. arpaci-dusseau | sigmod conference |   1997 |

Entity B:
| title                                | authors          | venue                 |   year |
|:-------------------------------------|:-----------------|:----------------------|-------:|
| high-performance extensible indexing | marcel kornacker | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 780
rtable_id: 792
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 |
|:----------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| approximate join processing over data streams | johannes gehrke , abhinandan das , mirek riedewald | sigmod conference |   2003 |

Entity B:
| title                                       | authors                                                                    | venue                 |   year |
|:--------------------------------------------|:---------------------------------------------------------------------------|:----------------------|-------:|
| approximate query processing using wavelets | kaushik chakrabarti , minos n. garofalakis , rajeev rastogi , kyuseok shim | very large data bases |   2000 |



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

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

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

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

Entity B:
| title                       | authors        | venue                                          |   year |
|:----------------------------|:---------------|:-----------------------------------------------|-------:|
| databases and visualization | daniel a. keim | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1545
rtable_id: 249
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 |
|:--------------------------------------------------------------|:----------------------------------------------------------------------|:--------------|-------:|
| semantic web workshop : models , architectures and management | vassilis christophides , dimitris plexousakis , panos constantopoulos | sigmod record |   2001 |

Entity B:
| title                                               | authors                      | venue             |   year |
|:----------------------------------------------------|:-----------------------------|:------------------|-------:|
| special section on semantic web and data management | robert meersman , amit sheth | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1494
rtable_id: 608
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 |
|:----------------------------------------|:------------------------------------|:--------|-------:|
| guest editorial : databases and the web | alberto o. mendelzon , paolo atzeni | vldb j. |   2000 |

Entity B:
| title                                                                         | authors                      | venue                                          |   year |
|:------------------------------------------------------------------------------|:-----------------------------|:-----------------------------------------------|-------:|
| wsq/dsq : a practical approach for combined querying of databases and the web | roy goldman , jennifer widom | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1397
rtable_id: 425
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 algorithms for minimizing tree pattern queries | prakash ramanan | sigmod conference |   2002 |

Entity B:
| title                           | authors                                                      | venue                                                                  |   year |
|:--------------------------------|:-------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| tree pattern query minimization | s. amer-yahia , s. cho , l. v. s. lakshmanan , d. srivastava | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 944
rtable_id: 1234
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 previews for networked information systems : a case study with nasa environmental data | khoa doan , catherine plaisant , ben shneiderman , tom bruns | sigmod record |   1997 |

Entity B:
| title                                                                          | authors                                 | venue             |   year |
|:-------------------------------------------------------------------------------|:----------------------------------------|:------------------|-------:|
| integrating modelling systems for environmental management information systems | david j. abel , kerry taylor , dean kun | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2293
rtable_id: 1906
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 |
|:---------------------------------------------------------------------|:----------------------------------------------|:--------------|-------:|
| report on first international workshop on real-time database systems | sang hyuk son , kwei-jay lin , azer bestavros | sigmod record |   1996 |

Entity B:
| title                                                                                                            | authors      | venue             |   year |
|:-----------------------------------------------------------------------------------------------------------------|:-------------|:------------------|-------:|
| report on ngits ' 99 : the fourth international workshop on next generation information technologies and systems | opher etzion | acm sigmod record |   1999 |



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

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

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

Entity A:
| title                                             | authors                             | venue   |   year |
|:--------------------------------------------------|:------------------------------------|:--------|-------:|
| temporal slicing in the evaluation of xml queries | richard t. snodgrass , dengfeng gao | vldb    |   2003 |

Entity B:
| title                                     | authors                                               | venue                                          |   year |
|:------------------------------------------|:------------------------------------------------------|:-----------------------------------------------|-------:|
| parallel evaluation of multi-join queries | annita n. wilschut , jan flokstra , peter m. g. apers | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1595
rtable_id: 1587
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 |
|:-------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| timber : a native xml database | andrew nierman , cong yu , jignesh m. patel , adriane chapman , nuwee wiwatwattana , h. v. jagadish , yuqing wu , laks v. s. lakshmanan , divesh srivastava , shurug al-khalifa , stelios paparizos | vldb j. |   2002 |

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: 1362
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 |
|:------------------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| mind your vocabulary : query mapping across heterogeneous information sources | kevin chen-chuan chang , hector garcia-molina | sigmod conference |   1999 |

Entity B:
| title                                               | authors                                              | venue                 |   year |
|:----------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| answering xml queries on heterogeneous data sources | ioana manolescu , daniela florescu , donald kossmann | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2450
rtable_id: 1353
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 |
|:-------------------------------------------------------|:-----------------------------|:--------|-------:|
| towards an odmg-compliant visual object query language | manoj chavda , peter t. wood | vldb    |   1997 |

Entity B:
| title                                                    | authors                        | venue                                          |   year |
|:---------------------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| towards an effective calculus for object query languages | leonidas fegaras , david maier | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2376
rtable_id: 1597
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 |
|:-------------------------------------------------------------|:------------------------------------|:--------------|-------:|
| webdb ' 98 : international workshop on the web and databases | alberto o. mendelzon , paolo atzeni | sigmod record |   1998 |

Entity B:
| title                                                                                                  | authors                                                             | venue             |   year |
|:-------------------------------------------------------------------------------------------------------|:--------------------------------------------------------------------|:------------------|-------:|
| report on the 5th international workshop on the design and management of data warehouses ( dmdw ' 03 ) | hans j. lenz , panos vassiliadis , manfred jeusfeld , martin staudt | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2395
rtable_id: 2210
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 |
|:------------------------------------------------------------------|:---------------------------------|:------------------|-------:|
| finding generalized projected clusters in high dimensional spaces | charu c. aggarwal , philip s. yu | sigmod conference |   2000 |

Entity B:
| title                                                             | authors               | venue                                         |   year |
|:------------------------------------------------------------------|:----------------------|:----------------------------------------------|-------:|
| a cost model for query processing in high dimensional data spaces | christian b &#246; hm | acm transactions on database systems ( tods ) |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2259
rtable_id: 510
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 | richard t. snodgrass | sigmod record |   1998 |

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: 934
rtable_id: 547
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 |
|:---------------------------------------------------------|:-----------------------------------------------------|:--------------|-------:|
| using unknowns to prevent discovery of association rules | chris clifton , yücel saygin , vassilios s. verykios | sigmod record |   2001 |

Entity B:
| title                                                              | authors                  | venue                 |   year |
|:-------------------------------------------------------------------|:-------------------------|:----------------------|-------:|
| discovery of multiple-level association rules from large databases | jiawei han , yongjian fu | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1881
rtable_id: 1443
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 |
|:--------------------|:--------------|:------------------|-------:|
| database principles | leonid libkin | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1989
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 |
|:----------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| algebraic query optimisation for database programming languages | carol small , alexandra poulovassilis | vldb j. |   1996 |

Entity B:
| title                                                              | authors                                                      | venue                                          |   year |
|:-------------------------------------------------------------------|:-------------------------------------------------------------|:-----------------------------------------------|-------:|
| a query language and optimization techniques for unstructured data | peter buneman , susan davidson , gerd hillebrand , dan suciu | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 76
rtable_id: 1992
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 |
|:--------------------------------------------------------------------------------------------------------------|:-------------|:--------------|-------:|
| report on ngits ' 99 : the 4th international workshop on next generation information technologies and systems | opher etzion | sigmod record |   1999 |

Entity B:
| title                                                                                 | authors                           | venue             |   year |
|:--------------------------------------------------------------------------------------|:----------------------------------|:------------------|-------:|
| report on the first international workshop on efficient web-based information systems | zo &#233; lacroix , omar boucelma | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2359
rtable_id: 913
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 |
|:---------------------------------------------|:--------------|:--------|-------:|
| management of multidimensional discrete data | peter baumann | vldb j. |   1994 |

Entity B:
| title                                                     | authors        | venue             |   year |
|:----------------------------------------------------------|:---------------|:------------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 449
rtable_id: 1884
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 |
|:-------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| index nesting - an efficient approach to indexing in object-oriented databases | jiawei han , beng chin ooi , hongjun lu , kian-lee tan | vldb j. |   1996 |

Entity B:
| title                                           | authors                        | venue                 |   year |
|:------------------------------------------------|:-------------------------------|:----------------------|-------:|
| efficient index structures for string databases | tamer kahveci , ambuj k. singh | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1118
rtable_id: 1408
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 |
|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------|:------------------|-------:|
| xmas : an extensible main-memory storage system for high-performance applications | ki hong kim , yong sik kwon , sang kyun cha , jang ho park , byoung dae park , sangho lee | sigmod conference |   1998 |

Entity B:
| title                                                                                  | authors                                                     | venue                                          |   year |
|:---------------------------------------------------------------------------------------|:------------------------------------------------------------|:-----------------------------------------------|-------:|
| datablitz storage manager : main-memory database performance for critical applications | j. baulier , p. bohannon , s. gogate , c. gupta , s. haldar | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1445
rtable_id: 46
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 |
|:----------------------------------------------------------------|:-------------------------------------------------------------------------|:------------------|-------:|
| multimediaminer : a system prototype for multimedia data mining | jenny chiang , ze-nian li , osmar r. zaïane , sonny h. chee , jiawei han | sigmod conference |   1998 |

Entity B:
| title                                                                | authors   | venue                 |   year |
|:---------------------------------------------------------------------|:----------|:----------------------|-------:|
| mineset ( tm ) : a system for high-end data mining and visualization |           | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 384
rtable_id: 1146
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 |
|:-----------------------------------------------------------------------------------------|:-------------------------|:--------|-------:|
| join index hierarchies for supporting efficient navigations in object-oriented databases | jiawei han , zhaohui xie | vldb    |   1994 |

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: 2540
rtable_id: 1976
label: 0