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 demarcation protocol : a technique for maintaining constraints in distributed database systems | daniel barbar &#225; - mill &#225; , hector garcia-molina | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2296
rtable_id: 590
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 |
|:-------------------------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| infosleuth : semantic integration of information in open and dynamic environments ( experience paper ) | gale martin , ray shea , tomasz ksiezyk , roberto j. bayardo jr. , marian h. nodine , william bohrer , vipul kashyap , c. unnikrishnan , richard s. brice , mosfeq rashid , amy unruh , abdelsalam helal , andrzej cichocki , marek rusinkiewicz , darrell woelk , jerry fowler | sigmod conference |   1997 |

Entity B:
| title                                                                     | authors                                                   | venue             |   year |
|:--------------------------------------------------------------------------|:----------------------------------------------------------|:------------------|-------:|
| dynamic service matchmaking among agents in open information environments | katia sycara , matthias klusch , seth widoff , jianguo lu | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 411
rtable_id: 120
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 |
|:---------------------------------------------------------------------------------------|:--------------------------------------|:--------------|-------:|
| from the guest editors - special section on data management issues in mobile computing | margaret h. dunham , abdelsalam helal | sigmod record |   1995 |

Entity B:
| title                                                                        | authors      | venue             |   year |
|:-----------------------------------------------------------------------------|:-------------|:------------------|-------:|
| data management issues in electronic commerce : guest editor 's introduction | asuman dogac | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 708
rtable_id: 344
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 foundation for multi-dimensional databases | laks v. s. lakshmanan , marc gyssens | vldb    |   1997 |

Entity B:
| title                                        | authors       | venue                                                                  |   year |
|:---------------------------------------------|:--------------|:-----------------------------------------------------------------------|-------:|
| management of multidimensional discrete data | peter baumann | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2595
rtable_id: 586
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 |
|:-----------------|:---------------------|:--------------|-------:|
| chair 's message | richard t. snodgrass | sigmod record |   2000 |

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: 1282
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 |
|:-------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| dbcache : database caching for web application servers | sailesh krishnamurthy , c. mohan , larry brown , hamid pirahesh , mehmet altinel , honguk woo , qiong luo , bruce g. lindsay | sigmod conference |   2002 |

Entity B:
| title                                                  | authors                         | venue                 |   year |
|:-------------------------------------------------------|:--------------------------------|:----------------------|-------:|
| form-based proxy caching for database-backed web sites | qiong luo , jeffrey f. naughton | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 786
rtable_id: 1418
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 supporting containment queries in relational database management systems | guy m. lohman , david j. dewitt , qiong luo , jeffrey f. naughton , chun zhang | sigmod conference |   2001 |

Entity B:
| title                                        | authors       | venue                 |   year |
|:---------------------------------------------|:--------------|:----------------------|-------:|
| database management systems and the internet | susan malaika | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 690
rtable_id: 1048
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 |
|:----------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------|:--------|-------:|
| facilitating multimedia database exploration through visual interfaces and perpetual query reformulations | kyoji hirata , yoshinori hara , wen-syan li , k. selçuk candan | vldb    |   1997 |

Entity B:
| title                                                                 | authors                                                                                                  | venue                                          |   year |
|:----------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| devise : integrated querying and visual exploration of large datasets | m. livny , r. ramakrishnan , k. beyer , g. chen , d. donjerkovic , s. lawande , j. myllymaki , k. wenger | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 1814
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 multimedia presentation algebra | maria luisa sapino , sibel adali , v. s. subrahmanian | sigmod conference |   1999 |

Entity B:
| title                      | authors                                                   | venue                                          |   year |
|:---------------------------|:----------------------------------------------------------|:-----------------------------------------------|-------:|
| a multi-similarity algebra | s. adali , p. bonatti , m. l. sapino , v. s. subrahmanian | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                           | authors                                            | venue             |   year |
|:------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| efficient evaluation of xml middle-ware queries | mary f. fernandez , dan suciu , atsuyuki morishima | sigmod conference |   2001 |

Entity B:
| title                              | authors                          | venue                 |   year |
|:-----------------------------------|:---------------------------------|:----------------------|-------:|
| evaluating top-k selection queries | surajit chaudhuri , luis gravano | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1920
rtable_id: 793
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 |
|:-----------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| one-dimensional and multi-dimensional substring selectivity estimation | raymond t. ng , divesh srivastava , h. v. jagadish , olga kapitskaia | vldb j. |   2000 |

