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 |
|:------------------------------------------------------------|:-----------------------------------------------------------------------------|:--------------|-------:|
| lore : a database management system for semistructured data | roy goldman , serge abiteboul , jennifer widom , dallan quass , jason mchugh | sigmod record |   1997 |

Entity B:
| title                                                       | authors                                    | venue                 |   year |
|:------------------------------------------------------------|:-------------------------------------------|:----------------------|-------:|
| tavant system architecture for sell-side channel management | srinivasa narayanan , subbu n. subramanian | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2224
rtable_id: 1330
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 |
|:---------------------------------------------------|:------------|:--------------|-------:|
| in reply to domains , relations and religious wars | hugh darwen | sigmod record |   1996 |

Entity B:
| title                                                                   | authors    | venue             |   year |
|:------------------------------------------------------------------------|:-----------|:------------------|-------:|
| a response to r. camps ' article domains , relations and religious wars | c. j. date | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 173
rtable_id: 1892
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 |
|:------------------------------------------------------------------|:------------------------------------------------------------------------|:--------|-------:|
| multi-dimensional regression analysis of time-series data streams | benjamin w. wah , yixin chen , jianyong wang , guozhu dong , jiawei han | vldb    |   2002 |

Entity B:
| title                                                      | authors                                    | venue                                          |   year |
|:-----------------------------------------------------------|:-------------------------------------------|:-----------------------------------------------|-------:|
| multi-dimensional resource scheduling for parallel queries | minos n. garofalakis , yannis e. ioannidis | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1543
rtable_id: 1981
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 |
|:-----------------------------|:--------------------------------|:------------------|-------:|
| size separation spatial join | kenneth c. sevcik , nick koudas | sigmod conference |   1997 |

Entity B:
| title                              | authors                            | venue                                          |   year |
|:-----------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| partition based spatial-merge join | jignesh m. patel , david j. dewitt | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1041
rtable_id: 1972
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 |
|:-----------------------------------|:---------------------------------|:--------|-------:|
| evaluating top-k selection queries | luis gravano , surajit chaudhuri | vldb    |   1999 |

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: 1
original: ltable_id: 1944
rtable_id: 793
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 middleware muddle | david ritter | sigmod record |   1998 |

Entity B:
| title                 | authors      | venue             |   year |
|:----------------------|:-------------|:------------------|-------:|
| the middleware muddle | david ritter | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1882
rtable_id: 112
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 |
|:------------------------------------------------------------------------|:-----------------------------------------------------------|:--------|-------:|
| integrating triggers and declarative constraints in sql database sytems | roberta cochrane , hamid pirahesh , nelson mendonça mattos | vldb    |   1996 |

Entity B:
| title                                                                                                | authors                                         | venue                                          |   year |
|:-----------------------------------------------------------------------------------------------------|:------------------------------------------------|:-----------------------------------------------|-------:|
| integrating association rule mining with relational database systems : alternatives and implications | sunita sarawagi , shiby thomas , rakesh agrawal | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 35
rtable_id: 1795
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 |
|:------------------------------------------|:----------------|:------------------|-------:|
| oracle rac : architecture and performance | angelo pruscino | sigmod conference |   2003 |

Entity B:
| title                                                   | authors                          | venue             |   year |
|:--------------------------------------------------------|:---------------------------------|:------------------|-------:|
| workshop on performance and architecture of web servers | krishna kant , prasant mohapatra | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1838
rtable_id: 499
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 |
|:-----------------------------------------------|:------------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| anatomy of a native xml base management system | thorsten fiebig , till westmann , robert schiele , guido moerkotte , carl-christian kanne , julia neumann , sven helmer | vldb j. |   2002 |

Entity B:
| title                                                                          | authors                      | venue             |   year |
|:-------------------------------------------------------------------------------|:-----------------------------|:------------------|-------:|
| the active database management system manifesto : a rulebase of adbms features | corporate act-net consortium | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 508
rtable_id: 1872
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 network is the database : data management for highly distributed systems | michael j. wynblatt , julio c. navas | sigmod conference |   2001 |

Entity B:
| title                                   | authors            | venue                                          |   year |
|:----------------------------------------|:-------------------|:-----------------------------------------------|-------:|
| database systems management and oracle8 | c. gregory doherty | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2098
rtable_id: 171
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 |
|:------------------------------------------------------------------------------------------------|:-------------------------------------------|:--------|-------:|
| l/mrp : a buffer management strategy for interactive continuous data flows in a multimedia dbms | wolfgang klas , frank moser , achim kraiss | vldb    |   1995 |

