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 |
|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | daniel j. rosenkrantz , nick koudas , dan suciu , peter scheuermann , rajeev rastogi , jiawei han , kenneth a. ross | sigmod record |   2001 |

Entity B:
| title              | authors   | venue             |   year |
|:-------------------|:----------|:------------------|-------:|
| influential papers | ken ross  | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 359
rtable_id: 924
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 |
|:-----------------------------------------------|:---------------------------------------------------------------------------|:------------------|-------:|
| cache-and-query for wide area sensor databases | phillip b. gibbons , srinivasan seshan , suman kumar nath , amol deshpande | sigmod conference |   2003 |

Entity B:
| title                                          | authors                                                              | venue                                          |   year |
|:-----------------------------------------------|:---------------------------------------------------------------------|:-----------------------------------------------|-------:|
| cache-and-query for wide area sensor databases | amol deshpande , suman nath , phillip b. gibbons , srinivasan seshan | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 68
rtable_id: 2048
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 |
|:---------------|:---------------------|:--------------|-------:|
| tods reviewers | richard t. snodgrass | sigmod record |   2003 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2508
rtable_id: 2124
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 |
|:--------------------------------------------------------------------------------|:--------------------------------------------------|:--------|-------:|
| data model for extensible support of explicit relationships in design databases | joan peckham , bonnie mackellar , michael doherty | vldb j. |   1995 |

Entity B:
| title                                                                           | authors                                           | venue                                                                  |   year |
|:--------------------------------------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| data model for extensible support of explicit relationships in design databases | joan peckham , bonnie mackellar , michael doherty | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2537
rtable_id: 625
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 |
|:------------------------------------------------|:----------------------------------------------------------------------------------------------|:--------|-------:|
| vxmlr : a visual xml-relational database system | aoying zhou , wenyun ji , shihui zheng , hongjun lu , yuqi liang , zengping tian , long zhang | vldb    |   2001 |

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: 1738
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 |
|:-----------------------------------------------------------------|:------------------------------------------------------|:--------|-------:|
| implementing lazy database updates for an object database system | fabrizio ferrandina , thorsten meyer , roberto zicari | vldb    |   1994 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1685
rtable_id: 2261
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 |
|:--------------------------------------------|:-------------------------------------------------------|:------------------|-------:|
| selectivity estimation in spatial databases | viswanath poosala , sridhar ramaswamy , swarup acharya | sigmod conference |   1999 |

Entity B:
| title                                     | authors     | venue                                                                  |   year |
|:------------------------------------------|:------------|:-----------------------------------------------------------------------|-------:|
| special issue on spatial database systems | h. j. schek | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2369
rtable_id: 588
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 editor 's introduction | asuman dogac | sigmod record |   1998 |

Entity B:
| title                        | authors     | venue             |   year |
|:-----------------------------|:------------|:------------------|-------:|
| guest editor 's introduction | karl aberer | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1705
rtable_id: 2234
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 |
|:------------------------------------------|:------------------------------------------------------|:--------------|-------:|
| infering structure in semistructured data | rajeev motwani , serge abiteboul , svetlozar nestorov | sigmod record |   1997 |

Entity B:
| title                                          | authors                                      | venue                                          |   year |
|:-----------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| meaningful change detection in structured data | sudarshan s. chawathe , hector garcia-molina | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 778
rtable_id: 1935
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 |
|:-------------------|:------------------------------------------------------|:------------------|-------:|
| online aggregation | helen j. wang , peter j. haas , joseph m. hellerstein | sigmod conference |   1997 |

Entity B:
| title                                  | authors                                 | venue                 |   year |
|:---------------------------------------|:----------------------------------------|:----------------------|-------:|
| eager aggregation and lazy aggregation | weipeng p. yan , per - &#197; ke larson | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 168
rtable_id: 1466
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 |
|:-----------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| agflow : agent-based cross-enterprise workflow management system | boualem benatallah , anne h. h. ngu , phuong nguyen , liangzhao zeng | vldb    |   2001 |

Entity B:
| title                                          | authors                                                                                     | venue                                                                  |   year |
|:-----------------------------------------------|:--------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| anatomy of a native xml base management system | t. fiebig , s. helmer , c.-c . kanne , g. moerkotte , j. neumann , r. schiele , t. westmann | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 398
rtable_id: 1233
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 |
|:--------------------------------------------|:---------------------------------------------------------------|:--------|-------:|
| hypothetical queries in an olap environment | thanos papadimitriou , andrey balmin , yannis papakonstantinou | vldb    |   2000 |

