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

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

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

Entity A:
| title                                               | authors   | venue                       |   year |
|:----------------------------------------------------|:----------|:----------------------------|-------:|
| distributed query evaluation on semistructured data | dan suciu | acm trans . database syst . |   2002 |

Entity B:
| title                                | authors                                                                               | venue                 |   year |
|:-------------------------------------|:--------------------------------------------------------------------------------------|:----------------------|-------:|
| a fast index for semistructured data | brian cooper , neal sample , michael j. franklin , gisli r. hjaltason , moshe shadmon | very large data bases |   2001 |



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

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

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

Entity A:
| title                               | authors        | venue             |   year |
|:------------------------------------|:---------------|:------------------|-------:|
| anatomy of a real e-commerce system | anant jhingran | sigmod conference |   2000 |

Entity B:
| title                               | authors        | venue                                          |   year |
|:------------------------------------|:---------------|:-----------------------------------------------|-------:|
| anatomy of a real e-commerce system | anant jhingran | international conference on management of data |   2000 |



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

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

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

Entity A:
| title                                                              | authors                                                                     | venue             |   year |
|:-------------------------------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| improved histograms for selectivity estimation of range predicates | eugene j. shekita , viswanath poosala , yannis e. ioannidis , peter j. haas | sigmod conference |   1996 |

Entity B:
| title                                                              | authors                                                                     | venue                                          |   year |
|:-------------------------------------------------------------------|:----------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| improved histograms for selectivity estimation of range predicates | viswanath poosala , peter j. haas , yannis e. ioannidis , eugene j. shekita | international conference on management of data |   1996 |



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

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

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

Entity A:
| title                                              | authors            | venue             |   year |
|:---------------------------------------------------|:-------------------|:------------------|-------:|
| extracting and exploiting structure in text search | prabhakar raghavan | sigmod conference |   2003 |

Entity B:
| title                                                | authors                               | venue             |   year |
|:-----------------------------------------------------|:--------------------------------------|:------------------|-------:|
| integrating contents and structure in text retrieval | ricardo baeza-yates , gonzalo navarro | acm sigmod record |   1996 |



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

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

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

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

Entity B:
| title                                                                                                            | authors      | venue             |   year |
|:-----------------------------------------------------------------------------------------------------------------|:-------------|:------------------|-------:|
| report on ngits ' 99 : the fourth international workshop on next generation information technologies and systems | opher etzion | acm sigmod record |   1999 |



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

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

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

Entity A:
| title                                          | authors        | venue   |   year |
|:-----------------------------------------------|:---------------|:--------|-------:|
| sampling large databases for association rules | hannu toivonen | vldb    |   1996 |

Entity B:
| title                                      | authors        | venue                 |   year |
|:-------------------------------------------|:---------------|:----------------------|-------:|
| large databases for remote sensing and gis | a. r. dasgupta | very large data bases |   1996 |



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

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

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

Entity A:
| title                                                            | authors                                               | venue   |   year |
|:-----------------------------------------------------------------|:------------------------------------------------------|:--------|-------:|
| implementing lazy database updates for an object database system | fabrizio ferrandina , thorsten meyer , roberto zicari | vldb    |   1994 |

Entity B:
| title                                                                                            | authors                     | venue                                         |   year |
|:-------------------------------------------------------------------------------------------------|:----------------------------|:----------------------------------------------|-------:|
| semantics for update rule programs and implementation in a relational database management system | louiqa raschid , jorge lobo | acm transactions on database systems ( tods ) |   1996 |



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

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

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

Entity A:
| title                                                                    | authors                             | venue   |   year |
|:-------------------------------------------------------------------------|:------------------------------------|:--------|-------:|
| qualitative representation of spatial knowledge in two-dimensional space | dimitris papadias , timos k. sellis | vldb j. |   1994 |

Entity B:
| title                                                                    | authors                          | venue                                                                  |   year |
|:-------------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|-------:|
| qualitative representation of spatial knowledge in two-dimensional space | dimitris papadias , timos sellis | the vldb journal -- the international journal on very large data bases |   1994 |



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

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

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

