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 |
|:--------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------|-------:|
| mixed mode xml query processing | stratis viglas , josef burger , leonidas galanis , jeffrey f. naughton , alan halverson , rajasekar krishnamurthy , david j. dewitt , feng tian , ameet kini , yuan wang , ajith nagaraja rao | vldb    |   2003 |

Entity B:
| title                                        | authors                                                                                | venue                 |   year |
|:---------------------------------------------|:---------------------------------------------------------------------------------------|:----------------------|-------:|
| low-cost compensation-based query processing | &#216; ystein gr &#248; vlen , svein-olaf hvasshovd , &#216; ystein torbj &#248; rnsen | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2149
rtable_id: 1017
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 techniques for queries with expensive methods | joseph m. hellerstein | acm trans . database syst . |   1998 |

Entity B:
| title                                                       | authors                                  | venue                 |   year |
|:------------------------------------------------------------|:-----------------------------------------|:----------------------|-------:|
| query processing techniques for multiversion access methods | jochen van den bercken , bernhard seeger | very large data bases |   1996 |



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

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

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

Entity A:
| title                               | authors                                                            | venue         |   year |
|:------------------------------------|:-------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | kaladhar voruganti , renée j. miller , kenneth a. ross , flip korn | sigmod record |   2002 |

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



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

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

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

Entity A:
| title                                                                               | authors                                         | venue             |   year |
|:------------------------------------------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| integrating mining with relational database systems : alternatives and implications | shiby thomas , rakesh agrawal , sunita sarawagi | sigmod conference |   1998 |

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: 2294
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 |
|:------------------------------------------------------------------------------|:-----------------------------|:--------|-------:|
| processing sliding window multi-joins in continuous queries over data streams | lukasz golab , m. tamer özsu | vldb    |   2003 |

Entity B:
| title                                                          | authors                                         | venue                                          |   year |
|:---------------------------------------------------------------|:------------------------------------------------|:-----------------------------------------------|-------:|
| on computing correlated aggregates over continual data streams | johannes gehrke , flip korn , divesh srivastava | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2137
rtable_id: 469
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 |
|:-------------------------------------------------------------------|:-------------------------------------------------------------------------------|:------------------|-------:|
| dyda : data warehouse maintenance in fully concurrent environments | songting chen , andreas koeller , elke a. rundensteiner , xin zhang , jun chen | sigmod conference |   2001 |

Entity B:
| title                                                           | authors   | venue                 |   year |
|:----------------------------------------------------------------|:----------|:----------------------|-------:|
| multiple-view self-maintenance in data warehousing environments | nam huyn  | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2136
rtable_id: 1031
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 |
|:----------------------------------------------------------|:--------------------------------------------------------------------------------------------------|:--------|-------:|
| legodb : customizing relational storage for xml documents | prasan roy , philip bohannon , jayant r. haritsa , jérôme siméon , maya ramanath , juliana freire | vldb    |   2002 |

Entity B:
| title                                                   | authors                                                                                                                              | venue                 |   year |
|:--------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| efficiently publishing relational data as xml documents | jayavel shanmugasundaram , eugene j. shekita , rimon barr , michael j. carey , bruce g. lindsay , hamid pirahesh , berthold reinwald | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1339
rtable_id: 879
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 |
|:---------------------|:---------------------------------------------------------------------------|:------------------|-------:|
| qbi : query by icons | antonio massari , panos k. chrysanthis , lorenzo saladini , stefano pavani | sigmod conference |   1995 |

Entity B:
| title                | authors                                                                    | venue                                          |   year |
|:---------------------|:---------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| qbi : query by icons | antonio massari , stefano pavani , lorenzo saladini , panos k. chrysanthis | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1520
rtable_id: 1530
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 |
|:-------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| trex : dtd-conforming xml to xml transformations | xueqing gong , kun yue , aoying zhou , zhimao guo , jianchang xiao , wenfei fan , hongwei wu , qing wang , shihui zheng | sigmod conference |   2003 |

Entity B:
| title                                            | authors                                                                                                                 | venue                                          |   year |
|:-------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| trex : dtd-conforming xml to xml transformations | aoying zhou , qing wang , zhimao guo , xueqing gong , shihui zheng , hongwei wu , jianchang xiao , kun yue , wenfei fan | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1721
rtable_id: 2023
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 a-tree : an index structure for high-dimensional spaces using relative approximation | masatoshi yoshikawa , shunsuke uemura , yasushi sakurai , haruhiko kojima | vldb    |   2000 |

