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

Entity B:
| title                                           | authors                 | venue      | year   |
|:------------------------------------------------|:------------------------|:-----------|:-------|
| a taxonomy for object-oriented secure databases | m olivier , s von solms | acm tods , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2300
rtable_id: 19278
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 |
|:--------------------------------------------------|:---------------------------------|:--------|-------:|
| discover : keyword search in relational databases | v hristidis , y papakonstantinou | vldb    |   2002 |

Entity B:
| title                                                 | authors    | venue   | year   |
|:------------------------------------------------------|:-----------|:--------|:-------|
| temporal inegrity constraints in relational databases | j chomicki |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2125
rtable_id: 23788
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 |
|:---------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| disima : a distributed and interoperable image database system | v oria , m жzsu , p iglinski , s lin , b yao | sigmod conference |   2000 |

Entity B:
| title                                              | authors                               | venue          | year   |
|:---------------------------------------------------|:--------------------------------------|:---------------|:-------|
| mariposa : a wide-area distributed database system | z qin , w wang , f wu , t lo , p aoki | vldb journal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 807
rtable_id: 52741
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 |
|:--------------------------------------------------------|:-------------------|:------------------|-------:|
| time-parameterized queries in spatio-temporal databases | y tao , d papadias | sigmod conference |   2002 |

Entity B:
| title                                               | authors                        | venue                         | year   |
|:----------------------------------------------------|:-------------------------------|:------------------------------|:-------|
| estimation of count queries in relational databases | wc hou , g ozsoyoglu , e dogdu | acm sigmod conference , may , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 537
rtable_id: 49918
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 |
|:-----------------------------------------------------------|:----------------------------|:------------------|-------:|
| multi-dimensional resource scheduling for parallel queries | m garofalakis , y ioannidis | sigmod conference |   1996 |

Entity B:
| title                                                | authors                                  | venue                                                                  |   year |
|:-----------------------------------------------------|:-----------------------------------------|:-----------------------------------------------------------------------|-------:|
| resource scheduling for composite multimedia objects | mn garofalakis , ye ioannidis , b oezden | proceedings of the international conference on very large & hellip ; , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1520
rtable_id: 50828
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 glue-nail deductive database system : design , implementation , and evaluation | m derr , s morishita , g phipps | vldb j. |   1994 |

Entity B:
| title                                                                                          | authors                                                 | venue                                                  | year   |
|:-----------------------------------------------------------------------------------------------|:--------------------------------------------------------|:-------------------------------------------------------|:-------|
| building a scalable geo-spatial database system : technology , implementation , and evaluation | j patel , j yu , n kabra , k tufte , b nag , j burger , | proc . acm sigmod int . conf . on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2552
rtable_id: 14213
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 |
|:---------------------------------------------------|:----------|:--------|-------:|
| information retrieval from an incomplete data cube | c dyreson | vldb    |   1996 |

Entity B:
| title                                          | authors                   | venue    | year   |
|:-----------------------------------------------|:--------------------------|:---------|:-------|
| incomplete information in relational databases | t imieliã?nski , w lipski | j. acm , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2609
rtable_id: 16392
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 logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                                | authors            | venue                          |   year |
|:-----------------------------------------------------|:-------------------|:-------------------------------|-------:|
| schema evolution in object-oriented database systems | gt nguyen , d rieu | data & knowledge engineering , |   1989 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 22975
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 ultra highly available dbms | s hvasshovd , s bratsberg , и torbjјrnsen | vldb    |   2000 |

Entity B:
| title                                    | authors                     | venue                                                     | year   |
|:-----------------------------------------|:----------------------------|:----------------------------------------------------------|:-------|
| designing an ultra highly available dbms | o torbjornsen , s bratsberg | proceedings of acmsigmod conference , dallas , tx , may , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1173
rtable_id: 10603
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 |           |         |   1997 |

Entity B:
| title           | authors     | venue                                   | year   |
|:----------------|:------------|:----------------------------------------|:-------|
| editor 's notes | wmk trochim | new directions for program evaluation , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 568
rtable_id: 31216
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 |
|:------------------------------------------------|:------------|:--------------|-------:|
| advances in real-time database systems research | a bestavros | sigmod record |   1996 |