Entity A:
| title                                         | authors         | venue                       |   year |
|:----------------------------------------------|:----------------|:----------------------------|-------:|
| safe query languages for constraint databases | peter z. revesz | acm trans . database syst . |   1998 |

Entity B:
| title                                | authors       | venue             |   year |
|:-------------------------------------|:--------------|:------------------|-------:|
| introduction to constraint databases | bart kuijpers | acm sigmod record |   2002 |



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

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

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

Entity A:
| title                                  | authors      | venue         |   year |
|:---------------------------------------|:-------------|:--------------|-------:|
| domains , relations and religious wars | rafael camps | sigmod record |   1996 |

Entity B:
| title                                                                   | authors    | venue             |   year |
|:------------------------------------------------------------------------|:-----------|:------------------|-------:|
| a response to r. camps ' article domains , relations and religious wars | c. j. date | acm sigmod record |   1996 |



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

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

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

Entity A:
| title                                                                | authors                                       | venue             |   year |
|:---------------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| birch : an efficient data clustering method for very large databases | raghu ramakrishnan , miron livny , tian zhang | sigmod conference |   1996 |

Entity B:
| title                                                                                 | authors                                                         | venue                 |   year |
|:--------------------------------------------------------------------------------------|:----------------------------------------------------------------|:----------------------|-------:|
| wavecluster : a multi-resolution clustering approach for very large spatial databases | gholamhosein sheikholeslami , surojit chatterjee , aidong zhang | very large data bases |   1998 |



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

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

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

Entity A:
| title                                                                       | authors                             | venue         |   year |
|:----------------------------------------------------------------------------|:------------------------------------|:--------------|-------:|
| extraction of object-oriented structures from existing relational databases | julia e. hodges , shekar ramanathan | sigmod record |   1997 |

Entity B:
| title                                                                                               | authors                                                                | venue                 |   year |
|:----------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|:----------------------|-------:|
| optimizing queries with universal quantification in object-oriented and object-relational databases | jens clau &#223; en , alfons kemper , guido moerkotte , klaus peithner | very large data bases |   1997 |



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

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

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

Entity A:
| title                                             | authors                             | venue   |   year |
|:--------------------------------------------------|:------------------------------------|:--------|-------:|
| promises and realities of active database systems | eric simon , angelika kotz dittrich | vldb    |   1995 |

Entity B:
| title                                             | authors                             | venue                 |   year |
|:--------------------------------------------------|:------------------------------------|:----------------------|-------:|
| promises and realities of active database systems | eric simon , angelika kotz dittrich | very large data bases |   1995 |



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

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

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

Entity A:
| title                                | authors                                               | venue   |   year |
|:-------------------------------------|:------------------------------------------------------|:--------|-------:|
| data staging for on-demand broadcast | stanley b. zdonik , demet aksoy , michael j. franklin | vldb    |   2001 |

Entity B:
| title                                      | authors                                            | venue                                          |   year |
|:-------------------------------------------|:---------------------------------------------------|:-----------------------------------------------|-------:|
| balancing push and pull for data broadcast | swarup acharya , michael franklin , stanley zdonik | international conference on management of data |   1997 |



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

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

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

Entity A:
| title                                                       | authors                                | venue   |   year |
|:------------------------------------------------------------|:---------------------------------------|:--------|-------:|
| an introduction to deductive database languages and systems | kotagiri ramamohanarao , james harland | vldb j. |   1994 |

Entity B:
| title                                                                        | authors                                                                                      | venue                 |   year |
|:-----------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------|:----------------------|-------:|
| an effective deductive object-oriented database through language integration | maria l. barja , norman w. paton , alvaro a. a. fernandes , m. howard williams , andrew dinn | very large data bases |   1994 |



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

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

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

Entity A:
| title                                                                                                       | authors       | venue   |   year |
|:------------------------------------------------------------------------------------------------------------|:--------------|:--------|-------:|
| optimizing relational queries in connection hypergraphs : nested queries , views , and binding propagations | jia liang han | vldb j. |   1998 |

Entity B:
| title                                                                                               | authors                                                                | venue                 |   year |
|:----------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|:----------------------|-------:|
| optimizing queries with universal quantification in object-oriented and object-relational databases | jens clau &#223; en , alfons kemper , guido moerkotte , klaus peithner | very large data bases |   1997 |



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

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

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

