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 |
|:--------------------------------------------|:------------------------------------|:------------------|-------:|
| selectivity estimation in spatial databases | s acharya , v poosala , s ramaswamy | sigmod conference |   1999 |

Entity B:
| title                                                                      | authors                                | venue   | year   |
|:---------------------------------------------------------------------------|:---------------------------------------|:--------|:-------|
| selectivity estimation in extensible databases-a neural network approach . | acms disc , acms anthology , p edition |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1023
rtable_id: 63738
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 query by image content ( qbic ) system | j ashley , m flickner , j hafner , d lee , w niblack , d petkovic | sigmod conference |   1995 |

Entity B:
| title                                      | authors                                                | venue                                                                    |   year |
|:-------------------------------------------|:-------------------------------------------------------|:-------------------------------------------------------------------------|-------:|
| the query by image content ( qbic ) system | j ashley , m flickner , j hafner , d lee , w niblack , | proceedings of the 1995 acm sigmod international conference & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1679
rtable_id: 1376
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 |
|:-----------------------------------------------|:------------------------------------|:------------------|-------:|
| infomaster : an information integration system | m genesereth , a keller , o duschka | sigmod conference |   1997 |

Entity B:
| title                                         | authors     | venue   |   year |
|:----------------------------------------------|:------------|:--------|-------:|
| information integration and xml in ibm 's db2 | pg selinger | vldb ,  |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1365
rtable_id: 31209
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 |
|:-------------------------------------------------------------------------------------------|:-------------------------------|:--------|-------:|
| cost-based selection of path expression processing algorithms in object-oriented databases | g gardarin , j gruser , z tang | vldb    |   1996 |

Entity B:
| title                                                                                     | authors       | venue                                                                    |   year |
|:------------------------------------------------------------------------------------------|:--------------|:-------------------------------------------------------------------------|-------:|
| on accessing object-oriented databases : expressive power , complexity , and restrictions | r hull , j su | proceedings of the 1989 acm sigmod international conference & hellip ; , |   1989 |



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

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

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

Entity A:
| title                             | authors   | venue   |   year |
|:----------------------------------|:----------|:--------|-------:|
| concurrency in the data warehouse | r taylor  | vldb    |   2000 |

Entity B:
| title                        | authors                       | venue              | year   |
|:-----------------------------|:------------------------------|:-------------------|:-------|
| expiring data in a warehouse | hg molina , wj labio , j yang | proc . 24th vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1400
rtable_id: 21236
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 |
|:------------------------------------------|:----------------------------|:------------------|-------:|
| goal-oriented buffer management revisited | k brown , m carey , m livny | sigmod conference |   1996 |

Entity B:
| title                                     | authors                       | venue                                                                    |   year |
|:------------------------------------------|:------------------------------|:-------------------------------------------------------------------------|-------:|
| goal-oriented buffer management revisited | kp brown , mj carey , m livny | proceedings of the 1996 acm sigmod international conference & hellip ; , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1457
rtable_id: 54156
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 |
|:----------------------------------------------|:-----------|:--------|-------:|
| query processing in tertiary memory databases | s sarawagi | vldb    |   1995 |

Entity B:
| title                                                          | authors      | venue                                                       | year   |
|:---------------------------------------------------------------|:-------------|:------------------------------------------------------------|:-------|
| spatial query processing in an object-oriented database system | ja orenstein | proceedings of the 1986 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 104
rtable_id: 52821
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 |
|:--------------------------------------------------------|:-------------------------------------------------|:------------------|-------:|
| dna-miner : a system prototype for mining dna sequences | j han , h jamil , y lu , l chen , y liao , j pei | sigmod conference |   2001 |

Entity B:
| title                                                            | authors                       | venue                                                              |   year |
|:-----------------------------------------------------------------|:------------------------------|:-------------------------------------------------------------------|-------:|
| multimedia miner : a system prototype for multimedia data mining | , j han , sh chee , jy chiang | proceedings of acm-sigmod international conference on & hellip ; , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 611
rtable_id: 135
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 araneus web-base management system | g mecca , p atzeni , a masci , p merialdo , g sindoni | sigmod conference |   1998 |

