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 |
|:-----------------------------------------------------|:---------------------------------|:----------------------------|-------:|
| optimization of queries with user-defined predicates | kyuseok shim , surajit chaudhuri | acm trans . database syst . |   1999 |

Entity B:
| title                                                                                               | authors                                                                | venue                 |   year |
|:----------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|:----------------------|-------:|
| optimizing queries with universal quantification in object-oriented and object-relational databases | jens clau &#223; en , alfons kemper , guido moerkotte , klaus peithner | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1089
rtable_id: 1035
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 |
|:-----------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| lambda-db : an odmg-based object-oriented dbms | arvind rajendran , david maier , leonidas fegaras , chandrasekhar srinivasan | sigmod conference |   2000 |

Entity B:
| title                                        | authors          | venue                                          |   year |
|:---------------------------------------------|:-----------------|:-----------------------------------------------|-------:|
| query unnesting in object-oriented databases | leonidas fegaras | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                                       | authors                               | venue   |   year |
|:------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| the impact of global clustering on spatial database systems | thomas brinkhoff , hans-peter kriegel | vldb    |   1994 |

Entity B:
| title                                                            | authors                                                                  | venue             |   year |
|:-----------------------------------------------------------------|:-------------------------------------------------------------------------|:------------------|-------:|
| the impact of database research on industrial products ( panel ) | jos &#233; a. blakeley , dan fishman , david lomet , michael stonebraker | acm sigmod record |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1415
rtable_id: 1684
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 |
|:----------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| transparent mid-tier database caching in sql server | per-åke larson , jingren zhou , jonathan goldstein | sigmod conference |   2003 |

Entity B:
| title                                       | authors                                                                                                             | venue                                          |   year |
|:--------------------------------------------|:--------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| middle-tier database caching for e-business | qiong luo , sailesh krishnamurthy , c. mohan , hamid pirahesh , honguk woo , bruce g. lindsay , jeffrey f. naughton | international conference on management of data |   2002 |



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

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

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

Entity A:
| title                                                                    | authors                                                 | venue             |   year |
|:-------------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| materialized view and index selection tool for microsoft sql server 2000 | vivek r. narasayya , sanjay agrawal , surajit chaudhuri | sigmod conference |   2001 |

Entity B:
| title                                                                  | authors                                | venue                 |   year |
|:-----------------------------------------------------------------------|:---------------------------------------|:----------------------|-------:|
| an efficient cost-driven index selection tool for microsoft sql server | surajit chaudhuri , vivek r. narasayya | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1088
rtable_id: 1033
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 |
|:----------------------------------------------|:----------------|:----------------------------|-------:|
| safe query languages for constraint databases | peter z. revesz | acm trans . database syst . |   1998 |

Entity B:
| title                                                  | authors                                          | venue                                         |   year |
|:-------------------------------------------------------|:-------------------------------------------------|:----------------------------------------------|-------:|
| formal query languages for secure relational databases | marianne winslett , kenneth smith , xiaolei qian | acm transactions on database systems ( tods ) |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1577
rtable_id: 1649
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 |
|:-----------------------------------------------|:-----------------------------------------------|:-----------------------------------------------|-------:|
| a system for watermarking relational databases | rakesh agrawal , peter j. haas , jerry kiernan | international conference on management of data |   2003 |



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

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

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

Entity A:
| title                                               | authors                                     | venue             |   year |
|:----------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| scalable parallel data mining for association rules | eui-hong han , vipin kumar , george karypis | sigmod conference |   1997 |

Entity B:
| title                                               | authors                                     | venue                                          |   year |
|:----------------------------------------------------|:--------------------------------------------|:-----------------------------------------------|-------:|
| scalable parallel data mining for association rules | eui-hong han , george karypis , vipin kumar | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 146
rtable_id: 1812
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 |
|:--------------------------------------------------------------|:-----------------------------------------------|:----------------------------|-------:|
| tracing the lineage of view data in a warehousing environment | janet l. wiener , yingwei cui , jennifer widom | acm trans . database syst . |   2000 |

Entity B:
| title                                                                   | authors                                    | venue                 |   year |
|:------------------------------------------------------------------------|:-------------------------------------------|:----------------------|-------:|
| algorithms for materialized view design in data warehousing environment | jian yang , kamalakar karlapalem , qing li | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2562
rtable_id: 1072
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 |
|:--------------------------------|:---------------------|:--------------|-------:|
| information director 's message | alberto o. mendelzon | sigmod record |   1998 |

Entity B:
| title                | authors        | venue             |   year |
|:---------------------|:---------------|:------------------|-------:|
| treasurer 's message | joachim hammer | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 285
rtable_id: 542
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 deductive databases by mixed integer programming | anil nerode , colin bell , raymond t. ng , v. s. subrahmanian | acm trans . database syst . |   1996 |