Entity A:
| title                                                          | authors                                       | venue             |   year |
|:---------------------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| an effective hash based algorithm for mining association rules | ming-syan chen , philip s. yu , jong soo park | sigmod conference |   1995 |

Entity B:
| title                                          | authors        | venue                 |   year |
|:-----------------------------------------------|:---------------|:----------------------|-------:|
| sampling large databases for association rules | hannu toivonen | very large data bases |   1996 |



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

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

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

Entity A:
| title                                                  | authors                                                                                                                      | venue             |   year |
|:-------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| dbcache : database caching for web application servers | sailesh krishnamurthy , c. mohan , larry brown , hamid pirahesh , mehmet altinel , honguk woo , qiong luo , bruce g. lindsay | sigmod conference |   2002 |

Entity B:
| title                                     | authors   | venue                 |   year |
|:------------------------------------------|:----------|:----------------------|-------:|
| caching technologies for web applications | c. mohan  | very large data bases |   2001 |



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

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

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

Entity A:
| title                                             | authors                         | venue   |   year |
|:--------------------------------------------------|:--------------------------------|:--------|-------:|
| intelligent rollups in multidimensional olap data | sunita sarawagi , gayatri sathe | vldb    |   2001 |

Entity B:
| title                                        | authors       | venue                                                                  |   year |
|:---------------------------------------------|:--------------|:-----------------------------------------------------------------------|-------:|
| management of multidimensional discrete data | peter baumann | the vldb journal -- the international journal on very large data bases |   1994 |



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

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

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

Entity A:
| title                                                            | authors                                                  | venue             |   year |
|:-----------------------------------------------------------------|:---------------------------------------------------------|:------------------|-------:|
| efficient and extensible algorithms for multi query optimization | s. sudarshan , siddhesh bhobe , s. seshadri , prasan roy | sigmod conference |   2000 |

Entity B:
| title                                                                    | authors                       | venue                                          |   year |
|:-------------------------------------------------------------------------|:------------------------------|:-----------------------------------------------|-------:|
| efficient mid-query re-optimization of sub-optimal query execution plans | navin kabra , david j. dewitt | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                         | authors                                                   | venue   |   year |
|:----------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| generalized search trees for database systems | jeffrey f. naughton , avi pfeffer , joseph m. hellerstein | vldb    |   1995 |

Entity B:
| title                         | authors   | venue                                          |   year |
|:------------------------------|:----------|:-----------------------------------------------|-------:|
| parallel database systems 101 | jim gray  | international conference on management of data |   1995 |



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

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

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

Entity A:
| title                                                                                 | authors                                             | venue             |   year |
|:--------------------------------------------------------------------------------------|:----------------------------------------------------|:------------------|-------:|
| a robust , optimization-based approach for approximate answering of aggregate queries | vivek r. narasayya , gautam das , surajit chaudhuri | sigmod conference |   2001 |

Entity B:
| title                                                            | authors                                                                            | venue                 |   year |
|:-----------------------------------------------------------------|:-----------------------------------------------------------------------------------|:----------------------|-------:|
| approximating aggregate queries about web pages via random walks | ziv bar-yossef , alexander berg , steve chien , jittat fakcharoenphol , dror weitz | very large data bases |   2000 |



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

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

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

Entity A:
| title                                  | authors      | venue         |   year |
|:---------------------------------------|:-------------|:--------------|-------:|
| mpeg-7 and multimedia database systems | harald kosch | sigmod record |   2002 |

Entity B:
| title                          | authors                                | venue                                          |   year |
|:-------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| the ecrc multi database system | willem jonker , heribert sch &#252; tz | international conference on management of data |   1995 |



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

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

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

Entity A:
| title                                                                                  | authors                       | venue   |   year |
|:---------------------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| opt + + : an object-oriented implementation for extensible database query optimization | david j. dewitt , navin kabra | vldb j. |   1999 |

Entity B:
| title                                                              | authors                          | venue                                                                  |   year |
|:-------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|-------:|
| exact : an extensible approach to active object-oriented databases | oscar d &#237; az , arturo jaime | the vldb journal -- the international journal on very large data bases |   1997 |



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

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

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

