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 |
|:-------------------------------------|:-------------------------------------------------------------|:--------|-------:|
| active views for electronic commerce | s abiteboul , b amann , s cluet , a eyal , l mignet , t milo | vldb    |   1999 |

Entity B:
| title                            | authors   | venue   |   year |
|:---------------------------------|:----------|:--------|-------:|
| electronic commerce technologies | w kou     |         |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1531
rtable_id: 3872
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 |
|:--------------------------------------|:------------------------------|:--------|-------:|
| streaming queries over streaming data | s chandrasekaran , m franklin | vldb    |   2002 |

Entity B:
| title                         | authors              | venue   | year   |
|:------------------------------|:---------------------|:--------|:-------|
| xsq : streaming xpath queries | f peng , ss chawathe |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2212
rtable_id: 52956
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 |
|:---------------------------------------------|:-------------------|:------------------|-------:|
| xmill : an efficient compressor for xml data | h liefke , d suciu | sigmod conference |   2000 |

Entity B:
| title                                      | authors            | venue                               | year   |
|:-------------------------------------------|:-------------------|:------------------------------------|:-------|
| xmill : an e cient compressor for xml data | h liefke , d suciu | proc . of the acm sigmod , seiten , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 860
rtable_id: 47248
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 |
|:-----------------------------|:----------------------------|:------------------|-------:|
| data grid management systems | a jagatheesan , a rajasekar | sigmod conference |   2003 |

Entity B:
| title                                                        | authors                                                 | venue   | year   |
|:-------------------------------------------------------------|:--------------------------------------------------------|:--------|:-------|
| linear road : a benchmark for stream data management systems | a arasu , m cherniack , e galvez , d maier , a maskey , | vldb    |        |



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

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

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

Entity A:
| title                               | authors                                                                            | venue   |   year |
|:------------------------------------|:-----------------------------------------------------------------------------------|:--------|-------:|
| the aditi deductive database system | j vaghani , k ramamohanarao , d kemp , z somogyi , p stuckey , t leask , j harland | vldb j. |   1994 |

Entity B:
| title                              | authors                | venue                               | year   |
|:-----------------------------------|:-----------------------|:------------------------------------|:-------|
| metu interoperable database system | ce koksal , s mancuhan | demo description , in proc . of acm |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2554
rtable_id: 40895
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 extendible hash for multi-precision similarity querying of image databases | s lin , m жzsu , v oria , r ng | vldb    |   2001 |

Entity B:
| title                                                         | authors   | venue   | year   |
|:--------------------------------------------------------------|:----------|:--------|:-------|
| an extendible hashing structure for image similarity searches | s lin     |         |        |



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

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

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

Entity A:
| title                                                        | authors                   | venue                       |   year |
|:-------------------------------------------------------------|:--------------------------|:----------------------------|-------:|
| a logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                                                  | authors        | venue            | year   |
|:-----------------------------------------------------------------------|:---------------|:-----------------|:-------|
| a dynamic model for conceptual clustering in object-oriented databases | q li , j smith | proc . of vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 18329
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 |
|:-------------------------------------|:------------------|:------------------|-------:|
| association rules over interval data | r miller , y yang | sigmod conference |   1997 |

Entity B:
| title                   | authors                                                | venue                                                 |   year |
|:------------------------|:-------------------------------------------------------|:------------------------------------------------------|-------:|
| association rule hiding | vs verykios , ak elmagarmid , e bertino , y saygin , e | ieee transactions on knowledge and data engineering , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1313
rtable_id: 50395
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 |
|:----------------------------------------------------|:------------------------------|:----------------------------|-------:|
| synthesis of extended transaction models using acta | p chrysanthis , k ramamritham | acm trans . database syst . |   1994 |

Entity B:
| title                                                   | authors                 | venue                                                    | year   |
|:--------------------------------------------------------|:------------------------|:---------------------------------------------------------|:-------|
| modular method to implement extended transaction models | r barga , cpa practical | proceedings of the 21st international conference on very |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2307
rtable_id: 39321
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 infosleuth project | r jr. , w bohrer , r brice , a cichocki , j fowler , a helal , v kashyap , t ksiezyk , g martin , m nodine , m rashid , m rusinkiewicz , r shea , c unnikrishnan , a unruh , d woelk | sigmod conference |   1997 |

