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 |
|:----------------------------------------------------|:------------|:--------------|-------:|
| the mariposa distributed database management system | jeff sidell | sigmod record |   1996 |

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: 2296
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 |
|:----------------------------------------------------|:-------------------------------|:--------|-------:|
| on the costs of multilingualism in database systems | a. kumaran , jayant r. haritsa | vldb    |   2003 |

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: 1279
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 |
|:---------------------------------------------------------------------------|:--------------------------------|:--------|-------:|
| selectivity estimation in extensible databases - a neural network approach | shaoyu zhou , m. seetha lakshmi | 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: 729
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 |
|:-----------------------------------------------------------------------------------|:-------------------------------|:----------------------------|-------:|
| a new approach to developing and implementing eager database replication protocols | gustavo alonso , bettina kemme | acm trans . database syst . |   2000 |

Entity B:
| title                                                                              | authors                        | venue                                         |   year |
|:-----------------------------------------------------------------------------------|:-------------------------------|:----------------------------------------------|-------:|
| a new approach to developing and implementing eager database replication protocols | bettina kemme , gustavo alonso | acm transactions on database systems ( tods ) |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1272
rtable_id: 460
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 |
|:-----------------------------------------------|:-----------------------------------------------------------------------------------------------------|:--------|-------:|
| xquec : pushing queries to compressed xml data | ioana manolescu , gianni costa , andrei arion , andrea pugliese , angela bonifati , sandra d'aguanno | vldb    |   2003 |

Entity B:
| title                                    | authors                             | venue                 |   year |
|:-----------------------------------------|:------------------------------------|:----------------------|-------:|
| optimizing queries on compressed bitmaps | sihem amer-yahia , theodore johnson | very large data bases |   2000 |



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

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

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

Entity A:
| title                                        | authors          | venue             |   year |
|:---------------------------------------------|:-----------------|:------------------|-------:|
| query unnesting in object-oriented databases | leonidas fegaras | sigmod conference |   1998 |

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



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

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

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

Entity A:
| title                                                        | authors                          | venue   |   year |
|:-------------------------------------------------------------|:---------------------------------|:--------|-------:|
| storage and retrieval of xml data using relational databases | surajit chaudhuri , kyuseok shim | 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: 2518
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 |
|:----------------------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| reconciling schemas of disparate data sources : a machine-learning approach | anhai doan , pedro domingos , alon y. halevy | sigmod conference |   2001 |

Entity B:
| title                                                                       | authors                                      | venue                                          |   year |
|:----------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| reconciling schemas of disparate data sources : a machine-learning approach | anhai doan , pedro domingos , alon y. halevy | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 767
rtable_id: 271
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 |
|:------------------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| exploiting constraint-like data characterizations in query optimization | jarek gryz , calisto zuzarte , parke godfrey | sigmod conference |   2001 |

Entity B:
| title                                | authors                                                              | venue             |   year |
|:-------------------------------------|:---------------------------------------------------------------------|:------------------|-------:|
| bringing order to query optimization | giedrius slivinskas , christian s. jensen , richard thomas snodgrass | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 205
rtable_id: 759
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 |
|:---------------------------------------------------------|:--------------------------------------------------------------------------|:--------|-------:|
| pesto : an integrated query/browser for object databases | laura m. haas , michael j. carey , vivekananda maganty , john h. williams | vldb    |   1996 |

Entity B:
| title                                                    | authors                                                                   | venue                 |   year |
|:---------------------------------------------------------|:--------------------------------------------------------------------------|:----------------------|-------:|
| pesto : an integrated query/browser for object databases | michael j. carey , laura m. haas , vivekananda maganty , john h. williams | very large data bases |   1996 |



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

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

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

Entity A:
| title                                           | authors                                     | venue                       |   year |
|:------------------------------------------------|:--------------------------------------------|:----------------------------|-------:|
| a taxonomy for secure object-oriented databases | sebastiaan h. von solms , martin s. olivier | acm trans . database syst . |   1994 |

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



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

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

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

Entity A:
| title                                                  | authors                                          | venue                       |   year |
|:-------------------------------------------------------|:-------------------------------------------------|:----------------------------|-------:|
| formal query languages for secure relational databases | marianne winslett , kenneth smith , xiaolei qian | acm trans . database syst . |   1994 |