Entity B:
| title             | authors       | venue   | year   |
|:------------------|:--------------|:--------|:-------|
| management system | csd recording |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1264
rtable_id: 45703
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 |
|:-------------------------------------------------------------------|:-----------------|:--------|-------:|
| exact : an extensible approach to active object-oriented databases | o dэaz , a jaime | vldb j. |   1997 |

Entity B:
| title                                                                                   | authors               | venue   | year   |
|:----------------------------------------------------------------------------------------|:----------------------|:--------|:-------|
| an active object-oriented database : a multi-paradigm approach to constraint management | h ishikawa , k kubota |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2432
rtable_id: 47811
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   |
|:-------------------------------------|:-----------------------------|:--------|:-------|
| vqbd : exploring semistructured data | ss chawathe , t baby , j yeo |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 204
rtable_id: 56249
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 |
|:-----------------------------------------|:---------------------|:--------|-------:|
| including group-by in query optimization | s chaudhuri , k shim | vldb    |   1994 |

Entity B:
| title                                      | authors                            | venue           | year   |
|:-------------------------------------------|:-----------------------------------|:----------------|:-------|
| open issues in parallel query optimization | h waqar , d florescu , p valduriez | sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 229
rtable_id: 59561
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 |
|:--------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------|:--------|-------:|
| advanced data processing in krisys : modeling concepts , implementation techniques , and client/server issues | s deпloch , t hфrder , n mattos , b mitschang , j thomas | vldb j. |   1998 |

Entity B:
| title                                                                                                  | authors                                               | venue                                                                 |   year |
|:-------------------------------------------------------------------------------------------------------|:------------------------------------------------------|:----------------------------------------------------------------------|-------:|
| advanced data processing in krisys : modeling concepts , implementation techniques , and client/server | s deã?loch , t hã $ rder , n mattos , b mitschang , j | the vldb journal the international journal on very large & hellip ; , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2439
rtable_id: 30401
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 |
|:------------------------------------------------------------------------|:-----------------------------------|:--------|-------:|
| integrating triggers and declarative constraints in sql database sytems | r cochrane , h pirahesh , n mattos | vldb    |   1996 |

Entity B:
| title                                                                 | authors        | venue   | year   |
|:----------------------------------------------------------------------|:---------------|:--------|:-------|
| integrating active concepts into an object-oriented database system . | acms anthology |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2587
rtable_id: 50293
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 ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j chaudhary , g karvelis , s sou | sigmod conference |   1994 |

Entity B:
| title                                                        | authors                                               | venue                                                                  | year   |
|:-------------------------------------------------------------|:------------------------------------------------------|:-----------------------------------------------------------------------|:-------|
| access pathselectionina relationaldatabase management system | p selinger , mm astrahan , dd chamberlin , ra lorie , | proceedings of the acm-sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1840
rtable_id: 26880
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 |
|:-----------------------------------------------------------------------------|:------------------------------------------|:------------------|-------:|
| infoharness : a system for search and retrieval of heterogeneous information | l shklar , a sheth , v kashyap , s thatte | sigmod conference |   1995 |

Entity B:
| title                                                                        | authors                                                | venue                  |   year |
|:-----------------------------------------------------------------------------|:-------------------------------------------------------|:-----------------------|-------:|
| stuff iâ ?? ve seen : a system for personal information retrieval and re-use | s dumais , e cutrell , jj cadiz , g jancke , r sarin , | proceedings of sigir , |   2003 |



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

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

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

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

Entity B:
| title                                                                  | authors          | venue           |   year |
|:-----------------------------------------------------------------------|:-----------------|:----------------|-------:|
| performing joins without decompression in a compressed database system | , n winterbottom | sigmod record , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 703
rtable_id: 24344
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 |
|:----------------------------------------------------------|:----------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | s son , r david , b thuraisingham | sigmod record |   1996 |