Entity B:
| title                                                    | authors                        | venue                                          |   year |
|:---------------------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| implementing database operations using simd instructions | jingren zhou , kenneth a. ross | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1297
rtable_id: 700
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 |
|:---------------------------------------------------|:------------|:--------------|-------:|
| converting relational to object-oriented databases | joseph fong | sigmod record |   1997 |

Entity B:
| title                                              | authors     | venue             |   year |
|:---------------------------------------------------|:------------|:------------------|-------:|
| converting relational to object-oriented databases | joseph fong | acm sigmod record |   1997 |



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

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

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

Entity A:
| title                                                     | authors                                                                                                              | venue   |   year |
|:----------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| scientific journals : extinction or explosion ? ( panel ) | gio wiederhold , abraham silberschatz , gerhard rossbach , raghu ramakrishnan , jaco zijlstra , hector garcia-molina | vldb    |   1995 |

Entity B:
| title                                                     | authors                                                                                                              | venue                 |   year |
|:----------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| scientific journals : extinction or explosion ? ( panel ) | raghu ramakrishnan , hector garcia-molina , gerhard rossbach , abraham silberschatz , gio wiederhold , jaco zijlstra | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2330
rtable_id: 1056
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 |
|:-------------------------------------------------|:----------------------------------------------|:--------|-------:|
| type classification of semi-structured documents | allen luniewski , markus tresch , neal palmer | vldb    |   1995 |

Entity B:
| title                                            | authors                                       | venue                 |   year |
|:-------------------------------------------------|:----------------------------------------------|:----------------------|-------:|
| type classification of semi-structured documents | markus tresch , neal palmer , allen luniewski | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1048
rtable_id: 1107
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 |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | ling liu  | sigmod record |   2001 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1093
rtable_id: 343
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 |
|:-------------------------------------------|:---------------|:--------|-------:|
| large databases for remote sensing and gis | a. r. dasgupta | vldb    |   1996 |

Entity B:
| title                                                                              | authors                                                                | venue                                         |   year |
|:-----------------------------------------------------------------------------------|:-----------------------------------------------------------------------|:----------------------------------------------|-------:|
| locally adaptive dimensionality reduction for indexing large time series databases | kaushik chakrabarti , eamonn keogh , sharad mehrotra , michael pazzani | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1642
rtable_id: 535
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 systems management and oracle8 | c. gregory doherty | sigmod conference |   1998 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2486
rtable_id: 2240
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 |
|:------------------------------------------------------------|:---------------|:--------------|-------:|
| supporting global user profiles through trusted authorities | ibrahim cingil | sigmod record |   2002 |

Entity B:
| title                                                       | authors        | venue             |   year |
|:------------------------------------------------------------|:---------------|:------------------|-------:|
| supporting global user profiles through trusted authorities | ibrahim cingil | acm sigmod record |   2002 |



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

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

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

Entity A:
| title                                          | authors                        | venue             |   year |
|:-----------------------------------------------|:-------------------------------|:------------------|-------:|
| optimization of dynamic query evaluation plans | goetz graefe , richard l. cole | sigmod conference |   1994 |

Entity B:
| title                                                | authors                          | venue                 |   year |
|:-----------------------------------------------------|:---------------------------------|:----------------------|-------:|
| optimization of queries with user-defined predicates | surajit chaudhuri , kyuseok shim | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 366
rtable_id: 1097
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 |
|:-------------------------------|:--------------------------------------------------------------------|:------------------|-------:|
| location-based spatial queries | jun zhang , dimitris papadias , manli zhu , yufei tao , dik lun lee | sigmod conference |   2003 |

Entity B:
| title                          | authors                                                             | venue                                          |   year |
|:-------------------------------|:--------------------------------------------------------------------|:-----------------------------------------------|-------:|
| location-based spatial queries | jun zhang , manli zhu , dimitris papadias , yufei tao , dik lun lee | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2251
rtable_id: 2055
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 |
|:----------------------------------------------------------|:------------|:------------------|-------:|
| data extraction and transformation for the data warehouse | cass squire | sigmod conference |   1995 |

Entity B:
| title                                                      | authors           | venue                                                                  |   year |
|:-----------------------------------------------------------|:------------------|:-----------------------------------------------------------------------|-------:|
| lineage tracing for general data warehouse transformations | y. cui , j. widom | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2386
rtable_id: 2119
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 trigs active object-oriented database system - an overview | gerti kappel , werner retschitzegger | sigmod record |   1998 |

Entity B:
| title                                                           | authors   | venue                                          |   year |
|:----------------------------------------------------------------|:----------|:-----------------------------------------------|-------:|
| unisql/x unified relational and object-oriented database system | won kim   | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2131
rtable_id: 1630
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 |
|:----------------------------------------------------|:-------------------------------|:--------|-------:|
| on the costs of multilingualism in database systems | a. kumaran , jayant r. haritsa | vldb    |   2003 |

Entity B:
| title                                    | authors                        | venue             |   year |
|:-----------------------------------------|:-------------------------------|:------------------|-------:|
| database systems-breaking out of the box | avi silberschatz , stan zdonik | acm sigmod record |   1997 |



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

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

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