Entity B:
| title                                                                                           | authors                                    | venue                 |   year |
|:------------------------------------------------------------------------------------------------|:-------------------------------------------|:----------------------|-------:|
| l/mrp : a buffer management strategy for interactive continuous data flows in a multimedia dbms | frank moser , achim kraiss , wolfgang klas | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 80
rtable_id: 1461
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 |
|:---------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| birch : an efficient data clustering method for very large databases | raghu ramakrishnan , miron livny , tian zhang | sigmod conference |   1996 |

Entity B:
| title                                                                                      | authors                                                         | venue                                                                  |   year |
|:-------------------------------------------------------------------------------------------|:----------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| wavecluster : a wavelet-based clustering approach for spatial data in very large databases | gholamhosein sheikholeslami , surojit chatterjee , aidong zhang | the vldb journal -- the international journal on very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 144
rtable_id: 1223
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 |
|:----------------------------------------------------------------|:----------|:-----------------------------------------------|-------:|
| unisql/x unified relational and object-oriented database system | won kim   | international conference on management of data |   1994 |



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

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

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

Entity A:
| title                                           | authors                                | venue   |   year |
|:------------------------------------------------|:---------------------------------------|:--------|-------:|
| query processing and optimization in oracle rdb | gennady antoshenkov , mohamed ziauddin | vldb j. |   1996 |

Entity B:
| title                                    | authors                          | venue                 |   year |
|:-----------------------------------------|:---------------------------------|:----------------------|-------:|
| including group-by in query optimization | surajit chaudhuri , kyuseok shim | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1169
rtable_id: 2211
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 |
|:---------------------------------------------------------|:--------------------------|:--------------|-------:|
| new tpc benchmarks for decision support and web commerce | meikel pöss , chris floyd | sigmod record |   2000 |

Entity B:
| title                                                           | authors                                                 | venue                                          |   year |
|:----------------------------------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| tpc-ds , taking decision support benchmarking to the next level | meikel poess , bryan smith , lubor kollar , paul larson | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2240
rtable_id: 724
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 |
|:----------------------------------------------------|:-----------------|:--------|-------:|
| querying a multilevel database : a logical analysis | frédéric cuppens | vldb    |   1996 |

Entity B:
| title                                                        | authors                                   | venue                 |   year |
|:-------------------------------------------------------------|:------------------------------------------|:----------------------|-------:|
| querying multiple features of groups in relational databases | damianos chatziantoniou , kenneth a. ross | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1795
rtable_id: 1046
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 |
|:--------------------------------------------------------|:------------------------------|:------------------|-------:|
| time-parameterized queries in spatio-temporal databases | dimitris papadias , yufei tao | sigmod conference |   2002 |

Entity B:
| title                                     | authors                                                                             | venue                                          |   year |
|:------------------------------------------|:------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| closest pair queries in spatial databases | antonio corral , yannis manolopoulos , yannis theodoridis , michael vassilakopoulos | international conference on management of data |   2000 |



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

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

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

Entity A:
| title                                                                        | authors                                                                                      | venue   |   year |
|:-----------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------|:--------|-------:|
| an effective deductive object-oriented database through language integration | m. howard williams , norman w. paton , andrew dinn , maria l. barja , alvaro a. a. fernandes | vldb    |   1994 |

Entity B:
| title                                                                     | authors                                                                | venue                                          |   year |
|:--------------------------------------------------------------------------|:-----------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the algres testbed of chimera : an active object-oriented database system | stefano ceri , piero fraternali , stefano paraboschi , giuseppe psaila | international conference on management of data |   1995 |



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

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

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

Entity A:
| title                               | authors                                                 | venue             |   year |
|:------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| dynamic multidimensional histograms | piotr indyk , sudipto guha , nitin thaper , nick koudas | sigmod conference |   2002 |

Entity B:
| title                                         | authors                                                                        | venue                                          |   year |
|:----------------------------------------------|:-------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| caching multidimensional queries using chunks | prasad m. deshpande , karthikeyan ramasamy , amit shukla , jeffrey f. naughton | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                       | authors             | venue   |   year |
|:--------------------------------------------|:--------------------|:--------|-------:|
| an introduction to spatial database systems | ralf hartmut güting | vldb j. |   1994 |

Entity B:
| title                                                       | authors                                | venue                                                                  |   year |
|:------------------------------------------------------------|:---------------------------------------|:-----------------------------------------------------------------------|-------:|
| an introduction to deductive database languages and systems | kotagiri ramamohanarao , 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: 1753
rtable_id: 580
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 database theory and xml | dan suciu | sigmod record |   2001 |

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



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

