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 |
|:-----------------------|:----------|:------------------|-------:|
| data mining techniques | j han     | sigmod conference |   1996 |

Entity B:
| title                  | authors              | venue   |   year |
|:-----------------------|:---------------------|:--------|-------:|
| data mining techniques | mja berry , g linoff |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1444
rtable_id: 47166
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 |
|:-----------------------------------------------------------|:------------------------|:----------------------------|-------:|
| indexing large metric spaces for similarity search queries | t bozkaya , z жzsoyoglu | acm trans . database syst . |   1999 |

Entity B:
| title                                                             | authors                          | venue                                                    | year   |
|:------------------------------------------------------------------|:---------------------------------|:---------------------------------------------------------|:-------|
| an efficient access method for similarity search in metric spaces | p ciaccia , m patella , p zezula | proceedings of the 23rd international conference on very |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2368
rtable_id: 47172
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 scalable algorithm for answering queries using views | r pottinger , a levy | vldb    |   2000 |

Entity B:
| title                                  | authors                | venue                                                                     | year   |
|:---------------------------------------|:-----------------------|:--------------------------------------------------------------------------|:-------|
| y. sagiv answering queries using views | ay levy , ao mendelzon | proc of the 16th acm sigact sigmod sigart symp on principles & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1212
rtable_id: 38944
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 gmap : a versatile tool for physical data independence | o tsatalos , m solomon , y ioannidis | vldb    |   1994 |

Entity B:
| title                                                      | authors                                 | venue   | year   |
|:-----------------------------------------------------------|:----------------------------------------|:--------|:-------|
| the gmap : a versatile tool for physical data independence | g odysseas , mh solomon , ye ioannidist |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 226
rtable_id: 11556
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 |
|:-------------------------------------------------------------|:----------------------|:------------------|-------:|
| implementation of magic-sets in a relational database system | i mumick , h pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                               | authors                                 | venue                                                                  |   year |
|:--------------------------------------------------------------------|:----------------------------------------|:-----------------------------------------------------------------------|-------:|
| implementing high-level active rules on top of relational databases | e simon , j kiernan , c de maindreville | proceedings of the international conference on very large & hellip ; , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1749
rtable_id: 39926
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 xml views of relational data | j shanmugasundaram , j kiernan , e shekita , c fan , j funderburk | vldb    |   2001 |

Entity B:
| title               | authors                   | venue                                                     | year   |
|:--------------------|:--------------------------|:----------------------------------------------------------|:-------|
| querying video data | r hjelsvold , rm modeling | proceedings of the international conference on very large |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1051
rtable_id: 19527
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 bandwidth model for internet search | a uhl     | vldb    |   2002 |

Entity B:
| title                                 | authors   | venue   |   year |
|:--------------------------------------|:----------|:--------|-------:|
| a bandwidth model for internet search | a uhl     | vldb ,  |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2236
rtable_id: 21750
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 |
|:----------------------------------|:----------|:--------|-------:|
| xquery : a query language for xml |           |         |   2003 |

Entity B:
| title                                                        | authors                               | venue                                                                    |   year |
|:-------------------------------------------------------------|:--------------------------------------|:-------------------------------------------------------------------------|-------:|
| xqbe : a visual environment for learning xml query languages | d braga , a campi , s ceri , a raffio | proceedings of the 2005 acm sigmod international conference & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 406
rtable_id: 34106
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 |
|:------------------------------------------------------------|:-----------|:--------|-------:|
| enhanced abstract data types in object-relational databases | p seshadri | vldb j. |   1998 |

Entity B:
| title                                                          | authors              | venue                                                                     | year   |
|:---------------------------------------------------------------|:---------------------|:--------------------------------------------------------------------------|:-------|
| andr . ramakrishnan . the case forenhanced abstract data types | p seshadri , m livny | inproceedings of the23th vldb conference , athens , greece , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2431
rtable_id: 26331
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 |
|:-------------------------------|:-----------|:--------------|-------:|
| describing semistructured data | l cardelli | sigmod record |   2001 |

