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 |
|:---------------------------------------------------|:------------|:--------------|-------:|
| converting relational to object-oriented databases | joseph fong | sigmod record |   1997 |

Entity B:
| title                                  | authors        | venue             |   year |
|:---------------------------------------|:---------------|:------------------|-------:|
| pixel-oriented database visualizations | daniel a. keim | acm sigmod record |   1996 |



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

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

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

Entity A:
| title                                                                                                  | authors                                                                                                                                                                                                                                                                         | venue             |   year |
|:-------------------------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| infosleuth : semantic integration of information in open and dynamic environments ( experience paper ) | gale martin , ray shea , tomasz ksiezyk , roberto j. bayardo jr. , marian h. nodine , william bohrer , vipul kashyap , c. unnikrishnan , richard s. brice , mosfeq rashid , amy unruh , abdelsalam helal , andrzej cichocki , marek rusinkiewicz , darrell woelk , jerry fowler | sigmod conference |   1997 |

Entity B:
| title                                                                          | authors     | venue             |   year |
|:-------------------------------------------------------------------------------|:------------|:------------------|-------:|
| semantic interoperability in information services : experiencing with coopware | avigdor gal | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 411
rtable_id: 125
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 |
|:------------------------------------------------------------------------|:---------------------------------------------------------|:--------|-------:|
| resource scheduling in enhanced pay-per-view continuous media databases | banu özden , minos n. garofalakis , abraham silberschatz | vldb    |   1997 |

Entity B:
| title                                                   | authors                       | venue             |   year |
|:--------------------------------------------------------|:------------------------------|:------------------|-------:|
| real-time database - similarity and resource scheduling | tei-wei kuo , aloysius k. mok | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 124
rtable_id: 375
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 | mitch cherniack , kenneth a. ross , gottfried vossen | sigmod record |   2003 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1639
rtable_id: 226
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 critique of ansi sql isolation levels | philip a. bernstein , patrick e. o'neil , hal berenson , elizabeth j. o'neil , jim melton , jim gray | sigmod conference |   1995 |

Entity B:
| title                                                | authors   | venue                                          |   year |
|:-----------------------------------------------------|:----------|:-----------------------------------------------|-------:|
| a survey and critique of advanced transaction models | c. mohan  | international conference on management of data |   1994 |



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

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

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

Entity A:
| title                                               | authors                                                                | venue   |   year |
|:----------------------------------------------------|:-----------------------------------------------------------------------|:--------|-------:|
| extracting large-scale knowledge bases from the web | andrew tomkins , prabhakar raghavan , ravi kumar , sridhar rajagopalan | vldb    |   1999 |

Entity B:
| title                                               | authors                                                                | venue                 |   year |
|:----------------------------------------------------|:-----------------------------------------------------------------------|:----------------------|-------:|
| extracting large-scale knowledge bases from the web | ravi kumar , prabhakar raghavan , sridhar rajagopalan , andrew tomkins | very large data bases |   1999 |



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

Entity B:
| title                                                                           | authors                                      | venue                                          |   year |
|:--------------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| multi-dimensional selectivity estimation using compressed histogram information | ju-hong lee , deok-hwan kim , chin-wan chung | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2009
rtable_id: 205
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 |
|:---------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| re-tree : an efficient index structure for regular expressions | rajeev rastogi , minos n. garofalakis , chee yong chan | vldb    |   2002 |

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: 1658
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 |
|:---------------------------------------------------------------|:-----------------------------------------------------|:--------|-------:|
| quality-driven integration of heterogenous information systems | johann christoph freytag , felix naumann , ulf leser | vldb    |   1999 |

Entity B:
| title                                                   | authors                 | venue             |   year |
|:--------------------------------------------------------|:------------------------|:------------------|-------:|
| semantic interoperability in global information systems | a. m. ouksel , a. sheth | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1011
rtable_id: 118
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 | james r. hamilton , limsoon wong , kenneth a. ross , laks v. s. lakshmanan | sigmod record |   2001 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 968
rtable_id: 650
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 |
|:-----------------------------------------------------------------------|:--------------------------------------------------------|:--------|-------:|
| automated selection of materialized views and indexes in sql databases | surajit chaudhuri , sanjay agrawal , vivek r. narasayya | vldb    |   2000 |

