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 |
|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | z. meral özsoyoglu , philip s. yu , nick roussopoulos , krithi ramamritham , alberto o. mendelzon , richard t. snodgrass , laura m. haas , jennifer widom , jan paredaens | sigmod record |   1998 |

Entity B:
| title                               | authors         | venue             |   year |
|:------------------------------------|:----------------|:------------------|-------:|
| reminiscences on influential papers | kenneth a. ross | acm sigmod record |   2000 |



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

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

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

Entity A:
| title                                             | authors                                    | venue             |   year |
|:--------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| query optimization in compressed database systems | zhiyuan chen , flip korn , johannes gehrke | sigmod conference |   2001 |

Entity B:
| title                                                     | authors                                             | venue             |   year |
|:----------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| improving timeliness in real-time secure database systems | sang h. son , rasikan david , bhavani thuraisingham | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1892
rtable_id: 378
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 |
|:---------------------------------------------------|:----------------|:--------|-------:|
| user-adaptive exploration of multidimensional data | sunita sarawagi | vldb    |   2000 |

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: 924
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 |
|:------------------------------------------------------------------------------------------|:----------------------------------------------|:--------|-------:|
| unql : a query language and algebra for semistructured data based on structural recursion | mary f. fernandez , peter buneman , dan suciu | vldb j. |   2000 |

Entity B:
| title                                                                                | authors                      | venue                 |   year |
|:-------------------------------------------------------------------------------------|:-----------------------------|:----------------------|-------:|
| dataguides : enabling query formulation and optimization in semistructured databases | roy goldman , jennifer widom | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1968
rtable_id: 952
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 |
|:--------------------------|:----------------------------------------------------------------|:------------------|-------:|
| archiving scientific data | sanjeev khanna , peter buneman , wang chiew tan , keishi tajima | sigmod conference |   2002 |

Entity B:
| title                     | authors                                                         | venue                                          |   year |
|:--------------------------|:----------------------------------------------------------------|:-----------------------------------------------|-------:|
| archiving scientific data | peter buneman , sanjeev khanna , keishi tajima , wang-chiew tan | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1516
rtable_id: 643
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 |
|:--------------------------------------------|:---------------|:------------------|-------:|
| belief reasoning in mls deductive databases | hasan m. jamil | sigmod conference |   1999 |

Entity B:
| title                                             | authors         | venue                                         |   year |
|:--------------------------------------------------|:----------------|:----------------------------------------------|-------:|
| tail recursion elimination in deductive databases | kenneth a. ross | acm transactions on database systems ( tods ) |   1996 |



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

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

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

Entity A:
| title                                        | authors                                        | venue                       |   year |
|:---------------------------------------------|:-----------------------------------------------|:----------------------------|-------:|
| querying atsql databases with temporal logic | jan chomicki , david toman , michael h. böhlen | acm trans . database syst . |   2001 |

Entity B:
| title                            | authors                                                              | venue                 |   year |
|:---------------------------------|:---------------------------------------------------------------------|:----------------------|-------:|
| coalescing in temporal databases | michael h. b &#246; hlen , richard thomas snodgrass , michael d. soo | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1164
rtable_id: 1150
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 |
|:-----------------------------------------------------|:-----------------------------------|:------------------|-------:|
| adaptive selectivity estimation using query feedback | chung-min chen , nick roussopoulos | sigmod conference |   1994 |

Entity B:
| title                                       | authors                                                | venue                                          |   year |
|:--------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------|-------:|
| selectivity estimation in spatial databases | swarup acharya , viswanath poosala , sridhar ramaswamy | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2150
rtable_id: 220
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 case for enhanced abstract data types | raghu ramakrishnan , miron livny , praveen seshadri | vldb    |   1997 |

Entity B:
| title                                     | authors                                             | venue                 |   year |
|:------------------------------------------|:----------------------------------------------------|:----------------------|-------:|
| the case for enhanced abstract data types | praveen seshadri , miron livny , raghu ramakrishnan | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 325
rtable_id: 958
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

Entity A:
| title                                        | authors       | venue   |   year |
|:---------------------------------------------|:--------------|:--------|-------:|
| database management systems and the internet | susan malaika | vldb    |   1996 |

Entity B:
| title                                    | authors                                                                                                                                                                                                 | venue                                          |   year |
|:-----------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| aurora : a data stream management system | d. abadi , d. carney , u. &#199; etintemel , m. cherniack , c. convey , c. erwin , e. galvez , m. hatoun , a. maskey , a. rasin , a. singer , m. stonebraker , n. tatbul , y. xing , r. yan , s. zdonik | international conference on management of data |   2003 |



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

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

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

Entity A:
| title                                                                                       | authors        | venue         |   year |
|:--------------------------------------------------------------------------------------------|:---------------|:--------------|-------:|
| report on the acm fourth international workshop on data warehousing and olap ( dolap 2001 ) | joachim hammer | sigmod record |   2002 |