Entity B:
| title                                                         | authors                                                 | venue                                          |   year |
|:--------------------------------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| ofl : a functional execution model for object query languages | georges gardarin , fernando machuca , philippe pucheral | international conference on management of data |   1995 |



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

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

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

Entity A:
| title                          | authors       | venue         |   year |
|:-------------------------------|:--------------|:--------------|-------:|
| describing semistructured data | luca cardelli | sigmod record |   2001 |

Entity B:
| title                                                              | authors                                  | venue             |   year |
|:-------------------------------------------------------------------|:-----------------------------------------|:------------------|-------:|
| semantic integration of semistructured and structured data sources | s. bergamaschi , s. castano , m. vincini | acm sigmod record |   1999 |



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

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

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

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

Entity B:
| title                                                           | authors                                                         | venue                                          |   year |
|:----------------------------------------------------------------|:----------------------------------------------------------------|:-----------------------------------------------|-------:|
| semantic assumptions and query evaluation in temporal databases | claudio bettini , x. sean wang , elisa bertino , sushil jajodia | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1015
rtable_id: 1512
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 |
|:-----------------------------------------------------------------------|:-----------------------------|:--------------|-------:|
| unisql 's next-generation object-relational database management system | phil janus , albert d'andrea | sigmod record |   1996 |

Entity B:
| title                                                        | authors                                | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| implementation of magic-sets in a relational database system | inderpal singh mumick , hamid pirahesh | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 9
rtable_id: 1715
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 |
|:-------------------------------------------|:--------------------|:--------------|-------:|
| repositories and object oriented databases | philip a. bernstein | sigmod record |   1998 |

Entity B:
| title                                                    | authors                                                                   | venue                 |   year |
|:---------------------------------------------------------|:--------------------------------------------------------------------------|:----------------------|-------:|
| pesto : an integrated query/browser for object databases | michael j. carey , laura m. haas , vivekananda maganty , john h. williams | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 692
rtable_id: 1053
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 |
|:------------------------------------------------------|:-------------------|:--------|-------:|
| extracting large data sets using db2 parallel edition | sriram padmanabhan | vldb    |   1996 |

Entity B:
| title                                    | authors        | venue                 |   year |
|:-----------------------------------------|:---------------|:----------------------|-------:|
| managing a db2 parallel edition database | gilles fecteau | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2146
rtable_id: 1437
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 |
|:-------------------------------------|:--------------------------------------------------|:------------------|-------:|
| vqbd : exploring semistructured data | jihwang yeo , sudarshan s. chawathe , thomas baby | sigmod conference |   2001 |

Entity B:
| title                                                                | authors                                             | venue             |   year |
|:---------------------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| semistructured and structured data in the web : going back and forth | paolo atzeni , giansalvatore mecca , paolo merialdo | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 747
rtable_id: 1754
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 |
|:--------------------------------------------------------------------------------------------------|:-------------------------------------------------|:----------------------------|-------:|
| top-k selection queries over relational databases : mapping strategies and performance evaluation | surajit chaudhuri , nicolas bruno , luis gravano | acm trans . database syst . |   2002 |

Entity B:
| title                                                                                             | authors                                          | venue                                         |   year |
|:--------------------------------------------------------------------------------------------------|:-------------------------------------------------|:----------------------------------------------|-------:|
| top-k selection queries over relational databases : mapping strategies and performance evaluation | nicolas bruno , surajit chaudhuri , luis gravano | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2266
rtable_id: 528
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 |
|:------------------------------------------|:------------------------------------------------------|:------------------|-------:|
| parallel evaluation of multi-join queries | jan flokstra , annita n. wilschut , peter m. g. apers | sigmod conference |   1995 |

Entity B:
| title                                                                     | authors                                     | venue                                                                  |   year |
|:--------------------------------------------------------------------------|:--------------------------------------------|:-----------------------------------------------------------------------|-------:|
| on applying hash filters to improving the execution of multi-join queries | ming-syan chen , hui-i hsiao , philip s. yu | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1568
rtable_id: 1165
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 structured information manager : a database system for sgml documents | ron sacks-davis | vldb    |   1996 |

Entity B:
| title                                    | authors                  | venue             |   year |
|:-----------------------------------------|:-------------------------|:------------------|-------:|
| temporal database system implementations | michael h. b &#246; hlen | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1201
rtable_id: 1600
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 structures for selective dissemination of information under the boolean model | tak w. yan , hector garcia-molina | acm trans . database syst . |   1994 |