Entity B:
| title                  | authors             | venue   | year   |
|:-----------------------|:--------------------|:--------|:-------|
| the infosleuth project | m rusinkiewiczâ ? ¦ |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1363
rtable_id: 32550
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 |
|:---------------------------------------------------------------------------------------|:----------|:--------|-------:|
| panel : future directions of database research - the vldb broadening strategy , part 2 | m brodie  | vldb    |   2000 |

Entity B:
| title                                                  | authors                  | venue   | year   |
|:-------------------------------------------------------|:-------------------------|:--------|:-------|
| database research : some comments on future directions | wt hardgrave , eh sibley |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1299
rtable_id: 52946
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 |
|:--------------------------------------------|:-----------------------------------------------------------------|:--------|-------:|
| xmark : a benchmark for xml data management | a schmidt , f waas , m kersten , m carey , i manolescu , r busse | vldb    |   2002 |

Entity B:
| title               | authors                 | venue              | year   |
|:--------------------|:------------------------|:-------------------|:-------|
| xml data management | p fankhauser , a halevy | the vldb journal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2144
rtable_id: 59206
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 processing in spatial network databases | d papadias , j zhang , n mamoulis , y tao | vldb    |   2003 |

Entity B:
| title                                                     | authors   | venue           |   year |
|:----------------------------------------------------------|:----------|:----------------|-------:|
| parallel query processing in shared disk database systems | e rahm    | sigmod record , |   1993 |



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

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

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

Entity A:
| title                                                            | authors                               | venue   |   year |
|:-----------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| dynamic load balancing in hierarchical parallel database systems | l bouganim , d florescu , p valduriez | vldb    |   1996 |

Entity B:
| title                                                            | authors             | venue                             | year   |
|:-----------------------------------------------------------------|:--------------------|:----------------------------------|:-------|
| managing intra-operator parallelism in parallel database systems | mm md951 , d dewitt | proc . vldb conference , zurich , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1796
rtable_id: 37857
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 |
|:--------------------------------------------------------------|:----------------------|:--------------|-------:|
| relational data sharing in peer-based data management systems | b ooi , y shu , k tan | sigmod record |   2003 |

Entity B:
| title                                                   | authors               | venue                   |   year |
|:--------------------------------------------------------|:----------------------|:------------------------|-------:|
| modelling market-based decentralised management systems | pj kearney , w merlat | bt technology journal , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1944
rtable_id: 20713
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 |
|:-----------------------------------------------------------------|:---------------------|:------------------|-------:|
| secure transaction processing in firm real-time database systems | b george , j haritsa | sigmod conference |   1997 |

Entity B:
| title                                                                                      | authors          | venue                               | year   |
|:-------------------------------------------------------------------------------------------|:-----------------|:------------------------------------|:-------|
| optimistic priority-based concurrency control protocol for firm real-time database systems | jh kim , hs shin | information & software technology , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1407
rtable_id: 18285
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 |
|:-----------------|:----------|:--------|-------:|
| chair 's message |           |         |   2003 |

Entity B:
| title                          | authors           | venue   | year   |
|:-------------------------------|:------------------|:--------|:-------|
| fact division chair 's message | ak gupta , d mahr |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1976
rtable_id: 27009
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 |
|:-------------------------------------------------------------|:-------------------------|:------------------|-------:|
| distributing queries over low-power wireless sensor networks | s madden , j hellerstein | sigmod conference |   2002 |

Entity B:
| title                                                          | authors                           | venue   | year   |
|:---------------------------------------------------------------|:----------------------------------|:--------|:-------|
| power-efficient data dissemination in wireless sensor networks | u cetintemel , a flinders , y sun |         |        |



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

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

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