Entity B:
| title                                                      | authors                                           | venue                                                                  |   year |
|:-----------------------------------------------------------|:--------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| the tv-tree : an index structure for high-dimensional data | king ip lin , h. v. jagadish , christos faloutsos | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 843
rtable_id: 585
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 |
|:----------------------------------------------|:-----------------|:--------|-------:|
| what do those weird xml types want , anyway ? | steven j. derose | vldb    |   1999 |

Entity B:
| title                                         | authors          | venue                 |   year |
|:----------------------------------------------|:-----------------|:----------------------|-------:|
| what do those weird xml types want , anyway ? | steven j. derose | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 733
rtable_id: 853
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 optimization in compressed database systems | zhiyuan chen , flip korn , johannes gehrke | sigmod conference |   2001 |

Entity B:
| title                                                        | authors                                            | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------------------|:-----------------------------------------------|-------:|
| revisiting commit processing in distributed database systems | ramesh gupta , jayant haritsa , krithi ramamritham | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1892
rtable_id: 1831
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 |
|:-----------------------------------------------------|:----------------------------------|:------------------|-------:|
| partitioned garbage collection of large object store | barbara liskov , umesh maheshwari | sigmod conference |   1997 |

Entity B:
| title                                                              | authors                                                 | venue                                          |   year |
|:-------------------------------------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| partition selection policies in object database garbage collection | jonathan e. cook , alexander l. wolf , benjamin g. zorn | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1239
rtable_id: 1647
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 |
|:------------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| thémis : a database programming language handling integrity constraints | anne doucet , véronique benzaken | vldb j. |   1995 |

Entity B:
| title                                                   | authors                                        | venue                                                                  |   year |
|:--------------------------------------------------------|:-----------------------------------------------|:-----------------------------------------------------------------------|-------:|
| fibonacci : a programming language for object databases | antonio albano , giorgio ghelli , renzo orsini | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 182
rtable_id: 636
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 extensible notation for spatiotemporal index queries | richard t. snodgrass , vassilis j. tsotras , christian s. jensen | sigmod record |   1998 |

Entity B:
| title                                          | authors                                    | venue                                         |   year |
|:-----------------------------------------------|:-------------------------------------------|:----------------------------------------------|-------:|
| analysis of predictive spatio-temporal queries | yufei tao , jimeng sun , dimitris papadias | acm transactions on database systems ( tods ) |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1805
rtable_id: 2196
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 |
|:------------------------------------------------------------------------------|:----------------|:------------------|-------:|
| will database researchers have any role in data security ? ( panel abstract ) | arnon rosenthal | sigmod conference |   2001 |

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



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

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

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

Entity A:
| title                                           | authors                | venue   |   year |
|:------------------------------------------------|:-----------------------|:--------|-------:|
| integrating information for on demand computing | nelson mendonça mattos | vldb    |   2003 |

Entity B:
| title                                          | authors                                                      | venue                                          |   year |
|:-----------------------------------------------|:-------------------------------------------------------------|:-----------------------------------------------|-------:|
| infomaster : an information integration system | michael r. genesereth , arthur m. keller , oliver m. duschka | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 181
rtable_id: 1846
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 |
|:----------------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | sang hyuk son , rasikan david , bhavani m. thuraisingham | sigmod record |   1996 |

Entity B:
| title                                               | authors                          | venue                 |   year |
|:----------------------------------------------------|:---------------------------------|:----------------------|-------:|
| secure buffering in firm real-time database systems | binto george , jayant r. haritsa | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 925
rtable_id: 998
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 sift information dissemination system | tak w. yan , hector garcia-molina | acm trans . database syst . |   1999 |

Entity B:
| title                                                   | authors                                                                                                                                                                                 | venue                 |   year |
|:--------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| sit-in : a real-life spatio-temporal information system | giuseppe sindoni , leonardo tininini , amedea ambrosetti , cristina bedeschi , stefano de francisci , orietta gargano , rossella molinaro , mario paolucci , paola patteri , pina ticca | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 865
rtable_id: 1416
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 mariposa distributed database management system | jeff sidell | sigmod record |   1996 |

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: 2296
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 |
|:-----------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| the asilomar report on database research | gerald held , hector garcia-molina , michael lesk , jim gray , philip a. bernstein , david maier , h. v. jagadish , michael stonebraker , stefano ceri , joseph m. hellerstein , david j. dewitt , jeffrey d. ullman , michael l. brodie , jeffrey f. naughton , michael j. franklin , hamid pirahesh | sigmod record |   1998 |