Entity B:
| title                                             | authors                        | venue                                          |   year |
|:--------------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| a framework for implementing hypothetical queries | timothy griffin , richard hull | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2342
rtable_id: 1808
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 |
|:----------------------|:------------------------------------------------------------------|:--------|-------:|
| hippocratic databases | yirong xu , jerry kiernan , rakesh agrawal , ramakrishnan srikant | vldb    |   2002 |

Entity B:
| title              | authors              | venue                                          |   year |
|:-------------------|:---------------------|:-----------------------------------------------|-------:|
| petabyte databases | dirk d &#252; llmann | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1271
rtable_id: 38
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 |
|:---------------------------------------------------------|:----------------|:-----------------------------------------------|-------:|
| efficient algorithms for minimizing tree pattern queries | prakash ramanan | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 879
rtable_id: 680
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 formal methods to reason about semantics-based decompositions of transactions | paul ammann , indrakshi ray , sushil jajodia | vldb    |   1995 |

Entity B:
| title                                                                               | authors                                      | venue                 |   year |
|:------------------------------------------------------------------------------------|:---------------------------------------------|:----------------------|-------:|
| using formal methods to reason about semantics-based decompositions of transactions | paul ammann , sushil jajodia , indrakshi ray | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1757
rtable_id: 1476
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 |
|:-----------------------------------------------------------------------------|:-----------------------------------------|:----------------------------------------------|-------:|
| an efficient method for checking object-oriented database schema correctness | a. formica , h. d. groger , m. missikoff | acm transactions on database systems ( tods ) |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1304
rtable_id: 218
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 |
|:--------------------------------------------------------|:------------------------------------------|:----------------------------|-------:|
| cost models for overlapping and multiversion structures | yufei tao , jun zhang , dimitris papadias | acm trans . database syst . |   2002 |

Entity B:
| title                                                   | authors                                   | venue                                         |   year |
|:--------------------------------------------------------|:------------------------------------------|:----------------------------------------------|-------:|
| cost models for overlapping and multiversion structures | yufei tao , dimitris papadias , jun zhang | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1249
rtable_id: 538
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 |
|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| surfing wavelets on streams : one-pass summaries for approximate aggregate queries | anna c. gilbert , martin strauss , yannis kotidis , s. muthukrishnan | vldb    |   2001 |