Entity B:
| title                                                                                                  | authors                                                             | venue             |   year |
|:-------------------------------------------------------------------------------------------------------|:--------------------------------------------------------------------|:------------------|-------:|
| report on the 5th international workshop on the design and management of data warehouses ( dmdw ' 03 ) | hans j. lenz , panos vassiliadis , manfred jeusfeld , martin staudt | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 20
rtable_id: 2210
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 |
|:----------------------------------------------------|:--------------------------------------|:--------|-------:|
| issues in network management in the next millennium | michael l. brodie , surajit chaudhuri | vldb    |   1999 |

Entity B:
| title                            | authors                            | venue             |   year |
|:---------------------------------|:-----------------------------------|:------------------|-------:|
| issues in data stream management | lukasz golab , m. tamer &#214; zsu | acm sigmod record |   2003 |



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

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

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

Entity A:
| title                                              | authors                                                              | venue   |   year |
|:---------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| multi-dimensional substring selectivity estimation | divesh srivastava , olga kapitskaia , raymond t. ng , h. v. jagadish | vldb    |   1999 |

Entity B:
| title                                                                                                                                         | authors           | venue                                          |   year |
|:----------------------------------------------------------------------------------------------------------------------------------------------|:------------------|:-----------------------------------------------|-------:|
| hierarchical subspace sampling : a unified framework for high dimensional data reduction , selectivity estimation and nearest neighbor search | charu c. aggarwal | international conference on management of data |   2002 |



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

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

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

Entity A:
| title                                         | authors         | venue   |   year |
|:----------------------------------------------|:----------------|:--------|-------:|
| query processing in tertiary memory databases | sunita sarawagi | vldb    |   1995 |

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: 674
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 |
|:----------------------------------------------------------------------------|:----------------------------|:--------------|-------:|
| the database and information system research group at the university of ulm | peter dadam , wolfgang klas | sigmod record |   1997 |

Entity B:
| title                                                                     | authors         | venue                 |   year |
|:--------------------------------------------------------------------------|:----------------|:----------------------|-------:|
| the structured information manager : a database system for sgml documents | ron sacks-davis | very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2091
rtable_id: 1123
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 |
|:---------------------------------------------------------|:-------------------------------|:--------|-------:|
| finding intensional knowledge of distance-based outliers | raymond t. ng , edwin m. knorr | vldb    |   1999 |

Entity B:
| title                                                      | authors                         | venue                                          |   year |
|:-----------------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| distance-based indexing for high-dimensional metric spaces | tolga bozkaya , meral ozsoyoglu | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1457
rtable_id: 1836
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 |
|:-------------------------------------------|:-------------------|:------------------|-------:|
| indexing multimedia databases ( tutorial ) | christos faloutsos | sigmod conference |   1995 |

Entity B:
| title                  | authors                            | venue                 |   year |
|:-----------------------|:-----------------------------------|:----------------------|-------:|
| indexing multiple sets | christoph kilger , guido moerkotte | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2524
rtable_id: 2281
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 |
|:----------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| algebraic query optimisation for database programming languages | carol small , alexandra poulovassilis | vldb j. |   1996 |

Entity B:
| title                                         | authors         | venue                                         |   year |
|:----------------------------------------------|:----------------|:----------------------------------------------|-------:|
| safe query languages for constraint databases | peter z. revesz | acm transactions on database systems ( tods ) |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 76
rtable_id: 232
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 |
|:------------------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| mind your vocabulary : query mapping across heterogeneous information sources | kevin chen-chuan chang , hector garcia-molina | sigmod conference |   1999 |

Entity B:
| title                                                                         | authors                                                  | venue                                          |   year |
|:------------------------------------------------------------------------------|:---------------------------------------------------------|:-----------------------------------------------|-------:|
| mind your vocabulary : query mapping across heterogeneous information sources | chen-chuan k. chang , h &#233; ctor garc &#237; a-molina | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2450
rtable_id: 198
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 |
|:-------------------------------------------------------------------|:---------------|:------------------|-------:|
| efficient geometry-based similarity search of 3d spatial databases | daniel a. keim | sigmod conference |   1999 |

Entity B:
| title                                                   | authors                                                                                                      | venue                                          |   year |
|:--------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| fast parallel similarity search in multimedia databases | stefan berchtold , christian b &#246; hm , bernhard braunm &#252; ller , daniel a. keim , hans-peter kriegel | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 5
rtable_id: 1921
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 |
|:-----------------------------|:----------------------------------------------------------|:--------|-------:|
| e-services - guest editorial | dimitrios georgakopoulos , ming-chien shan , fabio casati | vldb j. |   2001 |

Entity B:
| title           | authors        | venue                                                                  |   year |
|:----------------|:---------------|:-----------------------------------------------------------------------|-------:|
| guest editorial | alon y. halevy | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1701
rtable_id: 1239
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 |
|:------------------------------------------------------|:----------------------------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | walid g. aref , ahmed k. elmagarmid , ihab f. ilyas | vldb    |   2003 |

Entity B:
| title                                                | authors                                                                                 | venue                 |   year |
|:-----------------------------------------------------|:----------------------------------------------------------------------------------------|:----------------------|-------:|
| supporting incremental join queries on ranked inputs | apostol natsev , yuan-chi chang , john r. smith , chung-sheng li , jeffrey scott vitter | very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1788
rtable_id: 1350
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 |
|:-------------------------------------------------------------------------|:---------------------------------------------------------|:--------|-------:|
| rp * : a family of order preserving scalable distributed data structures | witold litwin , marie-anne neimat , donovan a. schneider | vldb    |   1994 |

Entity B:
| title                                                                    | authors                                                  | venue                 |   year |
|:-------------------------------------------------------------------------|:---------------------------------------------------------|:----------------------|-------:|
| rp * : a family of order preserving scalable distributed data structures | witold litwin , marie-anne neimat , donovan a. schneider | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1350
rtable_id: 2257
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 |
|:-------------------------------------------------------------|:-----------------------------------------------------|:--------|-------:|
| generic database cost models for hierarchical memory systems | peter a. boncz , martin l. kersten , stefan manegold | vldb    |   2002 |

Entity B:
| title                                         | authors                          | venue             |   year |
|:----------------------------------------------|:---------------------------------|:------------------|-------:|
| a survey of logical models for olap databases | panos vassiliadis , timos sellis | acm sigmod record |   1999 |



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

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

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

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

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



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

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

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

Entity A:
| title                                            | authors                                          | venue   |   year |
|:-------------------------------------------------|:-------------------------------------------------|:--------|-------:|
| a case-based approach to information integration | maurizio panti , alberto giretti , luca spalazzi | vldb    |   2000 |

Entity B:
| title                                                                 | authors                                                        | venue                 |   year |
|:----------------------------------------------------------------------|:---------------------------------------------------------------|:----------------------|-------:|
| model-based information integration in a neuroscience mediator system | bertram lud &#228; scher , amarnath gupta , maryann e. martone | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 890
rtable_id: 1367
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 framework for semantic gossiping | manfred hauswirth , karl aberer , philippe cudré-mauroux | sigmod record |   2002 |

Entity B:
| title                                             | authors                        | venue                                          |   year |
|:--------------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| a framework for implementing hypothetical queries | timothy griffin , richard hull | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1828
rtable_id: 1808
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 |
|:-----------------------------------------------------------------|:-------------------------------|:--------|-------:|
| managing intra-operator parallelism in parallel database systems | david j. dewitt , manish mehta | vldb    |   1995 |

Entity B:
| title                                   | authors                | venue                                          |   year |
|:----------------------------------------|:-----------------------|:-----------------------------------------------|-------:|
| open object database management systems | jos &#233; a. blakeley | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2096
rtable_id: 1675
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 wasa2 object-oriented workflow management system | mathias weske , gottfried vossen | sigmod conference |   1999 |

Entity B:
| title                                                | authors                          | venue                                          |   year |
|:-----------------------------------------------------|:---------------------------------|:-----------------------------------------------|-------:|
| the wasa2 object-oriented workflow management system | gottfried vossen , mathias weske | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2123
rtable_id: 0
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 |
|:--------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------|:--------|-------:|
| relational databases for querying xml documents : limitations and opportunities | jeffrey f. naughton , kristin tufte , chun zhang , gang he , david j. dewitt , jayavel shanmugasundaram | vldb    |   1999 |

Entity B:
| title                                                                        | authors                                                                                                | venue                 |   year |
|:-----------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| xperanto : middleware for publishing object-relational data as xml documents | michael j. carey , jerry kiernan , jayavel shanmugasundaram , eugene j. shekita , subbu n. subramanian | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1187
rtable_id: 1369
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 tuning : principles , experiments , and troubleshooting techniques ( part ii ) | dennis shasha , philippe bonnet | sigmod conference |   2002 |

Entity B:
| title                                                                                   | authors                         | venue                                          |   year |
|:----------------------------------------------------------------------------------------|:--------------------------------|:-----------------------------------------------|-------:|
| database tuning : principles , experiments , and troubleshooting techniques ( part ii ) | dennis shasha , philippe bonnet | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1114
rtable_id: 756
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 |
|:-----------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| efficient incremental garbage collection for client-server object database systems | laurent amsaleg , olivier gruber , michael j. franklin | vldb    |   1995 |

Entity B:
| title                                                                                  | authors                                                                    | venue                                          |   year |
|:---------------------------------------------------------------------------------------|:---------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| semi-automatic , self-adaptive control of garbage collection rates in object databases | jonathan e. cook , artur w. klauser , alexander l. wolf , benjamin g. zorn | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1285
rtable_id: 1987
label: 0