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 |
|:--------------------------------------------|:---------------------------------|:------------------|-------:|
| outlier detection for high dimensional data | charu c. aggarwal , philip s. yu | sigmod conference |   2001 |

Entity B:
| title                                                                               | authors                                                                     | venue                                          |   year |
|:------------------------------------------------------------------------------------|:----------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| automatic subspace clustering of high dimensional data for data mining applications | rakesh agrawal , johannes gehrke , dimitrios gunopulos , prabhakar raghavan | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                         | authors                                                       | venue         |   year |
|:----------------------------------------------|:--------------------------------------------------------------|:--------------|-------:|
| database research at arizona state university | suzanne w. dietrich , forouzan golshani , susan darling urban | sigmod record |   1996 |

Entity B:
| title                                    | authors                                                                               | venue             |   year |
|:-----------------------------------------|:--------------------------------------------------------------------------------------|:------------------|-------:|
| database research at columbia university | shih-fu chang , luis gravano , gail e. kaiser , kenneth a. ross , salvatore j. stolfo | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1020
rtable_id: 229
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 database systems 101 | jim gray  | sigmod conference |   1995 |

Entity B:
| title                                                            | authors                                             | venue                 |   year |
|:-----------------------------------------------------------------|:----------------------------------------------------|:----------------------|-------:|
| dynamic load balancing in hierarchical parallel database systems | luc bouganim , daniela florescu , patrick valduriez | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 838
rtable_id: 1100
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 |
|:--------------------------------|:--------------------------------------------------------------------------|:------------------|-------:|
| alphasort : a risc machine sort | david b. lomet , jim gray , zarka cvetanovic , chris nyberg , tom barclay | sigmod conference |   1994 |

Entity B:
| title                           | authors                                                               | venue                                          |   year |
|:--------------------------------|:----------------------------------------------------------------------|:-----------------------------------------------|-------:|
| alphasort : a risc machine sort | chris nyberg , tom barclay , zarka cvetanovic , jim gray , dave lomet | international conference on management of data |   1994 |



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

Entity B:
| title                            | authors                                | venue                                          |   year |
|:---------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| eos : an extensible object store | alexandros biliris , euthimios panagos | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2494
rtable_id: 1672
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 |
|:-----------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| research issues in federated database systems : report of efdbs '97 workshop | fèlix saltor , mark roantree , mark w. w. vermeer , wilhelm hasselbring , martin schönhoff , markus strässler , barry eaglestone , stefan conrad | sigmod record |   1997 |

Entity B:
| title                                                  | authors                                                                                                       | venue             |   year |
|:-------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| research and practice in federated information systems | w. hasselbring , w.-j . van den heuvel , g. j. houben , r.-d . kutsche , b. rieger , m. roantree , k. subieta | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 698
rtable_id: 451
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 |
|:-----------------------------------|:--------------------------------|:--------|-------:|
| protdb : probabilistic data in xml | andrew nierman , h. v. jagadish | vldb    |   2002 |

Entity B:
| title                                               | authors                                         | venue                 |   year |
|:----------------------------------------------------|:------------------------------------------------|:----------------------|-------:|
| using probabilistic information in data integration | daniela florescu , daphne koller , alon y. levy | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1152
rtable_id: 1075
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 |
|:---------------------------------------------------------------------|:----------|:--------|-------:|
| mineset ( tm ) : a system for high-end data mining and visualization | ?         | vldb    |   1996 |

Entity B:
| title                                      | authors                                                                           | venue                                          |   year |
|:-------------------------------------------|:----------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| delaunay : a database visualization system | isabel f. cruz , m. averbuch , wendy t. lucas , melissa radzyminski , kirby zhang | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 597
rtable_id: 1854
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 data model and data structures for moving objects databases | markus schneider , enrico nardelli , luca forlizzi , ralf hartmut güting | sigmod conference |   2000 |

Entity B:
| title                                                   | authors                                                                       | venue                 |   year |
|:--------------------------------------------------------|:------------------------------------------------------------------------------|:----------------------|-------:|
| a low-cost storage server for movie on demand databases | banu &#214; zden , alexandros biliris , rajeev rastogi , abraham silberschatz | very large data bases |   1994 |



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

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

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

Entity A:
| title                                                    | authors                                                               | venue             |   year |
|:---------------------------------------------------------|:----------------------------------------------------------------------|:------------------|-------:|
| optimizing disjunctive queries with expensive predicates | alfons kemper , guido moerkotte , michael steinbrunn , klaus peithner | sigmod conference |   1994 |

