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 |
|:-------------------------------|:------------------------------------------|:--------|-------:|
| an ultra highly available dbms | s hvasshovd , s bratsberg , и torbjјrnsen | vldb    |   2000 |

Entity B:
| title                                                 | authors      | venue   | year   |
|:------------------------------------------------------|:-------------|:--------|:-------|
| tutorial : designing an ultra highly available dbms . | se bratsberg |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1173
rtable_id: 50041
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 |
|:---------------------------------------------|:--------------------|:------------------|-------:|
| optimal multi-step k-nearest neighbor search | t seidl , h kriegel | sigmod conference |   1998 |

Entity B:
| title                                            | authors                 | venue                               |   year |
|:-------------------------------------------------|:------------------------|:------------------------------------|-------:|
| k-nearest neighbor search for moving query point | z song , n roussopoulos | lecture notes in computer science , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1160
rtable_id: 45952
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 |
|:----------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| constructing and integrating data-centric web applications : methods , tools , and techniques |           |         |   2003 |

Entity B:
| title                                                                                         | authors              | venue                                                                  |   year |
|:----------------------------------------------------------------------------------------------|:---------------------|:-----------------------------------------------------------------------|-------:|
| constructing and integrating data-centric web applications : methods , tools , and techniques | s ceri , i manolescu | proceedings of the international conference on very large & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2186
rtable_id: 11257
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 content-based multimedia server for massively parallel architectures | w o'connell , i ieong , d schrader , c watson , g au , a biliris , s choo , p colin , g linderman , e panagos , j wang , t walters | sigmod conference |   1996 |

Entity B:
| title                                                                               | authors                          | venue   | year   |
|:------------------------------------------------------------------------------------|:---------------------------------|:--------|:-------|
| prospector : a content-based multimedia server for massively parallel architectures | , h chen , a biliris , e panagos |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1356
rtable_id: 61063
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 case-based approach to information integration | m panti , l spalazzi , a giretti | vldb    |   2000 |

Entity B:
| title                                      | authors                  | venue                                                                       |   year |
|:-------------------------------------------|:-------------------------|:----------------------------------------------------------------------------|-------:|
| edge-based approach to mesh simplification | k choo , id yun , su lee | 3-d digital imaging and modeling , 1999 . proceedings . second & hellip ; , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1158
rtable_id: 24643
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 |
|:---------------------------------------------------|:----------|:--------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record |   1997 |

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: 562
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 |
|:-------------------------------------|:----------------------|:--------|-------:|
| fast computation of sparse datacubes | k ross , d srivastava | vldb    |   1997 |

Entity B:
| title                             | authors               | venue                                                                 | year   |
|:----------------------------------|:----------------------|:----------------------------------------------------------------------|:-------|
| fast computations of sparse cubes | d srivastava , k ross | proceedings of the 23rd international conference on very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1674
rtable_id: 41629
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 |
|:--------------------------------------------------------|:--------------------------|:--------------|-------:|
| min-max compression methods for medical image databases | k karadimitriou , j tyler | sigmod record |   1997 |

Entity B:
| title                                           | authors                    | venue   | year   |
|:------------------------------------------------|:---------------------------|:--------|:-------|
| similarity searching in medical image databases | egm petrakis , c faloutsos |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 712
rtable_id: 31615
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 |
|:-------------------------------------------------------|:--------------------|:--------------|-------:|
| object database evolution using separation of concerns | a rashid , p sawyer | sigmod record |   2000 |

Entity B:
| title                                                    | authors                     | venue   | year   |
|:---------------------------------------------------------|:----------------------------|:--------|:-------|
| using separation of concerns for embedded systems design | ek jackson , j sztipanovits |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 338
rtable_id: 31826
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 |
|:-----------------------------------------------------------------------------|:-----------------------------------|:----------------------------|-------:|
| an efficient method for checking object-oriented database schema correctness | a formica , h grіger , m missikoff | acm trans . database syst . |   1998 |

Entity B:
| title                                                            | authors   | venue   | year   |
|:-----------------------------------------------------------------|:----------|:--------|:-------|
| a model for schema evolution in object-oriented database systems | s monk    |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2354
rtable_id: 34736
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 |
|:--------------------------------------------|:------------------------------------|:------------------|-------:|
| selectivity estimation in spatial databases | s acharya , v poosala , s ramaswamy | sigmod conference |   1999 |

Entity B:
| title                                         | authors                     | venue                       | year   |
|:----------------------------------------------|:----------------------------|:----------------------------|:-------|
| representing uncertainty in spatial databases | e tã ¸ ssebro , m nygã ¥ rd | submitted for publication , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1023
rtable_id: 41460
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   |
|:-------------------------------------------------|:---------------------|:--------|:-------|
| finding candidate keys for relational data bases | r fadous , j forsyth |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2310
rtable_id: 39536
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 |
|:-------------------------------------------------------------------------------|:---------------------|:------------------|-------:|
| the sr-tree : an index structure for high-dimensional nearest neighbor queries | n katayama , s satoh | sigmod conference |   1997 |