Entity B:
| title                                | authors                                              | venue   |   year |
|:-------------------------------------|:-----------------------------------------------------|:--------|-------:|
| a fast index for semistructured data | b cooper , n sample , mj franklin , gr hjaltason , m | vldb ,  |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 204
rtable_id: 15622
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 algorithms for mining association rules in large databases | r agrawal , r srikant | vldb    |   1994 |

Entity B:
| title                                                                           | authors   | venue                                                   | year   |
|:--------------------------------------------------------------------------------|:----------|:--------------------------------------------------------|:-------|
| fuy ( 1995 ) discovery of multiple-level association rules from large databases | j han     | proc . 21st international conference on very large data |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 95
rtable_id: 60370
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 |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| unisql/x unified relational and object-oriented database system | w kim     | sigmod conference |   1994 |

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



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

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

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

Entity A:
| title                                                                                | authors                               | venue   |   year |
|:-------------------------------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| fas - a freshness-sensitive coordination middleware for a cluster of olap components | u rіhm , k bіhm , h schek , h schuldt | vldb    |   2002 |

Entity B:
| title                                                                              | authors                                | venue                                   |   year |
|:-----------------------------------------------------------------------------------|:---------------------------------------|:----------------------------------------|-------:|
| fas-a freshness-sensitive coordination middleware for a cluster of olap components | u rohm , k bohm , hj schek , h schuldt | int . conf . on very large data bases , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2132
rtable_id: 26538
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 |
|:---------------------------------------------------------|:----------------------------------|:--------------|-------:|
| using unknowns to prevent discovery of association rules | y saygin , v verykios , c clifton | sigmod record |   2001 |

Entity B:
| title                                         | authors      | venue                                                                              | year   |
|:----------------------------------------------|:-------------|:-----------------------------------------------------------------------------------|:-------|
| discovery of multiple-level association rules | j han , y fu | zurich , switzerland : in proc . of the 21 ^ stint &#39; l conference & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 211
rtable_id: 34112
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 |
|:-------------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| improved histograms for selectivity estimation of range predicates | v poosala , y ioannidis , p haas , e shekita | sigmod conference |   1996 |

Entity B:
| title                                                                                             | authors   | venue                                                                | year   |
|:--------------------------------------------------------------------------------------------------|:----------|:---------------------------------------------------------------------|:-------|
| ye loannidis , pj haas , and ej shekita . improved histograms for selectivity estimation of range | v poosala | proceedings of the 1996 acm international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1525
rtable_id: 31396
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 |
|:------------------------------------------------------------|:--------------------|:--------|-------:|
| analysis of locking behavior in three real database systems | v singhal , a smith | vldb j. |   1997 |

Entity B:
| title                                                  | authors            | venue           | year   |
|:-------------------------------------------------------|:-------------------|:----------------|:-------|
| empirical data reference behaviour in database systems | j rodriguez-rossel | ieee computer , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2416
rtable_id: 22778
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 |
|:----------------------------------------|:----------|:--------|-------:|
| grid data management systems & services |           |         |   2003 |

Entity B:
| title                                           | authors                      | venue   | year   |
|:------------------------------------------------|:-----------------------------|:--------|:-------|
| temporal support in database management systems | g introduction , p statement |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2185
rtable_id: 16272
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 research at ut arlington | s chakravarthy , y aslandogan , r elmasri , l fegaras , j oh | sigmod record |   2003 |