Entity A:
| title                                                        | authors               | venue             |   year |
|:-------------------------------------------------------------|:----------------------|:------------------|-------:|
| implementation of magic-sets in a relational database system | i mumick , h pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                                  | authors                        | venue           | year   |
|:-----------------------------------------------------------------------|:-------------------------------|:----------------|:-------|
| implementauon of dam abstracuon m the relauonal database system ingres | j ong , d fogg , m stonebraker | sigmod record , |        |



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

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

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

Entity A:
| title                                                                     | authors                            | venue         |   year |
|:--------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| supply chain infrastructures : system integration and information sharing | m ball , m ma , l raschid , z zhao | sigmod record |   2002 |

Entity B:
| title                                             | authors      | venue               |   year |
|:--------------------------------------------------|:-------------|:--------------------|-------:|
| information structures : tools in problem solving | me d'imperio | acm sigmod record , |   1969 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 240
rtable_id: 27365
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 |
|:--------------------------------------------|:---------------------------------------------------|:--------|-------:|
| approximate query processing using wavelets | k chakrabarti , m garofalakis , r rastogi , k shim | vldb    |   2000 |

Entity B:
| title                     | authors   | venue                                  | year   |
|:--------------------------|:----------|:---------------------------------------|:-------|
| multiple query processing | tk sellis | acm transactions on database systems , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1192
rtable_id: 42492
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 tv-tree : an index structure for high-dimensional data | k lin , h jagadish , c faloutsos | vldb j. |   1994 |

Entity B:
| title                                                                       | authors            | venue                                 | year   |
|:----------------------------------------------------------------------------|:-------------------|:--------------------------------------|:-------|
| keim , andhans-peter kriegel . an index structure for high-dimensional data | da stefanberchtold | procs . of the 22nd vldb conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2560
rtable_id: 36030
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 |
|:----------------------------------------------------|:-----------------------------------------|:----------------------------|-------:|
| atomicity and isolation for transactional processes | h schuldt , g alonso , c beeri , h schek | acm trans . database syst . |   2002 |

Entity B:
| title                                               | authors                                   | venue                                  |   year |
|:----------------------------------------------------|:------------------------------------------|:---------------------------------------|-------:|
| atomicity and isolation for transactional processes | h schuldt , g alonso , c beeri , hj schek | acm transactions on database systems , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2339
rtable_id: 22852
label: 1
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                          | authors                        | venue             |   year |
|:-----------------------------------------------|:-------------------------------|:------------------|-------:|
| a system for watermarking relational databases | r agrawal , p haas , j kiernan | sigmod conference |   2003 |

Entity B:
| title                                                                       | authors   | venue           |   year |
|:----------------------------------------------------------------------------|:----------|:----------------|-------:|
| implementation of data abstraction in the relational database system ingres | j ong     | sigmod record , |   1984 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 34720
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 |
|:-------------------------------------|:--------------------------------------|:--------------|-------:|
| bringing order to query optimization | g slivinskas , c jensen , r snodgrass | sigmod record |   2002 |

Entity B:
| title                                  | authors                | venue                                                                    |   year |
|:---------------------------------------|:-----------------------|:-------------------------------------------------------------------------|-------:|
| an architecture for query optimization | a rosenthal , d reiner | proceedings of the 1982 acm sigmod international conference & hellip ; , |   1982 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 40
rtable_id: 34372
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 |
|:--------------------------------------------------------------|:----------------------|:--------------|-------:|
| relational data sharing in peer-based data management systems | b ooi , y shu , k tan | sigmod record |   2003 |

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



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

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

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

Entity A:
| title                                                 | authors                         | venue   |   year |
|:------------------------------------------------------|:--------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | i ilyas , w aref , a elmagarmid | vldb    |   2003 |

Entity B:
| title                                                      | authors                           | venue   | year   |
|:-----------------------------------------------------------|:----------------------------------|:--------|:-------|
| object-oriented querrying of existing relational databases | da keim , hp kriegel , a miethsam |         |        |



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

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

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