Entity B:
| title                                                | authors              | venue                                       | year   |
|:-----------------------------------------------------|:---------------------|:--------------------------------------------|:-------|
| secure buffering inâ ® rm real-time database systems | b george , j haritsa | journal on very large data bases ( vldb ) , |        |



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

Entity B:
| title                                                   | authors   | venue                                                                 |   year |
|:--------------------------------------------------------|:----------|:----------------------------------------------------------------------|-------:|
| rsrikant . fast algorithms for mining association rules | ra rr941  | proceedings of the 20th international conference on very & hellip ; , |     41 |



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

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

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

Entity A:
| title                                                                      | authors            | venue   |   year |
|:---------------------------------------------------------------------------|:-------------------|:--------|-------:|
| selectivity estimation in extensible databases - a neural network approach | m lakshmi , s zhou | vldb    |   1998 |

Entity B:
| title                                                         | authors                            | venue                              | year   |
|:--------------------------------------------------------------|:-----------------------------------|:-----------------------------------|:-------|
| selectivity estimation in spatial databases , acm sigmod intl | s achaya , v poosala , s ramaswamy | conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1756
rtable_id: 175
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 |
|:-------------------------------------------------|:----------------------------------------------|:--------|-------:|
| scalable techniques for mining causal structures | c silverstein , s brin , r motwani , j ullman | vldb    |   1998 |

Entity B:
| title                                                                 | authors   | venue   | year   |
|:----------------------------------------------------------------------|:----------|:--------|:-------|
| scalable distributed data structures : a survey of current techniques | d beck    |         |        |



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

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

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

Entity A:
| title                                                  | authors                 | venue             |   year |
|:-------------------------------------------------------|:------------------------|:------------------|-------:|
| accessing relational databases from the world wide web | t nguyen , v srinivasan | sigmod conference |   1996 |

Entity B:
| title                                        | authors                  | venue   |   year |
|:---------------------------------------------|:-------------------------|:--------|-------:|
| extracting knowledge from the world wide web | m henzinger , s lawrence | pnas ,  |   2004 |



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

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

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

Entity A:
| title                                                       | authors                               | venue   |   year |
|:------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| the design and implementation of a sequence database system | p seshadri , m livny , r ramakrishnan | vldb    |   1996 |

Entity B:
| title                                         | authors               | venue                                                                  | year   |
|:----------------------------------------------|:----------------------|:-----------------------------------------------------------------------|:-------|
| the architecture of an active database system | dr mccarthy , u dayal | proc . 1989 acm-sigmod conference on management of data , & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1826
rtable_id: 17562
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 |
|:-------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| revisiting commit processing in distributed database systems | r gupta , j haritsa , k ramamritham | sigmod conference |   1997 |

Entity B:
| title                                                        | authors   | venue           | year   |
|:-------------------------------------------------------------|:----------|:----------------|:-------|
| enslow , '' what is a ` distributed ` data processing system | h philip  | ieee computer , |        |



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

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

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

Entity A:
| title                                                    | authors                                            | venue             |   year |
|:---------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| optimizing disjunctive queries with expensive predicates | a kemper , g moerkotte , k peithner , m steinbrunn | sigmod conference |   1994 |

Entity B:
| title                                              | authors            | venue               |   year |
|:---------------------------------------------------|:-------------------|:--------------------|-------:|
| stream processing of xpath queries with predicates | ak gupta , d suciu | sigmod conference , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1788
rtable_id: 35232
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 |
|:---------------------------------------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| materialized view selection and maintenance using multi-query optimization | h mistry , p roy , s sudarshan , k ramamritham | sigmod conference |   2001 |