Entity B:
| title                                                   | authors   | venue           |   year |
|:--------------------------------------------------------|:----------|:----------------|-------:|
| an annotated bibliography on real-time database systems | o ulusoy  | sigmod record , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 667
rtable_id: 26191
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 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 | woâ ?? connell , it ieong , d schrader , c watson , g au | proceedingsof the 1996 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1356
rtable_id: 19813
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 logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                                           | authors                              | venue                                                   | year   |
|:----------------------------------------------------------------|:-------------------------------------|:--------------------------------------------------------|:-------|
| a new perspective on rule support for object-oriented databases | ea cm941 , l maugis , s chakravarthy | proceedings , international conference on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 28460
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 |
|:-------------------------------------------------------|:----------------------------|:------------------|-------:|
| using the golden rule of sampling for query estimation | y wu , d agrawal , a abbadi | sigmod conference |   2001 |

Entity B:
| title                                                           | authors                        | venue                                      | year   |
|:----------------------------------------------------------------|:-------------------------------|:-------------------------------------------|:-------|
| applying the golden rule of sampling for selectivity estimation | y wu , d agrawal , a el abbadi | proceedings of the acm sigmod conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 748
rtable_id: 37261
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 |
|:-----------------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| an efficient algorithm for mining association rules in large databases | a savasere , e omiecinski , s navathe | vldb    |   1995 |

Entity B:
| title                                                          | authors               | venue                                                        | year   |
|:---------------------------------------------------------------|:----------------------|:-------------------------------------------------------------|:-------|
| mining quantitative association rules in large relation tables | r sirkant , r agrawal | proceedings of acm sigmod conference of management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 11770
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 effective deductive object-oriented database through language integration | m barja , n paton , a fernandes , m williams , a dinn | vldb    |   1994 |

Entity B:
| title                                                            | authors                      | venue                                                                    | year   |
|:-----------------------------------------------------------------|:-----------------------------|:-------------------------------------------------------------------------|:-------|
| a query language for manipulating object-oriented databases , '' | am alashqur , syw su , h lam | proceedings of the fifth international conference on vldb , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 90
rtable_id: 18082
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 |
|:------------------------------------------------------------------------|:----------|:--------|-------:|
| covering indexes for xml queries : bisimulation - simulation = negation | p ramanan | vldb    |   2003 |

Entity B:
| title                                                                 | authors   | venue                                                                  |   year |
|:----------------------------------------------------------------------|:----------|:-----------------------------------------------------------------------|-------:|
| covering indexes for xml queries : bisimulation-simulation = negation | p ramanan | proceedings of the international conference on very large & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2087
rtable_id: 44956
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 |
|:----------------------------------------------------|:----------------------------|:------------------|-------:|
| scalable parallel data mining for association rules | e han , g karypis , v kumar | sigmod conference |   1997 |

Entity B:
| title                                               | authors     | venue               |   year |
|:----------------------------------------------------|:------------|:--------------------|-------:|
| scalable parallel data mining for association rules | eh hanâ ? ¦ | sigmod conference , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1288
rtable_id: 7065
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 |
|:-------------------------------------------------------------------|:-------------|:--------|-------:|
| efficient and effective clustering methods for spatial data mining | r ng , j han | vldb    |   1994 |

Entity B:
| title                                                               | authors                            | venue                                                                       | year   |
|:--------------------------------------------------------------------|:-----------------------------------|:----------------------------------------------------------------------------|:-------|
| birch : an efficient data clustering methodfor very large databases | t zhang , r ramakrishnan , m livny | proc . acm sigmod intl. conf . on managementof data , pages103 & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 72
rtable_id: 63302
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 |
|:---------------------------|:-------------------|:--------|-------:|
| query optimization for xml | j mchugh , j widom | vldb    |   1999 |

Entity B:
| title                                                    | authors                                         | venue   |   year |
|:---------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| the optimization strategy for query evaluation in rdb/v1 | a makinouchi , m tezuka , h kitakami , s adachi | vldb ,  |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1431
rtable_id: 25494
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 |
|:--------------------------------------------------|:-------------------------|:------------------|-------:|
| bottom-up computation of sparse and iceberg cubes | k beyer , r ramakrishnan | sigmod conference |   1999 |

Entity B:
| title                                                              | authors   | venue   |   year |
|:-------------------------------------------------------------------|:----------|:--------|-------:|
| experiments with bottom-up computation of sparse and iceberg cubes | s greve   |         |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 937
rtable_id: 5595
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   |
|:--------------------------------------------------|:-----------------|:--------------------------------------------------------------|:-------|
| an efficient indexing method for partitioned data | d choy , c mohan | ibm research report , ibm almaden research center , january , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2354
rtable_id: 35798
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 semantic web : semantics for data on the web |           |         |   2003 |