Entity A:
| title                                                             | authors                                                 | venue             |   year |
|:------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| random sampling for histogram construction : how much is enough ? | vivek r. narasayya , rajeev motwani , surajit chaudhuri | sigmod conference |   1998 |

Entity B:
| title                                                             | authors                                              | venue                                          |   year |
|:------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------|-------:|
| random sampling for histogram construction : how much is enough ? | surajit chaudhuri , rajeev motwani , vivek narasayya | international conference on management of data |   1998 |



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

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

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

Entity A:
| title                                                                   | authors                                    | venue   |   year |
|:------------------------------------------------------------------------|:-------------------------------------------|:--------|-------:|
| algorithms for materialized view design in data warehousing environment | kamalakar karlapalem , jian yang , qing li | vldb    |   1997 |

Entity B:
| title                                                           | authors   | venue                 |   year |
|:----------------------------------------------------------------|:----------|:----------------------|-------:|
| multiple-view self-maintenance in data warehousing environments | nam huyn  | very large data bases |   1997 |



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

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

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

Entity A:
| title                                                                      | authors                                      | venue   |   year |
|:---------------------------------------------------------------------------|:---------------------------------------------|:--------|-------:|
| m-tree : an efficient access method for similarity search in metric spaces | paolo ciaccia , pavel zezula , marco patella | vldb    |   1997 |

Entity B:
| title                                       | authors     | venue                 |   year |
|:--------------------------------------------|:------------|:----------------------|-------:|
| near neighbor search in large metric spaces | sergey brin | very large data bases |   1995 |



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

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

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

Entity A:
| title                                                                      | authors                     | venue                       |   year |
|:---------------------------------------------------------------------------|:----------------------------|:----------------------------|-------:|
| emancipating instances from the tyranny of classes in information modeling | jeffrey parsons , yair wand | acm trans . database syst . |   2000 |

Entity B:
| title                                                                      | authors                     | venue                                         |   year |
|:---------------------------------------------------------------------------|:----------------------------|:----------------------------------------------|-------:|
| emancipating instances from the tyranny of classes in information modeling | jeffrey parsons , yair wand | acm transactions on database systems ( tods ) |   2000 |



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

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

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

Entity A:
| title                                             | authors                             | venue             |   year |
|:--------------------------------------------------|:------------------------------------|:------------------|-------:|
| bottom-up computation of sparse and iceberg cubes | kevin s. beyer , raghu ramakrishnan | sigmod conference |   1999 |

Entity B:
| title                                     | authors                              | venue                                          |   year |
|:------------------------------------------|:-------------------------------------|:-----------------------------------------------|-------:|
| iceberg-cube computation with pc clusters | raymond t. ng , alan wagner , yu yin | international conference on management of data |   2001 |



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

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

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

Entity A:
| title                                                                                                    | authors                            | venue         |   year |
|:---------------------------------------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| workshop report : the first international workshop on active and real-time database systems ( artdb-95 ) | mikael berndtsson , jörgen hansson | sigmod record |   1996 |

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



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

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

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

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

Entity B:
| title                                                                  | authors                                                 | venue                 |   year |
|:-----------------------------------------------------------------------|:--------------------------------------------------------|:----------------------|-------:|
| automated selection of materialized views and indexes in sql databases | sanjay agrawal , surajit chaudhuri , vivek r. narasayya | very large data bases |   2000 |



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

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

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

Entity A:
| title                                               | authors                          | venue   |   year |
|:----------------------------------------------------|:---------------------------------|:--------|-------:|
| maintaining data privacy in association rule mining | shariq rizvi , jayant r. haritsa | vldb    |   2002 |

Entity B:
| title                                                        | authors                                                                    | venue                                         |   year |
|:-------------------------------------------------------------|:---------------------------------------------------------------------------|:----------------------------------------------|-------:|
| data mining with optimized two-dimensional association rules | takeshi fukuda , yasuhiko morimoto , shimichi morishita , takeshi tokuyama | acm transactions on database systems ( tods ) |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1287
rtable_id: 328
label: 0