Entity A:
| title                                                        | authors                                      | venue                       |   year |
|:-------------------------------------------------------------|:---------------------------------------------|:----------------------------|-------:|
| a logical foundation for deductive object-oriented databases | mengchi liu , tok wang ling , gillian dobbie | acm trans . database syst . |   2002 |

Entity B:
| title                                                                                  | authors                                                    | venue                                         |   year |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------|:----------------------------------------------|-------:|
| description logics for semantic query optimization in object-oriented database systems | domenico beneventano , sonia bergamaschi , claudio sartori | acm transactions on database systems ( tods ) |   2003 |



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

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

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

Entity A:
| title                                                        | authors                          | venue   |   year |
|:-------------------------------------------------------------|:---------------------------------|:--------|-------:|
| storage and retrieval of xml data using relational databases | surajit chaudhuri , kyuseok shim | vldb    |   2001 |

Entity B:
| title                                                               | authors                         | venue                 |   year |
|:--------------------------------------------------------------------|:--------------------------------|:----------------------|-------:|
| a multidatabase system for tracking and retrieval of financial data | munir cochinwala , john bradley | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2518
rtable_id: 2253
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 |
|:-------------------------------------------------------------------------------------------------------------------------------|:-----------------------------|:--------|-------:|
| hmap - a temporal data model managing intervals with different granularities and indeterminacy from natural language sentences | carlo combi , giuseppe pozzi | vldb j. |   2001 |

Entity B:
| title                                                                                                                          | authors                      | venue                                                                  |   year |
|:-------------------------------------------------------------------------------------------------------------------------------|:-----------------------------|:-----------------------------------------------------------------------|-------:|
| hmap - a temporal data model managing intervals with different granularities and indeterminacy from natural language sentences | carlo combi , giuseppe pozzi | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 830
rtable_id: 1264
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 |
|:------------------------------------------------------------------------------------------|:------------------|:--------------|-------:|
| re-designing distance functions and distance-based applications for high dimensional data | charu c. aggarwal | sigmod record |   2001 |

Entity B:
| title                                       | authors                          | venue                                          |   year |
|:--------------------------------------------|:---------------------------------|:-----------------------------------------------|-------:|
| outlier detection for high dimensional data | charu c. aggarwal , philip s. yu | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1121
rtable_id: 293
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 |
|:-----------------------------------------|:-------------------------------------|:--------------|-------:|
| modelling temporal thematic map contents | elaheh pourabbas , alberto d'onofrio | sigmod record |   2003 |

Entity B:
| title                                    | authors                              | venue             |   year |
|:-----------------------------------------|:-------------------------------------|:------------------|-------:|
| modelling temporal thematic map contents | alberto d'onofrio , elaheh pourabbas | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2543
rtable_id: 2121
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 |
|:---------------------------------------------------------------|:-----------------------------------------------------|:--------|-------:|
| odefs : a file system interface to an object-oriented database | narain h. gehani , william d. roome , h. v. jagadish | vldb    |   1994 |

Entity B:
| title                                                                                  | authors                                                    | venue                                         |   year |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------|:----------------------------------------------|-------:|
| description logics for semantic query optimization in object-oriented database systems | domenico beneventano , sonia bergamaschi , claudio sartori | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2183
rtable_id: 1236
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 | hector garcia-molina , patricia g. selinger , tomasz imielinski , david maier , jeffrey d. ullman , richard t. snodgrass | sigmod record |   1998 |

Entity B:
| title                               | authors           | venue             |   year |
|:------------------------------------|:------------------|:------------------|-------:|
| reminiscences on influential papers | richard snodgrass | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 472
rtable_id: 226
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 |
|:--------------------------------------------------------------------------|:-------------|:--------------|-------:|
| middle east technical university software research and development center | asuman dogac | sigmod record |   1996 |

Entity B:
| title                                                                     | authors      | venue             |   year |
|:--------------------------------------------------------------------------|:-------------|:------------------|-------:|
| middle east technical university software research and development center | asuman dogac | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 696
rtable_id: 1875
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 |
|:-------------------------------------------|:---------------------------------------------------------------------------------------|:------------------|-------:|
| delaunay : a database visualization system | kirby zhang , isabel f. cruz , michael averbuch , wendy t. lucas , melissa radzyminski | sigmod conference |   1997 |

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: 444
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 |
|:--------------------------|:------------------------------|:--------|-------:|
| adaptive index structures | yufei tao , dimitris papadias | vldb    |   2002 |

Entity B:
| title                                | authors                                                                               | venue                 |   year |
|:-------------------------------------|:--------------------------------------------------------------------------------------|:----------------------|-------:|
| a fast index for semistructured data | brian cooper , neal sample , michael j. franklin , gisli r. hjaltason , moshe shadmon | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2346
rtable_id: 1313
label: 0