Entity B:
| title                                                        | authors                                                                                  | venue                                          |   year |
|:-------------------------------------------------------------|:-----------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the mentor workbench for enterprise-wide workflow management | dirk wodtke , jeanine weissenfels , gerhard weikum , angelika kotz dittrich , peter muth | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 398
rtable_id: 1869
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 |
|:----------------------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| mocha : a self-extensible database middleware system for distributed data sources | manuel rodriguez-martinez , nick roussopoulos | sigmod conference |   2000 |

Entity B:
| title                                                          | authors                                                                   | venue                                          |   year |
|:---------------------------------------------------------------|:--------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| disima : a distributed and interoperable image database system | vincent oria , m. tamer &#214; zsu , paul j. iglinski , shu lin , bin yao | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1251
rtable_id: 400
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 |
|:----------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| grid data management systems & services | reagan moore , arun jagatheesan , paul watson , norman w. paton | vldb    |   2003 |

Entity B:
| title                        | authors                            | venue                                          |   year |
|:-----------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| data grid management systems | arun jagatheesan , arcot rajasekar | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1546
rtable_id: 2250
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 |
|:----------------------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| mocha : a self-extensible database middleware system for distributed data sources | manuel rodriguez-martinez , nick roussopoulos | sigmod conference |   2000 |

Entity B:
| title                                              | authors                                                                                                              | venue                                                                  |   year |
|:---------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| mariposa : a wide-area distributed database system | michael stonebraker , paul m. aoki , witold litwin , avi pfeffer , adam sah , jeff sidell , carl staelin , andrew yu | the vldb journal -- the international journal on very large data bases |   1996 |



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

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

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

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

Entity B:
| title                                                                       | authors                          | venue             |   year |
|:----------------------------------------------------------------------------|:---------------------------------|:------------------|-------:|
| 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: 287
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 |
|:-------------------------------------------------------------------------------|:-------------------------------------------|:--------------|-------:|
| integrating modelling systems for environmental management information systems | david j. abel , dean kuo , kerry l. taylor | sigmod record |   1997 |

Entity B:
| title                                                            | authors                      | venue             |   year |
|:-----------------------------------------------------------------|:-----------------------------|:------------------|-------:|
| improving access to environmental data using context information | anthony tomasic , eric simon | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1361
rtable_id: 1907
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 |
|:----------------------------|:---------------------------------------------------|:--------------|-------:|
| virtual database technology | venky harinarayan , ashish gupta , anand rajaraman | sigmod record |   1997 |

Entity B:
| title                                               | authors                                                          | venue                 |   year |
|:----------------------------------------------------|:-----------------------------------------------------------------|:----------------------|-------:|
| integration of data mining with database technology | amir netz , surajit chaudhuri , jeff bernhardt , usama m. fayyad | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 683
rtable_id: 886
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 |
|:---------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| opt + + : an object-oriented implementation for extensible database query optimization | david j. dewitt , navin kabra | vldb j. |   1999 |

Entity B:
| title                                                        | authors                                      | venue                                         |   year |
|:-------------------------------------------------------------|:---------------------------------------------|:----------------------------------------------|-------:|
| a logical foundation for deductive object-oriented databases | mengchi liu , gillian dobbie , tok wang ling | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2179
rtable_id: 346
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 |
|:----------------------------------------------|:---------------------------------------------|:------------------|-------:|
| similarity query processing using disk arrays | apostolos papadopoulos , yannis manolopoulos | sigmod conference |   1998 |

Entity B:
| title                                                                   | authors                                                                          | venue                 |   year |
|:------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:----------------------|-------:|
| improving adaptable similarity query processing by using approximations | mihael ankerst , bernhard braunm &#252; ller , hans-peter kriegel , thomas seidl | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2367
rtable_id: 1023
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 |
|:---------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------|:--------------|-------:|
| intelligent access to heterogeneous information sources : report on the 4th workshop on knowledge representation meets databases | manfred a. jeusfeld , franz baader , werner nutt | sigmod record |   1997 |

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



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

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

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

Entity A:
| title                                                                              | authors        | venue             |   year |
|:-----------------------------------------------------------------------------------|:---------------|:------------------|-------:|
| xml data management go native or spruce up relational systems ? ( panel abstract ) | per-åke larson | sigmod conference |   2001 |

Entity B:
| title                                                                               | authors                                                                                                           | venue                                          |   year |
|:------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| xml data management ( panel session ) : go native or spruce up relational systems ? | per - &#197; ke larson , dana florescu , goetz graefe , guido moerkotte , hamid pirahesh , harald sch &#246; ning | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 48
rtable_id: 360
label: 1