Entity B:
| title                                                                    | authors                                              | venue                                          |   year |
|:-------------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| materialized view and index selection tool for microsoft sql server 2000 | sanjay agrawal , surajit chaudhuri , vivek narasayya | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1538
rtable_id: 280
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 |
|:-----------------------------------------------------------------------------------------|:----------------------------------------|:------------------|-------:|
| counting , enumerating , and sampling of execution plans in a cost-based query optimizer | césar a. galindo-legaria , florian waas | sigmod conference |   2000 |

Entity B:
| title                                                                                    | authors                                     | venue                                          |   year |
|:-----------------------------------------------------------------------------------------|:--------------------------------------------|:-----------------------------------------------|-------:|
| counting , enumerating , and sampling of execution plans in a cost-based query optimizer | florian waas , c &#233; sar galindo-legaria | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1567
rtable_id: 442
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 |
|:------------------------------------------------------------|:--------------------------------|:--------------|-------:|
| research in information managment at dublin city university | alan f. smeaton , mark roantree | sigmod record |   2002 |

Entity B:
| title                                           | authors         | venue                 |   year |
|:------------------------------------------------|:----------------|:----------------------|-------:|
| research directions in biodiversity informatics | john l. schnase | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 57
rtable_id: 859
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 |
|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| surfing wavelets on streams : one-pass summaries for approximate aggregate queries | anna c. gilbert , martin strauss , yannis kotidis , s. muthukrishnan | vldb    |   2001 |

Entity B:
| title                                       | authors                                                                    | venue                 |   year |
|:--------------------------------------------|:---------------------------------------------------------------------------|:----------------------|-------:|
| approximate query processing using wavelets | kaushik chakrabarti , minos n. garofalakis , rajeev rastogi , kyuseok shim | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1512
rtable_id: 889
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 |
|:-------------------------------------------|:---------------------------------------------------------|:------------------|-------:|
| balancing push and pull for data broadcast | swarup acharya , stanley b. zdonik , michael j. franklin | sigmod conference |   1997 |

Entity B:
| title                                | authors                                               | venue                 |   year |
|:-------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| data staging for on-demand broadcast | demet aksoy , michael j. franklin , stanley b. zdonik | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1856
rtable_id: 1283
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 |
|:-----------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| devise : integrated querying and visualization of large datasets | miron livny , raghu ramakrishnan , donko donjerkovic , shilpa lawande , jussi myllymaki , guangshun chen , r. kent wenger , kevin s. beyer | sigmod conference |   1997 |

Entity B:
| title                       | authors        | venue                                          |   year |
|:----------------------------|:---------------|:-----------------------------------------------|-------:|
| databases and visualization | daniel a. keim | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 899
rtable_id: 249
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 |
|:---------------------------------------|:-------------|:--------------|-------:|
| mpeg-7 and multimedia database systems | harald kosch | sigmod record |   2002 |

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: 797
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 |
|:-------------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| index concurrency control in firm real-time database systems | brajesh goyal , s. seshadri , v. srinivasan , jayant r. haritsa | vldb    |   1995 |

Entity B:
| title                                                            | authors                                                                                | venue                 |   year |
|:-----------------------------------------------------------------|:---------------------------------------------------------------------------------------|:----------------------|-------:|
| data manager for evolvable real-time command and control systems | eric hughes , roman ginis , bhavani m. thuraisingham , peter c. krupp , john a. maurer | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 459
rtable_id: 930
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 |
|:----------------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| active storage for large-scale data mining and multimedia | garth a. gibson , erik riedel , christos faloutsos | vldb    |   1998 |

Entity B:
| title                                                           | authors                                                                            | venue                                          |   year |
|:----------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| multimediaminer : a system prototype for multimedia data mining | osmar r. za &#239; ane , jiawei han , ze-nian li , sonny h. chee , jenny y. chiang | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2140
rtable_id: 140
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 and transparent application recovery in client-server information systems | david b. lomet , gerhard weikum | sigmod conference |   1998 |

Entity B:
| title                                                          | authors                 | venue                                                                  |   year |
|:---------------------------------------------------------------|:------------------------|:-----------------------------------------------------------------------|-------:|
| synchronization and recovery in a client-server storage system | e. panagos , a. biliris | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 437
rtable_id: 1152
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 |
|:--------------------------------------------------------------|:---------------------------------------------------------|:--------|-------:|
| multidimensional access methods : trees have grown everywhere | nick roussopoulos , christos faloutsos , timos k. sellis | vldb    |   1997 |

