MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j chaudhary , g karvelis , s sou | sigmod conference |   1994 |

Entity B:
| title              | authors    | venue   | year   |
|:-------------------|:-----------|:--------|:-------|
| temporal databases | j chomicki |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1840
rtable_id: 56771
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |           |         |   2003 |

Entity B:
| title                                 | authors        | venue   |   year |
|:--------------------------------------|:---------------|:--------|-------:|
| reminiscences on influential papers . | acms anthology | sigmod  |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1864
rtable_id: 39339
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:----------------------------------------------------------------------------------|:-------------------------------------------------|:--------|-------:|
| storage estimation for multidimensional aggregates in the presence of hierarchies | a shukla , p deshpande , j naughton , k ramasamy | vldb    |   1996 |

Entity B:
| title                                           | authors                           | venue   | year   |
|:------------------------------------------------|:----------------------------------|:--------|:-------|
| set-derivability of multidimensional aggregates | j albrecht , h guenzel , w lehner |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2611
rtable_id: 35409
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| closest pair queries in spatial databases | a corral , y manolopoulos , y theodoridis , m vassilakopoulos | sigmod conference |   2000 |

Entity B:
| title                                         | authors                                   | venue   |   year |
|:----------------------------------------------|:------------------------------------------|:--------|-------:|
| query processing in spatial network databases | d papadias , j zhang , n mamoulis , y tao | vldb ,  |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 787
rtable_id: 48578
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-----------------------------------------------------|:--------------------------------------|:------------------|-------:|
| concurrency and recovery in generalized search trees | m kornacker , c mohan , j hellerstein | sigmod conference |   1997 |

Entity B:
| title                                    | authors                               | venue                                                  | year   |
|:-----------------------------------------|:--------------------------------------|:-------------------------------------------------------|:-------|
| concurrency control and recovery in gist | m kornacker , c mohan , j hellerstein | proc . acm sigmod int . conf . on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1240
rtable_id: 34514
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 taxonomy for secure object-oriented databases | m olivier , s solms | acm trans . database syst . |   1994 |

Entity B:
| title                                                       | authors                          | venue   | year   |
|:------------------------------------------------------------|:---------------------------------|:--------|:-------|
| pointer-based join techniques for object-oriented databases | df lieuwen , dj dewitt , m mehta |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2300
rtable_id: 32963
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------------------------------|:-----------------------|:--------|-------:|
| accessing a relational database through an object-oriented database interface | j orenstein , d kamber | vldb    |   1995 |

Entity B:
| title                                              | authors   | venue           |   year |
|:---------------------------------------------------|:----------|:----------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 45
rtable_id: 1043
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title           | authors   | venue         |   year |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | j widom   | sigmod record |   1996 |

Entity B:
| title           | authors                        | venue                                      | year   |
|:----------------|:-------------------------------|:-------------------------------------------|:-------|
| editors ' notes | n van note chism , dj bickford | new directions for teaching and learning , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 767
rtable_id: 50551
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------------|:-----------------|:--------|-------:|
| benchmarking spatial join operations with spatial output | e hoel , h samet | vldb    |   1995 |

Entity B:
| title                                   | authors                           | venue                                             | year   |
|:----------------------------------------|:----------------------------------|:--------------------------------------------------|:-------|
| benchmarking simple database operations | d bitton , d dewitt , c turbyfill | proc . 9th int . conf . on very large databases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 39
rtable_id: 48392
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                                       | authors                                                | venue         |   year |
|:------------------------------------------------------------|:-------------------------------------------------------|:--------------|-------:|
| lore : a database management system for semistructured data | j mchugh , s abiteboul , r goldman , d quass , j widom | sigmod record |   1997 |

Entity B:
| title                                                    | authors                                            | venue                                                                  |   year |
|:---------------------------------------------------------|:---------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| an annotation management system for relational databases | d bhagwat , l chiticariu , wc tan , g vijayvargiya | proceedings of the international conference on very large & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 570
rtable_id: 55822
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-------------------------------------------------------|:------------------------------|:----------------------------|-------:|
| formal query languages for secure relational databases | m winslett , k smith , x qian | acm trans . database syst . |   1994 |

Entity B:
| title                                                  | authors                       | venue                                  |   year |
|:-------------------------------------------------------|:------------------------------|:---------------------------------------|-------:|
| formal query languages for secure relational databases | m winslett , k smith , x qian | acm transactions on database systems , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2310
rtable_id: 53793
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-----------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| determining text databases to search in the internet | w meng , k liu , c yu , x wang , y chang , n rishe | vldb    |   1998 |

Entity B:
| title                          | authors   | venue           | year   |
|:-------------------------------|:----------|:----------------|:-------|
| global warming to the internet | e horwitt | computerworld , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1620
rtable_id: 12133
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------|:------------------|-------:|
| dbcache : middle-tier database caching for highly scalable e-business architectures | c bornhіvd , m altinel , s krishnamurthy , c mohan , h pirahesh , b reinwald | sigmod conference |   2003 |