Entity B:
| title                                                                | authors                            | venue                             | year   |
|:---------------------------------------------------------------------|:-----------------------------------|:----------------------------------|:-------|
| the x-tree : an index structure for high-dimensional data . 22 ndint | sd berchtold , d keim , hp kriegel | conf . on very large data bases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1397
rtable_id: 26019
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 |
|:---------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| querying heterogeneous information sources using source descriptions | a levy , a rajaraman , j ordille | vldb    |   1996 |

Entity B:
| title                                                                                | authors    | venue     | year   |
|:-------------------------------------------------------------------------------------|:-----------|:----------|:-------|
| papakonstantinouy . describing and using query capabilities of heterogeneous sources | v vassalos | proc . of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2581
rtable_id: 38215
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 |
|:----------------------------------------------------------------------------------|:-----------------------------------------|:----------------------------|-------:|
| towards a theory of cost management for digital libraries and electronic commerce | a sistla , o wolfson , y yesha , r sloan | acm trans . database syst . |   1998 |

Entity B:
| title                                                     | authors                                   | venue   |   year |
|:----------------------------------------------------------|:------------------------------------------|:--------|-------:|
| towards a theory of cost management for digital libraries | ap sistla , o wolfson , y yesha , r sloan |         |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2367
rtable_id: 22118
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 |
|:--------------------------------------------------------|:------------------------------------|:--------------|-------:|
| advances in databases and information systems ( adbis ) | a caplinskas , j eder , o vasilecas | sigmod record |   2002 |

Entity B:
| title                                    | authors                 | venue           | year   |
|:-----------------------------------------|:------------------------|:----------------|:-------|
| data engineering and information systems | rl shuey , g wiederhold | ieee computer , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 18
rtable_id: 41738
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 |
|:-------------------------------------------|:--------------------------------------------------------------------|:--------|-------:|
| building knowledge base management systems | j mylopoulos , v chaudhri , d plexousakis , a shrufi , t topaloglou | vldb j. |   1996 |

Entity B:
| title                                     | authors   | venue         | year   |
|:------------------------------------------|:----------|:--------------|:-------|
| knowledge management : know what you know | k gile    | pc magazine , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2513
rtable_id: 3126
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   |
|:--------------------------------------------------------|:----------|:----------------------------------------------------------|:-------|
| storage reclamation in object-oriented database systems | mh butler | proceedings of the acm sigmod international conference on |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 45
rtable_id: 63938
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 |
|:-------------------------------------------------------------------------------------|:-------------------------------|:--------|-------:|
| the intrinsic problems of structural heterogeneity and an approach to their solution | t hфrder , g sauter , j thomas | vldb j. |   1999 |

Entity B:
| title                                                                                | authors                           | venue                                                                 |   year |
|:-------------------------------------------------------------------------------------|:----------------------------------|:----------------------------------------------------------------------|-------:|
| the intrinsic problems of structural heterogeneity and an approach to their solution | t hã $ rder , g sauter , j thomas | the vldb journal the international journal on very large & hellip ; , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2378
rtable_id: 38980
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 |
|:-----------------------------------|:-------------------|:------------------|-------:|
| partition based spatial-merge join | j patel , d dewitt | sigmod conference |   1996 |

Entity B:
| title                        | authors              | venue                                                                    |   year |
|:-----------------------------|:---------------------|:-------------------------------------------------------------------------|-------:|
| size separation spatial join | n koudas , kc sevcik | proceedings of the 1997 acm sigmod international conference & hellip ; , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1532
rtable_id: 60672
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 |
|:---------------------------------------------------------|:-------------------------|:------------------|-------:|
| influence sets based on reverse nearest neighbor queries | f korn , s muthukrishnan | sigmod conference |   2000 |

Entity B:
| title                                | authors                                  | venue   | year   |
|:-------------------------------------|:-----------------------------------------|:--------|:-------|
| constrained nearest neighbor queries | h ferhatosmanoglu , i stanoi , d agrawal |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 858
rtable_id: 25095
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 toolkit for negotiation support interfaces to multi-dimensional data | m gebhardt , m jarke , s jacobs | sigmod conference |   1997 |

Entity B:
| title                                              | authors   | venue                                                       | year   |
|:---------------------------------------------------|:----------|:------------------------------------------------------------|:-------|
| tertiary storage support for multidimensional data | b reiner  | vldb supercomputing databases workshop , rome , september , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1336
rtable_id: 32315
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 |
|:-------------------------------------|:-----------------|:--------------|-------:|
| continuous queries over data streams | s babu , j widom | sigmod record |   2001 |

Entity B:
| title                                | authors          | venue           |   year |
|:-------------------------------------|:-----------------|:----------------|-------:|
| continuous queries over data streams | s babu , j widom | sigmod record , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 178
rtable_id: 29784
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 |
|:------------------------------------------------------------|:----------|:--------|-------:|
| towards adaptive workflow systems , cscw-98 workshop report |           |         |   1999 |