Entity B:
| title                                               | authors                                          | venue                                          |   year |
|:----------------------------------------------------|:-------------------------------------------------|:-----------------------------------------------|-------:|
| on effective multi-dimensional indexing for strings | h. v. jagadish , nick koudas , divesh srivastava | international conference on management of data |   2000 |



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

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

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

Entity A:
| title                        | authors                            | venue             |   year |
|:-----------------------------|:-----------------------------------|:------------------|-------:|
| data grid management systems | arun jagatheesan , arcot rajasekar | sigmod conference |   2003 |

Entity B:
| title                                             | authors                                                   | venue             |   year |
|:--------------------------------------------------|:----------------------------------------------------------|:------------------|-------:|
| a query language for a web-site management system | mary fernandez , daniela florescu , alon levy , dan suciu | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 393
rtable_id: 1862
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 |
|:----------|:--------------------------------------------------------|:--------|-------:|
| editorial | peter m. g. apers , stefano ceri , richard t. snodgrass | vldb j. |   2002 |

Entity B:
| title           | authors                                    | venue                                                                  |   year |
|:----------------|:-------------------------------------------|:-----------------------------------------------------------------------|-------:|
| guest editorial | vijay atluri , anupam joshi , yelena yesha | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1086
rtable_id: 2184
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 ecrc multi database system | heribert schütz , willem jonker | sigmod conference |   1995 |

Entity B:
| title                               | authors                                                                                                                   | venue                                                                  |   year |
|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| the aditi deductive database system | jayen vaghani , kotagiri ramamohanarao , david b. kemp , zoltan somogyi , peter j. stuckey , tim s. leask , james harland | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1107
rtable_id: 576
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 |
|:-------------------------------------|:--------------------------------------|:--------|-------:|
| mining generalized association rules | ramakrishnan srikant , rakesh agrawal | vldb    |   1995 |

Entity B:
| title                                                                          | authors                                                        | venue                                          |   year |
|:-------------------------------------------------------------------------------|:---------------------------------------------------------------|:-----------------------------------------------|-------:|
| exploratory mining and pruning optimizations of constrained associations rules | raymond t. ng , laks v. s. lakshmanan , jiawei han , alex pang | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                           | authors                          | venue             |   year |
|:------------------------------------------------|:---------------------------------|:------------------|-------:|
| optimizing queries over multimedia repositories | luis gravano , surajit chaudhuri | sigmod conference |   1996 |

Entity B:
| title                                                    | authors                                                | venue                                          |   year |
|:---------------------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------|-------:|
| optimizing disjunctive queries with expensive predicates | a. kemper , g. moerkotte , k. peithner , m. steinbrunn | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 438
rtable_id: 1632
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 structured data from web pages | arvind arasu , hector garcia-molina | sigmod conference |   2003 |

Entity B:
| title                                                                       | authors                          | venue             |   year |
|:----------------------------------------------------------------------------|:---------------------------------|:------------------|-------:|
| extraction of object-oriented structures from existing relational databases | shekar ramanathan , julia hodges | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1517
rtable_id: 1912
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 |
|:-----------------------------------------------|:--------------------------------------|:------------------|-------:|
| s3 : similarity search in cad database systems | hans-peter kriegel , stefan berchtold | 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: 2036
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 |
|:---------------------------------|:-------------|:--------------|-------:|
| a web odyssey : from codd to xml | victor vianu | sigmod record |   2003 |

Entity B:
| title                            | authors      | venue             |   year |
|:---------------------------------|:-------------|:------------------|-------:|
| a web odyssey : from codd to xml | victor vianu | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1601
rtable_id: 2067
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 incinerate data model | h. v. jagadish | acm trans . database syst . |   1995 |

Entity B:
| title                              | authors        | venue             |   year |
|:-----------------------------------|:---------------|:------------------|-------:|
| a close look at the ifo data model | magdy s. hanna | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 265
rtable_id: 1657
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 |
|:-----------------------------------------------|:--------------------------------------|:------------------|-------:|
| s3 : similarity search in cad database systems | hans-peter kriegel , stefan berchtold | sigmod conference |   1997 |

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: 1
original: ltable_id: 2036
rtable_id: 1870
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 |
|:-------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------------|-------:|
| path sharing and predicate evaluation for high-performance xml filtering | yanlei diao , hao zhang , peter m. fischer , michael j. franklin , mehmet altinel | acm trans . database syst . |   2003 |