Entity B:
| title                                                        | authors                                                | venue                                          |   year |
|:-------------------------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------|-------:|
| factorizing complex predicates in queries to exploit indexes | surajit chaudhuri , prasanna ganesan , sunita sarawagi | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1395
rtable_id: 2045
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 |
|:-------------------------------------|:-----------------------------------------------------------------|:--------------|-------:|
| bringing order to query optimization | giedrius slivinskas , richard t. snodgrass , christian s. jensen | sigmod record |   2002 |

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: 1857
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 |
|:-----------------------------------------------------------------|:---------------------|:------------------|-------:|
| dec data distributor : for data replication and data warehousing | daniel j. dietterich | sigmod conference |   1994 |

Entity B:
| title                                             | authors                                                                                          | venue                                         |   year |
|:--------------------------------------------------|:-------------------------------------------------------------------------------------------------|:----------------------------------------------|-------:|
| are quorums an alternative for data replication ? | ricardo jim &#233; nez-peris , m. pati &#241; o-mart &#237; nez , gustavo alonso , bettina kemme | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 353
rtable_id: 2248
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 |
|:-----------------------------------------------------------|:-----------------------------|:--------|-------:|
| buffering and read-ahead strategies for external mergesort | per-åke larson , weiye zhang | vldb    |   1998 |

Entity B:
| title                                            | authors                              | venue                 |   year |
|:-------------------------------------------------|:-------------------------------------|:----------------------|-------:|
| dynamic memory adjustment for external mergesort | weiye zhang , per - &#197; ke larson | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 533
rtable_id: 954
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 |
|:-----------------------------------------------|:----------------|:--------|-------:|
| foundations of preferences in database systems | werner kießling | vldb    |   2002 |

Entity B:
| title                                                    | authors                                  | venue             |   year |
|:---------------------------------------------------------|:-----------------------------------------|:------------------|-------:|
| an aspect of query optimization in multidatabase systems | chiang lee , chia-jung chen , hongjun lu | acm sigmod record |   1995 |



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

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

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

Entity A:
| title                                                  | authors                                                                                          | venue         |   year |
|:-------------------------------------------------------|:-------------------------------------------------------------------------------------------------|:--------------|-------:|
| on the issue of valid time ( s ) in temporal databases | themis panayiotopoulos , efstathios v. ioannidis , constantine d. spyropoulos , stavros kokkotos | sigmod record |   1995 |

Entity B:
| title                                                  | authors                                                                                          | venue             |   year |
|:-------------------------------------------------------|:-------------------------------------------------------------------------------------------------|:------------------|-------:|
| on the issue of valid time ( s ) in temporal databases | stavros kokkotos , efstathios v. ioannidis , themis panayiotopoulos , constantine d. spyropoulos | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2191
rtable_id: 1566
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 |
|:--------------------------------------------------|:---------------------------------------------------------------------------------------------|:------------------|-------:|
| java and relational databases : sqlj ( tutorial ) | johannes klein , richard pledereder , gray clossman , brian becker , phil shaw , mark hapner | sigmod conference |   1998 |

Entity B:
| title                                                | authors                                           | venue                                          |   year |
|:-----------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------|-------:|
| sap r/3 ( tutorial ) : a database application system | alfons kemper , donald kossmann , florian matthes | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 133
rtable_id: 179
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 |
|:----------------|:---------------|:--------------|-------:|
| editor 's notes | jennifer widom | sigmod record |   1996 |

Entity B:
| title     | authors                                        | venue                                                                  |   year |
|:----------|:-----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| editorial | peter apers , stefano ceri , richard snodgrass | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2548
rtable_id: 917
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 management for earth system science | james frew , jeff dozier | sigmod record |   1997 |

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: 1346
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 |
|:------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| parametric query optimization | raymond t. ng , timos k. sellis , yannis e. ioannidis , kyuseok shim | vldb j. |   1997 |

Entity B:
| title                                                          | authors                                        | venue                                         |   year |
|:---------------------------------------------------------------|:-----------------------------------------------|:----------------------------------------------|-------:|
| outerjoin simplification and reordering for query optimization | c &#233; sar galindo-legaria , arnon rosenthal | acm transactions on database systems ( tods ) |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 18
rtable_id: 1883
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 |
|:------------------------------------------------|:------------------------------------------------------|:-----------------------------------------------|-------:|
| using the calanda time series management system | werner dreyer , angelika kotz dittrich , duri schmidt | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1546
rtable_id: 1938
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 |
|:--------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| scientific databases - state of the art and future directions | yannis e. ioannidis , maria zemankova | vldb    |   1994 |

Entity B:
| title                                                                              | authors                                    | venue             |   year |
|:-----------------------------------------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| component-based e-commerce : assessment of current practices and future directions | martin bichler , arie segev , j. leon zhao | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 31
rtable_id: 12
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 |
|:-------------------------------|:--------------------------------------|:------------------|-------:|
| privacy-preserving data mining | ramakrishnan srikant , rakesh agrawal | sigmod conference |   2000 |