Entity B:
| title                                                            | authors                               | venue                                          |   year |
|:-----------------------------------------------------------------|:--------------------------------------|:-----------------------------------------------|-------:|
| efficient concurrency control in multidimensional access methods | kaushik chakrabarti , sharad mehrotra | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1650
rtable_id: 221
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 |
|:----------------------------------------|:--------------------------------|:--------|-------:|
| memory-contention responsive hash joins | goetz graefe , diane l. davison | vldb    |   1994 |

Entity B:
| title                                   | authors                         | venue                 |   year |
|:----------------------------------------|:--------------------------------|:----------------------|-------:|
| memory-contention responsive hash joins | diane l. davison , goetz graefe | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 426
rtable_id: 1485
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 |
|:-------------------------------------------------------------------|:------------------------------------------------------|:--------|-------:|
| gte superpages : using ir techniques for searching complex objects | steven d. whitehead , himanshu sinha , michael murphy | vldb    |   1997 |

Entity B:
| title                                                              | authors                                               | venue                 |   year |
|:-------------------------------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| gte superpages : using ir techniques for searching complex objects | steven d. whitehead , himanshu sinha , michael murphy | very large data bases |   1997 |



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

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: 1546
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 |
|:----------------------------------------------------|:------------------------------------------------|:--------|-------:|
| using probabilistic information in data integration | alon y. levy , daniela florescu , daphne koller | vldb    |   1997 |

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: 515
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 |
|:-----------------------------------------------|:--------------------------------------------------------------------------------|:--------|-------:|
| functional properties of information filtering | masahiko tsukamoto , shojiro nishio , tsutomu terada , rie sawai , yin-huei loh | vldb    |   2001 |

Entity B:
| title                                          | authors                                                                         | venue                 |   year |
|:-----------------------------------------------|:--------------------------------------------------------------------------------|:----------------------|-------:|
| functional properties of information filtering | rie sawai , masahiko tsukamoto , yin-huei loh , tsutomu terada , shojiro nishio | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2347
rtable_id: 1335
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 |
|:--------------------------------------------|:-----------------------------------------------|:--------------|-------:|
| mining fuzzy association rules in databases | ada wai-chee fu , man hon wong , chan man kuok | sigmod record |   1998 |

Entity B:
| title                                                           | authors                               | venue                 |   year |
|:----------------------------------------------------------------|:--------------------------------------|:----------------------|-------:|
| fast algorithms for mining association rules in large databases | rakesh agrawal , ramakrishnan srikant | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2313
rtable_id: 2207
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 |
|:-------------------------------------------------------------------------------------------|:------------------------------------------------------|:--------|-------:|
| cost-based selection of path expression processing algorithms in object-oriented databases | zhao-hui tang , georges gardarin , jean-robert gruser | vldb    |   1996 |

Entity B:
| title                                                                                         | authors                                                           | venue                                                                  |   year |
|:----------------------------------------------------------------------------------------------|:------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| garbage collection in object-oriented databases using transactional cyclic reference counting | p. roy , s. seshadri , a. silberschatz , s. sudarshan , s. ashwin | the vldb journal -- the international journal on very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3
rtable_id: 1182
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 |
|:----------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:--------|-------:|
| garbage collection in object oriented databases using transactional cyclic reference counting | s. sudarshan , prasan roy , abraham silberschatz , s. seshadri , srinivas ashwin | vldb    |   1997 |

Entity B:
| title                                                                              | authors                                                | venue                 |   year |
|:-----------------------------------------------------------------------------------|:-------------------------------------------------------|:----------------------|-------:|
| efficient incremental garbage collection for client-server object database systems | laurent amsaleg , michael j. franklin , olivier gruber | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2119
rtable_id: 1473
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 | hector garcia-molina , patricia g. selinger , tomasz imielinski , david maier , jeffrey d. ullman , richard t. snodgrass | sigmod record |   1998 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 472
rtable_id: 526
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 |
|:--------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| scalable feature selection , classification and signature generation for organizing large text databases into hierarchical topic taxonomies | prabhakar raghavan , byron dom , rakesh agrawal , soumen chakrabarti | vldb j. |   1998 |

Entity B:
| title                                                                                                                                       | authors                                                              | venue                                                                  |   year |
|:--------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| scalable feature selection , classification and signature generation for organizing large text databases into hierarchical topic taxonomies | soumen chakrabarti , byron dom , rakesh agrawal , prabhakar raghavan | the vldb journal -- the international journal on very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 431
rtable_id: 1181
label: 1