Entity A:
| title                                                        | authors               | venue             |   year |
|:-------------------------------------------------------------|:----------------------|:------------------|-------:|
| implementation of magic-sets in a relational database system | i mumick , h pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                        | authors   | venue   |   year |
|:-------------------------------------------------------------|:----------|:--------|-------:|
| a scan-driven sort facility for a relational database system | t haerder | vldb ,  |   1977 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1749
rtable_id: 8936
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 |
|:-------------------------------------------------------------------------|:-------------------------|:--------------|-------:|
| performance evaluation of a new distributed deadlock detection algorithm | c yeung , s hung , k lam | sigmod record |   1994 |

Entity B:
| title                                                                                                | authors            | venue   |   year |
|:-----------------------------------------------------------------------------------------------------|:-------------------|:--------|-------:|
| distributed concurrency control performance : a study of algorithms , distribution , and replication | mj carey , m livny | vldb ,  |   1988 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1015
rtable_id: 6599
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 |
|:----------------------------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| on supporting containment queries in relational database management systems | c zhang , j naughton , d dewitt , q luo , g lohman | sigmod conference |   2001 |

Entity B:
| title                                                        | authors        | venue   | year   |
|:-------------------------------------------------------------|:---------------|:--------|:-------|
| set-oriented production rules in relational database systems | portal.acm.org |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 713
rtable_id: 36009
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 |
|:---------------------------------------------|:-------------------------------------|:--------------|-------:|
| digital library services in mobile computing | b bhargava , m annamalai , e pitoura | sigmod record |   1995 |

Entity B:
| title                     | authors                | venue                |   year |
|:--------------------------|:-----------------------|:---------------------|-------:|
| digital optical computing | aa sawchuk , tc strand | ieee , proceedings , |   1984 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 856
rtable_id: 25777
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 x-tree : an index structure for high-dimensional data | s berchtold , d keim , h kriegel | vldb    |   1996 |

Entity B:
| title                                        | authors                            | venue                                 | year   |
|:---------------------------------------------|:-----------------------------------|:--------------------------------------|:-------|
| an index structure for high-dimensional data | s berchtold , da keim , hp kriegel | procs . of the 22nd vldb conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1834
rtable_id: 34498
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 |
|:-----------------------------------------------------------|:---------------------------------|:--------|-------:|
| the tv-tree : an index structure for high-dimensional data | k lin , h jagadish , c faloutsos | vldb j. |   1994 |

Entity B:
| title                             | authors               | venue                   | year   |
|:----------------------------------|:----------------------|:------------------------|:-------|
| high-dimensional index structures | s berchtold , da keim | proceedings of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2560
rtable_id: 35778
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 |
|:------------------------------------------------------------|:----------|:--------------|-------:|
| research in database engineering at the university of namur | j hainaut | sigmod record |   2003 |

Entity B:
| title                                                       | authors    | venue           |   year |
|:------------------------------------------------------------|:-----------|:----------------|-------:|
| research in database engineering at the university of namur | jl hainaut | sigmod record , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1916
rtable_id: 27784
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 |
|:-------------------------------------------------------------|:--------------------------|:--------|-------:|
| querying multiple features of groups in relational databases | d chatziantoniou , k ross | vldb    |   1996 |

Entity B:
| title                                                        | authors                    | venue                                                                  |   year |
|:-------------------------------------------------------------|:---------------------------|:-----------------------------------------------------------------------|-------:|
| querying multiple features of groups in relational databases | d chatziantoniou , ka ross | proceedings of the international conference on very large & hellip ; , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1986
rtable_id: 468
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 |
|:-------------------------------------------------------------------------------|:-----------------------------|:--------|-------:|
| index nesting - an efficient approach to indexing in object-oriented databases | b ooi , j han , h lu , k tan | vldb j. |   1996 |

Entity B:
| title                                                                | authors                 | venue   | year   |
|:---------------------------------------------------------------------|:------------------------|:--------|:-------|
| effective clustering of complex objects in object-oriented databases | rc jia-bing , ar hurson |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2506
rtable_id: 32338
label: 0