Entity B:
| title                                                                     | authors            | venue                                                                 |   year |
|:--------------------------------------------------------------------------|:-------------------|:----------------------------------------------------------------------|-------:|
| a predicate-based caching scheme for client-server database architectures | am keller , j basu | the vldb journal the international journal on very large & hellip ; , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 299
rtable_id: 1509
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-----------------------------------------------------|:-------------------------------|:--------|-------:|
| fast image retrieval using color-spatial information | b ooi , k tan , t chua , w hsu | vldb j. |   1998 |

Entity B:
| title                                               | authors            | venue   | year   |
|:----------------------------------------------------|:-------------------|:--------|:-------|
| musical information retrieval using melodic surface | m melucci , n orio |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2425
rtable_id: 43312
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| distributed deviation detection in sensor networks | t palpanas , d papadopoulos , v kalogeraki , d gunopulos | sigmod record |   2003 |

Entity B:
| title                                                 | authors                                      | venue                                                                    |   year |
|:------------------------------------------------------|:---------------------------------------------|:-------------------------------------------------------------------------|-------:|
| compressing historical information in sensor networks | a deligiannakis , y kotidis , n roussopoulos | proceedings of the 2004 acm sigmod international conference & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1875
rtable_id: 15443
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:--------------------------------------------------------|:-------------------------------|:--------|-------:|
| fibonacci : a programming language for object databases | a albano , g ghelli , r orsini | vldb j. |   1995 |

Entity B:
| title                            | authors      | venue   |   year |
|:---------------------------------|:-------------|:--------|-------:|
| history of programming languages | rl wexelblat |         |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2521
rtable_id: 6141
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 fast index for semistructured data | b cooper , n sample , m franklin , g hjaltason , m shadmon | vldb    |   2001 |

Entity B:
| title                                      | authors    | venue               |   year |
|:-------------------------------------------|:-----------|:--------------------|-------:|
| extracting schema from semistructured data | s nestorov | sigmod conference , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1146
rtable_id: 9099
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:----------------|:----------|:--------|-------:|
| guest editorial |           |         |   2003 |

Entity B:
| title     | authors   | venue                   |   year |
|:----------|:----------|:------------------------|-------:|
| editorial | p willis  | bt technology journal , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2295
rtable_id: 1839
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:----------------------------|:--------------------|:--------------|-------:|
| metadata in video databases | r jain , a hampapur | sigmod record |   1994 |

Entity B:
| title              | authors                                         | venue   | year   |
|:-------------------|:------------------------------------------------|:--------|:-------|
| data and databases | c databases , d warehouses , ae technology , ip |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 805
rtable_id: 33175
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 | a poulovassilis , c small | vldb j. |   1996 |

Entity B:
| title                                                 | authors    | venue   |   year |
|:------------------------------------------------------|:-----------|:--------|-------:|
| the denotational description of programming languages | mjc gordon |         |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2505
rtable_id: 52137
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:--------------------------------------------------------|:----------------------------------------------------------------|:--------|-------:|
| fast nearest neighbor search in medical image databases | f korn , n sidiropoulos , c faloutsos , e siegel , z protopapas | vldb    |   1996 |

Entity B:
| title                                         | authors   | venue                                            | year   |
|:----------------------------------------------|:----------|:-------------------------------------------------|:-------|
| near neighbour search in very large databases | s brin    | 21st international conference on very large data |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1807
rtable_id: 46421
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 buffer size investigation for oltp workloads ( experience paper ) | t tsuei , a packer , k ko | sigmod conference |   1997 |

Entity B:
| title                                                 | authors                      | venue                                                                    |   year |
|:------------------------------------------------------|:-----------------------------|:-------------------------------------------------------------------------|-------:|
| database buffer size investigation for oltp workloads | tf tsuei , an packer , kt ko | proceedings of the 1997 acm sigmod international conference & hellip ; , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1306
rtable_id: 33390
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:--------------------------------------------|:----------|:----------------------------|-------:|
| declarative updates of relational databases | w chen    | acm trans . database syst . |   1995 |

Entity B:
| title                                     | authors           | venue                                                                            | year   |
|:------------------------------------------|:------------------|:---------------------------------------------------------------------------------|:-------|
| random sampling from relational databases | f olken , d rotem | proc . vldb &#39; 86 twelfth international conference on very large & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2249
rtable_id: 10812
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-------------------------------------------------------------|:----------------------------------------------------------------|:--------------|-------:|
| dbglobe : a service-oriented p2p system for global computing | e pitoura , s abiteboul , d pfoser , g samaras , m vazirgiannis | sigmod record |   2003 |

Entity B:
| title                                                        | authors        | venue           |   year |
|:-------------------------------------------------------------|:---------------|:----------------|-------:|
| dbglobe : a service-oriented p2p system for global computing | e pitouraâ ? ¦ | sigmod record , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1888
rtable_id: 40666
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| static detection of security flaws in object-oriented databases | k tajima  | sigmod conference |   1996 |