Entity B:
| title                             | authors                              | venue   | year   |
|:----------------------------------|:-------------------------------------|:--------|:-------|
| towards adaptive workflow systems | a bernstein , c dellarocas , m klein |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 475
rtable_id: 24530
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 storage hierarchy , database systems and applications - socratic exegesis | f cariёo , w o'connell , j burgess , j saltz | vldb    |   1999 |

Entity B:
| title                                                        | authors                                            | venue   | year   |
|:-------------------------------------------------------------|:---------------------------------------------------|:--------|:-------|
| active object-oriented database systems for cim applications | g kappel , s rausch-schott , w retschitzegger , am |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1497
rtable_id: 38470
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 |
|:-------------------------------------|:----------------------|:--------|-------:|
| mining generalized association rules | r srikant , r agrawal | vldb    |   1995 |

Entity B:
| title                                                          | authors                            | venue                                     | year   |
|:---------------------------------------------------------------|:-----------------------------------|:------------------------------------------|:-------|
| beyond market : generalizing association rules to correlations | s brin , r motwani , c silverstein | processing of the acm sigmod conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 19
rtable_id: 6261
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 |
|:---------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| querying heterogeneous information sources using source descriptions | a levy , a rajaraman , j ordille | vldb    |   1996 |

Entity B:
| title                                                                                       | authors   | venue   | year   |
|:--------------------------------------------------------------------------------------------|:----------|:--------|:-------|
| approximate query translation across heterogeneous information sources ( extended version ) | cck chang |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2581
rtable_id: 42961
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 |
|:--------------------------------------------------|:----------|:------------------|-------:|
| paradise : a database system for gis applications | p team    | sigmod conference |   1995 |

Entity B:
| title                                                                | authors   | venue   | year   |
|:---------------------------------------------------------------------|:----------|:--------|:-------|
| dbcache : a project on database caching support for web applications | c mohan   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1692
rtable_id: 2576
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 |
|:---------------------------------------------------------------|:-----------------|:--------|-------:|
| incremental computation and maintenance of temporal aggregates | j yang , j widom | vldb j. |   2003 |

Entity B:
| title                                              | authors                        | venue   | year   |
|:---------------------------------------------------|:-------------------------------|:--------|:-------|
| incremental maintenance of nested relational views | j liu , mw vincent , m mohania |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2284
rtable_id: 14556
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 |
|:--------------------------------------------------------------------------|:---------------------------------|:------------------|-------:|
| structures for manipulating proposed updates in object-oriented databases | m doherty , r hull , m rupawalla | sigmod conference |   1996 |

Entity B:
| title                              | authors   | venue   | year   |
|:-----------------------------------|:----------|:--------|:-------|
| querying object-oriented databases | m kifer   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1529
rtable_id: 1845
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 |
|:-----------------------|:----------|:------------------|-------:|
| data mining techniques | j han     | sigmod conference |   1996 |

Entity B:
| title       | authors                 | venue   |   year |
|:------------|:------------------------|:--------|-------:|
| data mining | p adriaans , d zantinge |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1444
rtable_id: 4040
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 performance evaluation of oid mapping techniques | a eickler , c gerlhof , d kossmann | vldb    |   1995 |

Entity B:
| title                                                          | authors            | venue   |   year |
|:---------------------------------------------------------------|:-------------------|:--------|-------:|
| a performance evaluation of multi-level transaction management | c hasse , g weikum | vldb ,  |   1991 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1921
rtable_id: 43468
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 |
|:--------------------------------------------------|:------------------------------------------|:--------------|-------:|
| implementation aspects of an object-oriented dbms | a dogac , m altinel , c ozkan , i durusoy | sigmod record |   1995 |

Entity B:
| title                              | authors       | venue   |   year |
|:-----------------------------------|:--------------|:--------|-------:|
| improving object-oriented analysis | g eckertâ ? ¦ |         |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 773
rtable_id: 29870
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 |
|:------------------------------------------------------------|:----------------------------|:--------|-------:|
| an introduction to deductive database languages and systems | k ramamohanarao , j harland | vldb j. |   1994 |

Entity B:
| title                                            | authors   | venue                                                         | year   |
|:-------------------------------------------------|:----------|:--------------------------------------------------------------|:-------|
| an introduction to the unified data language udl | cj date   | proceedings 6th international conference on vldb ( montreal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2565
rtable_id: 55249
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 systems management and oracle8 | c doherty | sigmod conference |   1998 |

Entity B:
| title                                            | authors            | venue                                                                      |   year |
|:-------------------------------------------------|:-------------------|:---------------------------------------------------------------------------|-------:|
| data base management systems security and ingres | d downs , gj popek | very large data bases , 1979 . fifth international conference & hellip ; , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1105
rtable_id: 53356
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 |
|:------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| the design and implementation of a sequence database system | p seshadri , m livny , r ramakrishnan | vldb    |   1996 |

Entity B:
| title                                                               | authors                                             | venue   | year   |
|:--------------------------------------------------------------------|:----------------------------------------------------|:--------|:-------|
| the design and implementation of grid database services in ogsa-dai | m antonioletti , m atkinson , r baxter , a borley , |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1826
rtable_id: 51755
label: 0