Entity B:
| title                                       | authors          | venue             |   year |
|:--------------------------------------------|:-----------------|:------------------|-------:|
| predator : a resource for database research | praveen seshadri | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2407
rtable_id: 1775
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 |
|:-------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| partition selection policies in object database garbage collection | benjamin g. zorn , alexander l. wolf , jonathan e. cook | sigmod conference |   1994 |

Entity B:
| title                               | authors                                 | venue                 |   year |
|:------------------------------------|:----------------------------------------|:----------------------|-------:|
| concurrent garbage collection in o2 | marcin skubiszewski , patrick valduriez | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2088
rtable_id: 1027
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 |
|:--------------------------------------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| join queries with external text sources : execution and optimization techniques | umeshwar dayal , surajit chaudhuri , tak w. yan | sigmod conference |   1995 |

Entity B:
| title                                                          | authors                                                                                               | venue                                          |   year |
|:---------------------------------------------------------------|:------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| the onion technique : indexing for linear optimization queries | yuan-chi chang , lawrence bergman , vittorio castelli , chung-sheng li , ming-ling lo , john r. smith | international conference on management of data |   2000 |



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

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

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

Entity A:
| title                                                                           | authors                              | venue   |   year |
|:--------------------------------------------------------------------------------|:-------------------------------------|:--------|-------:|
| efficient filtering of xml documents for selective dissemination of information | michael j. franklin , mehmet altinel | vldb    |   2000 |

Entity B:
| title                                                                           | authors                              | venue                 |   year |
|:--------------------------------------------------------------------------------|:-------------------------------------|:----------------------|-------:|
| efficient filtering of xml documents for selective dissemination of information | mehmet altinel , michael j. franklin | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 873
rtable_id: 883
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 multidimensional database system rasdaman | andreas dehmel , peter baumann , norbert widmann , roland ritsch , paula furtado | sigmod conference |   1998 |

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



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

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

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

Entity A:
| title                                                       | authors      | venue   |   year |
|:------------------------------------------------------------|:-------------|:--------|-------:|
| practical issues with commercial use of federated databases | jim kleewein | vldb    |   1996 |

Entity B:
| title                                                                | authors                                                                 | venue                                                                  |   year |
|:---------------------------------------------------------------------|:------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| interviso : dealing with the complexity of federated database access | marjorie templeton , herbert henley , edward maros , darrel j. van buer | the vldb journal -- the international journal on very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1264
rtable_id: 626
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 management systems and the internet | susan malaika | vldb    |   1996 |

Entity B:
| title                                    | authors             | venue                 |   year |
|:-----------------------------------------|:--------------------|:----------------------|-------:|
| pc database systems - present and future | philip a. bernstein | very large data bases |   1994 |



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

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

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

Entity A:
| title                               | authors                                                      | venue         |   year |
|:------------------------------------|:-------------------------------------------------------------|:--------------|-------:|
| reminiscences an influential papers | jeffrey f. naughton , minos n. garofalakis , kenneth a. ross | sigmod record |   2003 |

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



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

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

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

Entity A:
| title                                              | authors         | venue   |   year |
|:---------------------------------------------------|:----------------|:--------|-------:|
| incorporating xsl processing into database engines | guido moerkotte | vldb    |   2002 |

Entity B:
| title                                                          | authors                                               | venue                 |   year |
|:---------------------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| integrating sql databases with content-specific search engines | stefan de &#223; loch , nelson mendon &#231; a mattos | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2334
rtable_id: 956
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 |
|:-----------------------------------------------------------------------------------------------------|:--------------------------------------------------------|:--------------|-------:|
| management of data and services in the environmental information system ( uis ) of baden-württemberg | wolf-fritz riekert , roland mayer-föll , gerlinde wiest | sigmod record |   1997 |

Entity B:
| title                             | authors               | venue             |   year |
|:----------------------------------|:----------------------|:------------------|-------:|
| environmental information systems | oliver g &#252; nther | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1276
rtable_id: 1909
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 mining algorithms for generalized association rules with classification hierarchy | masaru kitsuregawa , takahiko shintani | sigmod conference |   1998 |

Entity B:
| title                                | authors                               | venue                 |   year |
|:-------------------------------------|:--------------------------------------|:----------------------|-------:|
| mining generalized association rules | ramakrishnan srikant , rakesh agrawal | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2503
rtable_id: 1108
label: 0