Entity B:
| title                                             | authors    | venue   | year   |
|:--------------------------------------------------|:-----------|:--------|:-------|
| a logical semantics for object-oriented databases | j meseguer |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1518
rtable_id: 42022
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 schemes for managing multiversionxml documents | s chien , v tsotras , c zaniolo | vldb j. |   2002 |

Entity B:
| title                                                                | authors                           | venue                                                                  |   year |
|:---------------------------------------------------------------------|:----------------------------------|:-----------------------------------------------------------------------|-------:|
| efficient management of multiversion documents by object referencing | sy chien , vj tsotras , c zaniolo | proceedings of the international conference on very large & hellip ; , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2463
rtable_id: 20985
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------------------|:--------------------------------|:--------|-------:|
| capturing and querying multiple aspects of semistructured data | c dyreson , m bіhlen , c jensen | vldb    |   1999 |

Entity B:
| title                                                             | authors          | venue                                                                     |   year |
|:------------------------------------------------------------------|:-----------------|:--------------------------------------------------------------------------|-------:|
| a fast and versatile path index for querying semi-structured data | m barg , rk wong | database systems for advanced applications , 2003 . ( dasfaa & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1519
rtable_id: 30833
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:-----------------------------------------------------------------------|:----------|:--------|-------:|
| design and implementation of a genetic-based algorithm for data mining | s choenni | vldb    |   2000 |

Entity B:
| title                                                      | authors                          | venue                                                                    |   year |
|:-----------------------------------------------------------|:---------------------------------|:-------------------------------------------------------------------------|-------:|
| design and implementation of the glue-nail database system | ma derr , s morishita , g phipps | proceedings of the 1993 acm sigmod international conference & hellip ; , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1185
rtable_id: 57193
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 system for watermarking relational databases | r agrawal , p haas , j kiernan | sigmod conference |   2003 |

Entity B:
| title                         | authors                                      | venue                                                                   | year   |
|:------------------------------|:---------------------------------------------|:------------------------------------------------------------------------|:-------|
| java and relational databases | g clossman , p shaw , m hapner , j klein , r | proceedings of 1998 acm sigmod conference on management of & hellip ; , |        |



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

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 foundation for representing and quering moving objects | r gќting , m bіhlen , m erwig , c jensen , n lorentzos , m schneider , m vazirgiannis | acm trans . database syst . |   2000 |

Entity B:
| title                                                                  | authors                                                  | venue                        | year   |
|:-----------------------------------------------------------------------|:---------------------------------------------------------|:-----------------------------|:-------|
| ba foundation for representing and querying moving objects , â ?? â ?? | rh gã 1/4 ting , mh bã ¶ hlen , m erwig , cs jensen , na | acm transactions on database |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2317
rtable_id: 44825
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| rondo : a programming platform for generic model management | s melnik , e rahm , p bernstein | sigmod conference |   2003 |

Entity B:
| title                                                                            | authors                          | venue                                                                  | year   |
|:---------------------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|:-------|
| rondo : a programming platform for generic model management ( extended version ) | s melnik , e rahm , pa bernstein | technical report , leipzig university , 2003 . available at http : / / |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 377
rtable_id: 27297
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 views for electronic commerce | s abiteboul , b amann , s cluet , a eyal , l mignet , t milo | vldb    |   1999 |

Entity B:
| title                              | authors       | venue   | year   |
|:-----------------------------------|:--------------|:--------|:-------|
| ontologies for electronic commerce | dl mcguinness |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1531
rtable_id: 32794
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------------------------------------|:--------------------|:--------------|-------:|
| power efficient data gathering and aggregation in wireless sensor networks | h tan , i korpeoglu | sigmod record |   2003 |

Entity B:
| title                                                                             | authors              | venue   | year   |
|:----------------------------------------------------------------------------------|:---------------------|:--------|:-------|
| in-network aggregation trade-offs for data collection in wireless sensor networks | i solis , k obraczka |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1856
rtable_id: 43531
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:------------------------------------|:----------------------------------------------|:------------------|-------:|
| computing capabilities of mediators | r yerneni , c li , h garcia-molina , j ullman | sigmod conference |   1999 |

Entity B:
| title                                                                | authors                                       | venue                             | year   |
|:---------------------------------------------------------------------|:----------------------------------------------|:----------------------------------|:-------|
| computing capabilities of mediators extended version . http : www-db | r yerneni , c li , h garcia-molina , j ullman | stanford . edu pubpapersmedtemp . |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 928
rtable_id: 55527
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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 |
|:---------------------------------------------|:--------------|:------------------|-------:|
| gea : a toolkit for gene expression analysis | j phan , r ng | sigmod conference |   2002 |

Entity B:
| title                         | authors               | venue   | year   |
|:------------------------------|:----------------------|:--------|:-------|
| gene expression data analysis | eb analysis , r sites |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 459
rtable_id: 4062
label: 0