Entity B:
| title                     | authors                | venue                                          |   year |
|:--------------------------|:-----------------------|:-----------------------------------------------|-------:|
| free parallel data mining | bin li , dennis shasha | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                      | authors                                  | venue         |   year |
|:-------------------------------------------|:-----------------------------------------|:--------------|-------:|
| database systems - breaking out of the box | abraham silberschatz , stanley b. zdonik | sigmod record |   1997 |

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: 909
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 |
|:-----------------------------------------------------------------------------|:---------------------------------------------------------------|:------------------|-------:|
| optimization of constrained frequent set queries with 2-variable constraints | laks v. s. lakshmanan , alex pang , raymond t. ng , jiawei han | sigmod conference |   1999 |

Entity B:
| title                                                   | authors                                                      | venue                                          |   year |
|:--------------------------------------------------------|:-------------------------------------------------------------|:-----------------------------------------------|-------:|
| exploratory mining via constrained frequent set queries | raymond ng , laks v. s. lakshmanan , jiawei han , teresa mah | international conference on management of data |   1999 |



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

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

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

Entity A:
| title                                                          | authors                              | venue         |   year |
|:---------------------------------------------------------------|:-------------------------------------|:--------------|-------:|
| the trigs active object-oriented database system - an overview | gerti kappel , werner retschitzegger | sigmod record |   1998 |

Entity B:
| title                               | authors                                                                                                                   | venue                                                                  |   year |
|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| 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: 2131
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 |
|:-----------------------------------------|:------------------|:--------------|-------:|
| temporal database system implementations | michael h. böhlen | sigmod record |   1995 |

Entity B:
| title                                        | authors                                                                                                       | venue                                          |   year |
|:---------------------------------------------|:--------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the ores temporal database management system | babis theodoulidis , aziz ait-braham , george andrianopoulos , jayant chaudhary , george karvelis , simon sou | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 162
rtable_id: 1667
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 model for compound type changes encountered in schema evolution | barbara staudt lerner | acm trans . database syst . |   2000 |

Entity B:
| title                                                             | authors               | venue                                         |   year |
|:------------------------------------------------------------------|:----------------------|:----------------------------------------------|-------:|
| a model for compound type changes encountered in schema evolution | barbara staudt lerner | acm transactions on database systems ( tods ) |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1755
rtable_id: 511
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 |
|:-------------------------------------------------|:----------------------------|:--------------|-------:|
| comparative analysis of six xml schema languages | dongwon lee , wesley w. chu | sigmod record |   2000 |

Entity B:
| title                                            | authors                     | venue             |   year |
|:-------------------------------------------------|:----------------------------|:------------------|-------:|
| comparative analysis of six xml schema languages | dongwon lee , wesley w. chu | acm sigmod record |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1547
rtable_id: 457
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 |
|:------------------------------------------|:---------------------------------|:--------|-------:|
| query engines for web-accessible xml data | ramez elmasri , leonidas fegaras | vldb    |   2001 |

Entity B:
| title                                     | authors                          | venue                 |   year |
|:------------------------------------------|:---------------------------------|:----------------------|-------:|
| query engines for web-accessible xml data | leonidas fegaras , ramez elmasri | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2299
rtable_id: 1326
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 |
|:----------------------------------------|:-------------------|:------------------|-------:|
| database systems management and oracle8 | c. gregory doherty | sigmod conference |   1998 |

Entity B:
| title                                                                  | authors                      | venue             |   year |
|:-----------------------------------------------------------------------|:-----------------------------|:------------------|-------:|
| unisql 's next-generation object-relational database management system | albert d'andrea , phil janus | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2486
rtable_id: 1885
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 |
|:--------------------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| diag-join : an opportunistic join algorithm for 1 : n relationships | sven helmer , guido moerkotte , till westmann | vldb    |   1998 |

Entity B:
| title                                                               | authors                                       | venue                 |   year |
|:--------------------------------------------------------------------|:----------------------------------------------|:----------------------|-------:|
| diag-join : an opportunistic join algorithm for 1 : n relationships | sven helmer , till westmann , guido moerkotte | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2372
rtable_id: 993
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 |
|:---------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| space-efficient online computation of quantile summaries | sanjeev khanna , michael greenwald | sigmod conference |   2001 |

Entity B:
| title                                                    | authors                            | venue                                          |   year |
|:---------------------------------------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| space-efficient online computation of quantile summaries | michael greenwald , sanjeev khanna | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 549
rtable_id: 295
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 |
|:------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| database research at the university of oklahoma | sirirut vanichayobon , leonard brown , ravi a. dirckze , sylvain guinepain , carlos sánchez , le gruenwald , brian summers | sigmod record |   1999 |

Entity B:
| title                                         | authors                                                  | venue             |   year |
|:----------------------------------------------|:---------------------------------------------------------|:------------------|-------:|
| database research at arizona state university | susan d. urban , suzanne w. dietrich , forouzan golshani | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 372
rtable_id: 323
label: 0