Entity B:
| title                                                                               | authors                                         | venue                                         |   year |
|:------------------------------------------------------------------------------------|:------------------------------------------------|:----------------------------------------------|-------:|
| index structures for selective dissemination of information under the boolean model | tak w. yan , h &#233; ctor garc &#237; a-molina | acm transactions on database systems ( tods ) |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1907
rtable_id: 1311
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 |
|:------------------------------|:--------------------------------------------------------------------------------------|:--------|-------:|
| proximity search in databases | narayanan shivakumar , hector garcia-molina , roy goldman , suresh venkatasubramanian | vldb    |   1998 |

Entity B:
| title                                          | authors                               | venue                                          |   year |
|:-----------------------------------------------|:--------------------------------------|:-----------------------------------------------|-------:|
| s3 : similarity search in cad database systems | stefan berchtold , hans-peter kriegel | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1138
rtable_id: 1870
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 |
|:-----------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| metu interoperable database system | ebru kilic , pinar koksal , cem evrendilek , ugur halici , sema mancuhan , n. kesim , asuman dogac , cevdet dengi , sena nural , gökhan özhan , fatma ozcan , ismailcem budak arpinar | sigmod record |   1995 |

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



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

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

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

Entity A:
| title                                                                            | authors                 | venue         |   year |
|:---------------------------------------------------------------------------------|:------------------------|:--------------|-------:|
| the five-minute rule ten years later , and other computer storage rules of thumb | jim gray , goetz graefe | sigmod record |   1997 |

Entity B:
| title                                                                            | authors                 | venue             |   year |
|:---------------------------------------------------------------------------------|:------------------------|:------------------|-------:|
| the five-minute rule ten years later , and other computer storage rules of thumb | jim gray , goetz graefe | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1549
rtable_id: 1747
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 |
|:------------------------------------------------------|:--------------------------------------------|:--------|-------:|
| distance-based outliers : algorithms and applications | v. tucakov , raymond t. ng , edwin m. knorr | vldb j. |   2000 |

Entity B:
| title                                                                                     | authors           | venue             |   year |
|:------------------------------------------------------------------------------------------|:------------------|:------------------|-------:|
| re-designing distance functions and distance-based applications for high dimensional data | charu c. aggarwal | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1009
rtable_id: 473
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 aditi deductive database system | kotagiri ramamohanarao , david b. kemp , jayen vaghani , tim s. leask , james harland , peter j. stuckey , zoltan somogyi | vldb j. |   1994 |

Entity B:
| title                                                        | authors                                           | venue                 |   year |
|:-------------------------------------------------------------|:--------------------------------------------------|:----------------------|-------:|
| applying database technology in the adsm mass storage system | luis-felipe cabrera , robert rees , wayne hineman | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 229
rtable_id: 1104
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 |
|:------------------------------------|:-----------------------------------------------------------|:--------|-------:|
| effective timestamping in databases | christian s. jensen , kristian torp , richard t. snodgrass | vldb j. |   2000 |

Entity B:
| title                               | authors                                                        | venue                                                                  |   year |
|:------------------------------------|:---------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| effective timestamping in databases | kristian torp , christian s. jensen , richard thomas snodgrass | the vldb journal -- the international journal on very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 198
rtable_id: 1220
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 |
|:------------------------------------|:----------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | kenneth a. ross , beng chin ooi , frank neven | sigmod record |   2003 |

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



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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 644
rtable_id: 1915
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 |
|:-------------------------------------------------------------------|:--------------------------|:--------|-------:|
| exact : an extensible approach to active object-oriented databases | arturo jaime , oscar díaz | vldb j. |   1997 |

Entity B:
| title                                                              | authors                          | venue                                                                  |   year |
|:-------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|-------:|
| exact : an extensible approach to active object-oriented databases | oscar d &#237; az , arturo jaime | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2494
rtable_id: 1159
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 |
|:-------------------------------------------------------------------|:-----------------------------------------------------------------------|:------------------|-------:|
| the design of an acquisitional query processor for sensor networks | samuel madden , wei hong , joseph m. hellerstein , michael j. franklin | sigmod conference |   2003 |

Entity B:
| title                                                                 | authors                    | venue             |   year |
|:----------------------------------------------------------------------|:---------------------------|:------------------|-------:|
| the cougar approach to in-network query processing in sensor networks | yong yao , johannes gehrke | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2276
rtable_id: 540
label: 0