Entity B:
| title                                      | authors        | venue           |   year |
|:-------------------------------------------|:---------------|:----------------|-------:|
| database research at columbia university . | acms anthology | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1998
rtable_id: 21047
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 of magic-sets in a relational database system | i mumick , h pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                             | authors                           | venue                                                                    |   year |
|:------------------------------------------------------------------|:----------------------------------|:-------------------------------------------------------------------------|-------:|
| xml and relational database management systems : the inside story | m rys , d chamberlin , d florescu | proceedings of the 2005 acm sigmod international conference & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1749
rtable_id: 51481
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 |
|:------------------------------------------------------------------------|:---------------------|:--------|-------:|
| efficiently instantiating view-objects from remote relational databases | b lee , g wiederhold | vldb j. |   1994 |

Entity B:
| title                                                    | authors                                           | venue               | year   |
|:---------------------------------------------------------|:--------------------------------------------------|:--------------------|:-------|
| updating relational databases through object-based views | a keller , t barsalou , n siambela , g wiederhold | proc . acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2561
rtable_id: 19950
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 |
|:----------------------------------|:----------------------|:--------|-------:|
| watermarking relational databases | r agrawal , j kiernan | vldb    |   2002 |

Entity B:
| title                                             | authors             | venue                                                                     | year   |
|:--------------------------------------------------|:--------------------|:--------------------------------------------------------------------------|:-------|
| on an algebra for historical relational databases | j cliord , a tansel | proceedings of the international conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2208
rtable_id: 46920
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 |
|:---------------------------------------------------------------|:---------------------------|:------------------|-------:|
| dynamat : a dynamic view management system for data warehouses | y kotidis , n roussopoulos | sigmod conference |   1999 |

Entity B:
| title                                                      | authors                                 | venue        | year   |
|:-----------------------------------------------------------|:----------------------------------------|:-------------|:-------|
| lore : a database management system for semistructued data | j mchugh , s abiteboul , r goldmanâ ? ¦ | acm sigmod , |        |



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

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

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

Entity A:
| title                                                    | authors   | venue             |   year |
|:---------------------------------------------------------|:----------|:------------------|-------:|
| efficient algorithms for minimizing tree pattern queries | p ramanan | sigmod conference |   2002 |

Entity B:
| title                                                      | authors   | venue   | year   |
|:-----------------------------------------------------------|:----------|:--------|:-------|
| an algorithm for answering queries efficiently using views | p mitra   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 506
rtable_id: 6596
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 |
|:---------------------|:--------------------------------------------------|:------------------|-------:|
| qbi : query by icons | a massari , s pavani , l saladini , p chrysanthis | sigmod conference |   1995 |

Entity B:
| title                                   | authors                                           | venue           | year   |
|:----------------------------------------|:--------------------------------------------------|:----------------|:-------|
| qbic : query by image and video content | m flickner , h sawhney , w niblack , j ashley , q | ieee computer , |        |



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

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

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

Entity A:
| title                        | authors   | venue   |   year |
|:-----------------------------|:----------|:--------|-------:|
| guest editor 's introduction |           |         |   2002 |

Entity B:
| title           | authors     | venue               |   year |
|:----------------|:------------|:--------------------|-------:|
| guest editorial | c allocchio | computer networks , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 7916
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 |
|:--------------------------------------------|:------------------------|:------------------|-------:|
| partial results for online query processing | v raman , j hellerstein | sigmod conference |   2002 |

Entity B:
| title                    | authors                               | venue                                                                          | year   |
|:-------------------------|:--------------------------------------|:-------------------------------------------------------------------------------|:-------|
| sequnce query processing | p seshadri , m livny , r ramakrishnan | proc . of the acm sigmod conf. , pages430441 , minneapolis , mn , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 536
rtable_id: 7374
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 |
|:---------------------------------------------------------------------------|:----------------------|:------------------|-------:|
| d ( k ) - index : an adaptive structural summary for graph-structured data | c qun , a lim , k ong | sigmod conference |   2003 |