Entity B:
| title                                                            | authors                                                                            | venue                 |   year |
|:-----------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------|-------:|
| approximating aggregate queries about web pages via random walks | ziv bar-yossef , alexander berg , steve chien , jittat fakcharoenphol , dror weitz | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1512
rtable_id: 1373
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 sr-tree : an index structure for high-dimensional nearest neighbor queries | norio katayama , shin ` ichi satoh | sigmod conference |   1997 |

Entity B:
| title                                                                  | authors                                              | venue                                          |   year |
|:-----------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| vist : a dynamic index method for querying xml data by tree structures | haixun wang , sanghyun park , wei fan , philip s. yu | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1514
rtable_id: 2085
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 |
|:---------------------------------------|:------------------------------------------------------------------------------|:------------------|-------:|
| strudel : a web-site management system | alon y. levy , mary f. fernandez , jaewoo kang , daniela florescu , dan suciu | sigmod conference |   1997 |

Entity B:
| title                                       | authors                                     | venue                 |   year |
|:--------------------------------------------|:--------------------------------------------|:----------------------|-------:|
| is web-site management a database problem ? | daniela florescu , alon y. levy , dan suciu | very large data bases |   1998 |



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

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

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

Entity A:
| title                                                                                            | authors                                                              | venue   |   year |
|:-------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| learning response time for websources using query feedback and application in query optimization | jean-robert gruser , vladimir zadorozhny , louiqa raschid , tao zhan | vldb j. |   2000 |

Entity B:
| title                                           | authors       | venue                                          |   year |
|:------------------------------------------------|:--------------|:-----------------------------------------------|-------:|
| query optimization for selections using bitmaps | ming-chuan wu | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 682
rtable_id: 207
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 |
|:----------------------------------------------|:--------------------------------------------------|:--------|-------:|
| database technologies for electronic commerce | yirong xu , ramakrishnan srikant , rakesh agrawal | vldb    |   2002 |

Entity B:
| title                          | authors                      | venue                                          |   year |
|:-------------------------------|:-----------------------------|:-----------------------------------------------|-------:|
| electronic commerce : tutorial | nabil r. adam , yelena yesha | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1074
rtable_id: 178
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 |
|:----------------------------|:--------------------------------------------------------------|:------------------|-------:|
| xsb as a deductive database | terrance swift , konstantinos f. sagonas , david scott warren | sigmod conference |   1994 |

Entity B:
| title                                             | authors         | venue                                         |   year |
|:--------------------------------------------------|:----------------|:----------------------------------------------|-------:|
| tail recursion elimination in deductive databases | kenneth a. ross | acm transactions on database systems ( tods ) |   1996 |



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

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

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

Entity A:
| title                                   | authors          | venue             |   year |
|:----------------------------------------|:-----------------|:------------------|-------:|
| open object database management systems | josé a. blakeley | sigmod conference |   1994 |

Entity B:
| title                                                       | authors                                                                                               | venue                                                                  |   year |
|:------------------------------------------------------------|:------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| tigukat : a uniform behavioral objectbase management system | m. tamer &#214; zsu , randal peters , duane szafron , boman irani , anna lipka , adriana mu &#241; oz | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 987
rtable_id: 639
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 rewriting for semistructured data | vasilis vassalos , yannis papakonstantinou | sigmod conference |   1999 |

Entity B:
| title                                                       | authors                                                                      | venue             |   year |
|:------------------------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| lore : a database management system for semistructured data | jason mchugh , serge abiteboul , roy goldman , dallas quass , jennifer widom | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 932
rtable_id: 1758
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 |
|:---------------------------------------------------------|:----------------------------------------------------------------------|:------------------|-------:|
| optimizing disjunctive queries with expensive predicates | alfons kemper , guido moerkotte , michael steinbrunn , klaus peithner | sigmod conference |   1994 |

Entity B:
| title                       | authors                        | venue                                          |   year |
|:----------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| optimizing queries on files | mariano p. consens , tova milo | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1395
rtable_id: 1637
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 |
|:----------------------------------------------------------------------------------------------------|:-------------------------------------------|:--------|-------:|
| calibrating the query optimizer cost model of iro-db , an object-oriented federated database system | zhao-hui tang , fei sha , georges gardarin | vldb    |   1996 |

Entity B:
| title                                                          | authors                       | venue             |   year |
|:---------------------------------------------------------------|:------------------------------|:------------------|-------:|
| the trigs active object-oriented database system - an overview | g. kappel , w. retschitzegger | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 892
rtable_id: 225
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 |
|:----------------------------------|:-------------------------------|:--------|-------:|
| watermarking relational databases | rakesh agrawal , jerry kiernan | vldb    |   2002 |

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: 1771
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 |
|:-------------------------------------------------|:--------------|:--------|-------:|
| index configuration in object-oriented databases | elisa bertino | vldb j. |   1994 |

Entity B:
| title                                                                                  | authors                       | venue                 |   year |
|:---------------------------------------------------------------------------------------|:------------------------------|:----------------------|-------:|
| integrating heterogenous overlapping databases through object-oriented transformations | vanja josifovski , tore risch | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 644
rtable_id: 848
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 |
|:----------------------------------------------------------------------|:-------------------------------------|:--------|-------:|
| heterogeneous database query optimization in db2 universal datajoiner | shivakumar venkataraman , tian zhang | vldb    |   1998 |

Entity B:
| title                                                                 | authors                     | venue                 |   year |
|:----------------------------------------------------------------------|:----------------------------|:----------------------|-------:|
| semantic integration in heterogeneous databases using neural networks | wen-syan li , chris clifton | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 252
rtable_id: 2227
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 database system implementations | michael h. böhlen | sigmod record |   1995 |

Entity B:
| title                          | authors                                | venue                                          |   year |
|:-------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| the ecrc multi database system | willem jonker , heribert sch &#252; tz | international conference on management of data |   1995 |



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

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

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

Entity A:
| title              | authors     | venue         |   year |
|:-------------------|:------------|:--------------|-------:|
| book review column | karl aberer | sigmod record |   2002 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 386
rtable_id: 598
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 effective hash based algorithm for mining association rules | ming-syan chen , philip s. yu , jong soo park | sigmod conference |   1995 |

Entity B:
| title                                                        | authors                                                                    | venue                                         |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------|:----------------------------------------------|-------:|
| data mining with optimized two-dimensional association rules | takeshi fukuda , yasuhiko morimoto , shimichi morishita , takeshi tokuyama | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 818
rtable_id: 328
label: 0