Entity B:
| title                                                            | authors                                                | venue                                                                    |   year |
|:-----------------------------------------------------------------|:-------------------------------------------------------|:-------------------------------------------------------------------------|-------:|
| rainbow : multi-xquery optimization using materialized xml views | x zhang , k dimitrova , l wang , m el sayed , b murphy | proceedings of the 2003 acm sigmod international conference & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 669
rtable_id: 16431
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 the university of oklahoma | l gruenwald , l brown , r dirckze , s guinepain , c sсnchez , b summers , s vanichayobon | sigmod record |   1999 |

Entity B:
| title                                    | authors      | venue           |   year |
|:-----------------------------------------|:-------------|:----------------|-------:|
| database research at la trobe university | j zeleznikow | sigmod record , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 464
rtable_id: 21924
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 |
|:--------------------------------------------------------------------------------------------------|:-------------------|:----------------------------|-------:|
| semantics for update rule programs and implementations in a relational database management system | l raschid , j lobo | acm trans . database syst . |   1996 |

Entity B:
| title                                              | authors             | venue                                      | year   |
|:---------------------------------------------------|:--------------------|:-------------------------------------------|:-------|
| semantic mtegrity of a relational data base system | m hammer , d mcleod | proc . conf very large data bases , sept , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2272
rtable_id: 58812
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 |
|:-----------------------------------------------------------|:--------------------|:--------|-------:|
| coloring away communication in parallel query optimization | w hasan , r motwani | vldb    |   1995 |

Entity B:
| title                        | authors                 | venue      | year   |
|:-----------------------------|:------------------------|:-----------|:-------|
| continous query optimization | r avnur , j hellerstien | acm sigmod |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1969
rtable_id: 45113
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 |
|:--------------------------------------|:-----------------------------|:--------|-------:|
| complex queries over web repositories | s raghavan , h garcia-molina | vldb    |   2003 |

Entity B:
| title                                                           | authors                            | venue                                                   |   year |
|:----------------------------------------------------------------|:-----------------------------------|:--------------------------------------------------------|-------:|
| optimizing top-k selection queries over multimedia repositories | s chaudhuri , l gravano , a marian | knowledge and data engineering , ieee transactions on , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2069
rtable_id: 57141
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 |
|:----------------------------------------------------------------------------------|:--------------------------|:------------------|-------:|
| highly concurrent cache consistency for indices in client-server database systems | m zaharioudakis , m carey | sigmod conference |   1997 |

Entity B:
| title                                                | authors        | venue   | year   |
|:-----------------------------------------------------|:---------------|:--------|:-------|
| concurrency control and recovery in database systems | acms anthology |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1296
rtable_id: 41110
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 |
|:-------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| distinct sampling for highly-accurate answers to distinct values queries and event reports | p gibbons | vldb    |   2001 |

Entity B:
| title                                                                                      | authors    | venue   |   year |
|:-------------------------------------------------------------------------------------------|:-----------|:--------|-------:|
| distinct sampling for highly-accurate answers to distinct values queries and event reports | pb gibbons | vldb ,  |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1098
rtable_id: 60270
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 |
|:------------------------------------|:-----------------------|:--------------|-------:|
| real-time index concurrency control | j haritsa , s seshadri | sigmod record |   1996 |

Entity B:
| title                                         | authors               | venue                                                                      |   year |
|:----------------------------------------------|:----------------------|:---------------------------------------------------------------------------|-------:|
| on optimistic methods for concurrency control | ht king , jt robinson | very large data bases , 1979 . fifth international conference & hellip ; , |   1979 |



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

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

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

Entity A:
| title                                                          | authors                | venue             |   year |
|:---------------------------------------------------------------|:-----------------------|:------------------|-------:|
| an effective hash based algorithm for mining association rules | j park , m chen , p yu | sigmod conference |   1995 |

Entity B:
| title                                                    | authors                    | venue                                                                       |   year |
|:---------------------------------------------------------|:---------------------------|:----------------------------------------------------------------------------|-------:|
| algorithms for mining association rules in bag databases | py hsu , yl chen , cc ling | information sciencesâ ?? informatics and computer science : an & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1543
rtable_id: 11823
label: 0