Entity B:
| title                                        | authors   | venue               | year   |
|:---------------------------------------------|:----------|:--------------------|:-------|
| cream-creating metadata for the semantic web | shs staab | computer networks , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2049
rtable_id: 1950
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 |
|:--------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| ofl : a functional execution model for object query languages | g gardarin , f machuca , p pucheral | sigmod conference |   1995 |

Entity B:
| title                                                    | authors             | venue               |   year |
|:---------------------------------------------------------|:--------------------|:--------------------|-------:|
| towards an effective calculus for object query languages | l fegaras , d maier | sigmod conference , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1593
rtable_id: 50779
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 |
|:-------------------------------------------|:--------------------------|:--------|-------:|
| groupwise processing of relational queries | d chatziantoniou , k ross | vldb    |   1997 |

Entity B:
| title                                                                               | authors    | venue   |   year |
|:------------------------------------------------------------------------------------|:-----------|:--------|-------:|
| efficient processing of interactive relational data base queries expressed in logic | dhd warren | vldb ,  |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1701
rtable_id: 17611
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 maintenance for non-distributive aggregate functions | t palpanas , r sidle , r cochrane , h pirahesh | vldb    |   2002 |

Entity B:
| title                                                            | authors                                        | venue   |   year |
|:-----------------------------------------------------------------|:-----------------------------------------------|:--------|-------:|
| incremental maintenance for non-distributive aggregate functions | t palpanas , r sidle , r cochrane , h pirahesh | vldb ,  |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2128
rtable_id: 63486
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 |
|:-------------------------------------|:----------------------------------|:--------|-------:|
| on the minimization of xpath queries | s flesca , f furfaro , e masciari | vldb    |   2003 |

Entity B:
| title                                | authors    | venue   | year   |
|:-------------------------------------|:-----------|:--------|:-------|
| on the minimization of xpath queries | s bottcher |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2086
rtable_id: 16106
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 |
|:-------------------------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| declare and sds : early efforts to commercialize deductive database technology | w kieпling , h schmidt , w strauп , g dќnzinger | vldb j. |   1994 |

Entity B:
| title                                 | authors     | venue   |   year |
|:--------------------------------------|:------------|:--------|-------:|
| commercial use of database technology | h schoening | vldb ,  |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2566
rtable_id: 55313
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 |
|:-----------------------------------------------------------------------------------|:----------|:--------|-------:|
| query decomposition and view maintenance for query languages for unstructured data | d suciu   | vldb    |   1996 |

Entity B:
| title                                                                 | authors                               | venue                                                                     | year   |
|:----------------------------------------------------------------------|:--------------------------------------|:--------------------------------------------------------------------------|:-------|
| a querying language and optimization techniques for unstructured data | p buneman , s davidson , g hillebrand | proceedings of acm sigmod conference on management of data , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2577
rtable_id: 51241
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 management for earth system science | j frew , j dozier | sigmod record |   1997 |

Entity B:
| title                      | authors                          | venue           | year   |
|:---------------------------|:---------------------------------|:----------------|:-------|
| scientific data management | jc french , ak jones , jl pfaltz | sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 574
rtable_id: 51653
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 logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                           | authors   | venue   | year   |
|:------------------------------------------------|:----------|:--------|:-------|
| the notion of active ob ject-oriented databases | s reich   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 22295
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 | m franklin | sigmod record |   2000 |

Entity B:
| title           | authors            | venue                                 | year   |
|:----------------|:-------------------|:--------------------------------------|:-------|
| editors ' notes | pj gray , tw banta | new directions for higher education , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 353
rtable_id: 29979
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 |
|:----------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| micronet : a microcomputer network system for managing distributed relational databases | syw su , s lupkiewicz , c lee | vldb ,  |   1978 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 54322
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 |
|:--------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| supply chain infrastructures : system integration and information sharing | m ball , m ma , l raschid , z zhao | sigmod record |   2002 |

Entity B:
| title                                          | authors   | venue   |   year |
|:-----------------------------------------------|:----------|:--------|-------:|
| architecture of integrated information systems | aw scheer |         |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 240
rtable_id: 32713
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 |
|:-------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| optimizing the secure evaluation of twig queries | s cho , s amer-yahia , l lakshmanan , d srivastava | vldb    |   2002 |

Entity B:
| title                           | authors                               | venue                                                         | year   |
|:--------------------------------|:--------------------------------------|:--------------------------------------------------------------|:-------|
| optimizing nonrecursive queries | r krishnamurthy , h boral , c zaniolo | proc 1986 international conference on very large data bases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2232
rtable_id: 38075
label: 0