Entity B:
| title                                                                       | authors                                                 | venue             |   year |
|:----------------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| the design and performance evaluation of alternative xml storage strategies | feng tian , david j. dewitt , jianjun chen , chun zhang | acm sigmod record |   2002 |



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

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

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

Entity A:
| title                                           | authors                                               | venue             |   year |
|:------------------------------------------------|:------------------------------------------------------|:------------------|-------:|
| using the calanda time series management system | werner dreyer , angelika kotz dittrich , duri schmidt | sigmod conference |   1995 |

Entity B:
| title                                   | authors        | venue                 |   year |
|:----------------------------------------|:---------------|:----------------------|-------:|
| dwms : data warehouse management system | narendra mohan | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1870
rtable_id: 1051
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 |
|:----------------------------------|:----------|:------------------|-------:|
| management of semistructured data | dan suciu | acm sigmod record |   1997 |



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

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

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

Entity A:
| title                                                                | authors                                       | venue         |   year |
|:---------------------------------------------------------------------|:----------------------------------------------|:--------------|-------:|
| report on first international workshop on real-time database systems | sang hyuk son , kwei-jay lin , azer bestavros | sigmod record |   1996 |

Entity B:
| title                                           | authors        | venue             |   year |
|:------------------------------------------------|:---------------|:------------------|-------:|
| advances in real-time database systems research | azer bestavros | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1365
rtable_id: 372
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 |
|:---------------------------------------------------------------|:---------------------------------------------------------------------------------|:------------------|-------:|
| enabling dynamic content caching for database-driven web sites | qiong luo , divyakant agrawal , wen-syan li , wang-pin hsiung , k. selçuk candan | sigmod conference |   2001 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2464
rtable_id: 284
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 | z. meral özsoyoglu , philip s. yu , nick roussopoulos , krithi ramamritham , alberto o. mendelzon , richard t. snodgrass , laura m. haas , jennifer widom , jan paredaens | sigmod record |   1998 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1160
rtable_id: 546
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 |
|:-----------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| one-dimensional and multi-dimensional substring selectivity estimation | raymond t. ng , divesh srivastava , h. v. jagadish , olga kapitskaia | vldb j. |   2000 |

Entity B:
| title                                                                                     | authors                              | venue                 |   year |
|:------------------------------------------------------------------------------------------|:-------------------------------------|:----------------------|-------:|
| estimating the selectivity of spatial queries using the ` correlation ' fractal dimension | alberto belussi , christos faloutsos | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2009
rtable_id: 1478
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 research status report on adaptation for mobile data access | brian noble , mahadev satyanarayanan | sigmod record |   1995 |

Entity B:
| title                                 | authors                                    | venue                                          |   year |
|:--------------------------------------|:-------------------------------------------|:-----------------------------------------------|-------:|
| data replication for mobile computers | yixiu huang , prasad sistla , ouri wolfson | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2568
rtable_id: 1738
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 views and xml | serge abiteboul | sigmod record |   1999 |

Entity B:
| title                      | authors   | venue             |   year |
|:---------------------------|:----------|:------------------|-------:|
| on database theory and xml | dan suciu | acm sigmod record |   2001 |



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

Entity B:
| title                                                        | authors                                                                                | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| efficient evaluation of queries in a mediator for websources | vladimir zadorozhny , louiqa raschid , maria esther vidal , tolga urhan , laura bright | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1568
rtable_id: 644
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 |
|:----------------------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| historical queries along multiple lines of time evolution | vassilis j. tsotras , gad m. landau , jeanette p. schmidt | vldb j. |   1995 |

Entity B:
| title                                                     | authors                                                   | venue                                                                  |   year |
|:----------------------------------------------------------|:----------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| historical queries along multiple lines of time evolution | gad m. landau , jeanette p. schmidt , vassilis j. tsotras | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1319
rtable_id: 632
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 |
|:-----------------------------------------------------------------|:----------------------------------------|:--------------|-------:|
| semantic b2b integration : issues in ontology-based applications | zhan cui , paul o'brien , dean m. jones | sigmod record |   2002 |

Entity B:
| title                    | authors           | venue                                          |   year |
|:-------------------------|:------------------|:-----------------------------------------------|-------:|
| semantic b2b integration | christoph bussler | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2433
rtable_id: 367
label: 0