Entity B:
| title                                          | authors                     | venue                   | year   |
|:-----------------------------------------------|:----------------------------|:------------------------|:-------|
| statistical synopses for graph-structured data | n polyzotis , m garofalakis | proceedings of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 370
rtable_id: 7797
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 |
|:------------------------------------------|:---------------------------------------------------------|:----------------------------|-------:|
| space optimization in deductive databases | d srivastava , s sudarshan , r ramakrishnan , j naughton | acm trans . database syst . |   1995 |

Entity B:
| title                                             | authors                    | venue   | year   |
|:--------------------------------------------------|:---------------------------|:--------|:-------|
| query optimization in compressed database systems | z chen , j gehrke , f korn |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2256
rtable_id: 12263
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 |
|:-----------------------------------------------------------------------------------------------|:-------------------------|:--------|-------:|
| dynamic load balancing for parallel association rule mining on heterogenous pc cluster systems | m tamura , m kitsuregawa | vldb    |   1999 |

Entity B:
| title                                               | authors                | venue                                                 | year   |
|:----------------------------------------------------|:-----------------------|:------------------------------------------------------|:-------|
| scalable parallel data mining for association rules | h eui-hong , g karypis | ieee transactions on knowledge and data engineering , |        |



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

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

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

Entity A:
| title                        | authors   | venue   |   year |
|:-----------------------------|:----------|:--------|-------:|
| guest editor 's introduction |           |         |   2002 |

Entity B:
| title           | authors   | venue   | year   |
|:----------------|:----------|:--------|:-------|
| guest editorial | lp hunt   |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 58481
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 aditi deductive database system | j vaghani , k ramamohanarao , d kemp , z somogyi , p stuckey , t leask , j harland | vldb j. |   1994 |

Entity B:
| title                                   | authors     | venue                                                       | year   |
|:----------------------------------------|:------------|:------------------------------------------------------------|:-------|
| the o 2 object-oriented database system | f bancilhon | proceedings of the 1992 acm sigmod-international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2554
rtable_id: 41920
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 |
|:----------------------------------------------------------|:----------------------------|:------------------|-------:|
| automatic discovery of language models for text databases | j callan , m connell , a du | sigmod conference |   1999 |

Entity B:
| title                                                   | authors   | venue                                  |   year |
|:--------------------------------------------------------|:----------|:---------------------------------------|-------:|
| implementation of logical query languages for databases | jd ullman | acm transactions on database systems , |   1985 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 936
rtable_id: 40729
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   |
|:------------------------------------------------------------------------------------------|:-------------------|:------------------------------------------------------------|:-------|
| is fast : five optimizations in the design of an experimental database system for cad/cam | m hardwick , r why | proceedings of the 1987 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1826
rtable_id: 27662
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 |
|:------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| rondo : a programming platform for generic model management | s melnik , e rahm , p bernstein | sigmod conference |   2003 |

Entity B:
| title                                               | authors                         | venue                                     | year   |
|:----------------------------------------------------|:--------------------------------|:------------------------------------------|:-------|
| rondo : a programming platform for model management | s melnik , e rahm , p bernstein | proc . acm sigmod , san diego ( ca us ) , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 377
rtable_id: 53827
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 |
|:-------------------------------------------|:------------|:--------------|-------:|
| repositories and object oriented databases | p bernstein | sigmod record |   1998 |

Entity B:
| title                                       | authors   | venue                                                     | year   |
|:--------------------------------------------|:----------|:----------------------------------------------------------|:-------|
| a query model for object-oriented databases | w krm     | proceedings of the international conference on very large |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 632
rtable_id: 9988
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 |
|:-----------------------------------------------|:------------------------|:------------------|-------:|
| s3 : similarity search in cad database systems | s berchtold , h kriegel | sigmod conference |   1997 |

Entity B:
| title                                                                    | authors              | venue                              | year   |
|:-------------------------------------------------------------------------|:---------------------|:-----------------------------------|:-------|
| efficient user-adaptable similarity search in large multimedia databases | s thomas , h kriegel | proc . 23th int . conf . on vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1368
rtable_id: 7806
label: 0