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 |
|:-----------------------------------------------------------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| algorithms for mining association rules for binary segmentations of huge categorical databases | y morimoto , t fukuda , h matsuzawa , t tokuyama , k yoda | vldb    |   1998 |

Entity B:
| title                                                                  | authors                    | venue                                                                                  | year   |
|:-----------------------------------------------------------------------|:---------------------------|:---------------------------------------------------------------------------------------|:-------|
| an efficient algorithm for mining association rules in large databases | ase omiecinski , s navathe | i > proc . 21st int &#39; l conf . very large data bases , < / i > morgan & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1640
rtable_id: 1459
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 |
|:------------------------------------------------------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| design and implementation of advanced knowledge processing in the kdms krisys ( demonstration description ) | j thomas , s deпloch , n mattos | sigmod conference |   1995 |

Entity B:
| title                                                                         | authors   | venue           |   year |
|:------------------------------------------------------------------------------|:----------|:----------------|-------:|
| design and implementation of advanced knowledge processing in the kbms krisys | j thomas  | sigmod record , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1670
rtable_id: 42082
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 |
|:-----------------------------------------------|:-------------------------------------|:----------------------------|-------:|
| probabilistic temporal databases , i : algebra | a dekhtyar , r ross , v subrahmanian | acm trans . database syst . |   2001 |

Entity B:
| title                                          | authors                               | venue                                  |   year |
|:-----------------------------------------------|:--------------------------------------|:---------------------------------------|-------:|
| probabilistic temporal databases , i : algebra | a dekhtyar , r ross , vs subrahmanian | acm transactions on database systems , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2320
rtable_id: 5341
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 |
|:-----------------------------------------------|:-------------------------------------------------|:------------------|-------:|
| lambda-db : an odmg-based object-oriented dbms | l fegaras , c srinivasan , a rajendran , d maier | sigmod conference |   2000 |

Entity B:
| title                                                       | authors                    | venue   | year   |
|:------------------------------------------------------------|:---------------------------|:--------|:-------|
| sentinel : an object-oriented dbms with event-based rules . | acms anthology , p edition |         |        |



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

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

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

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

Entity B:
| title           | authors     | venue                                 |   year |
|:----------------|:------------|:--------------------------------------|-------:|
| guest editorial | s chaudhuri | data mining and knowledge discovery , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 18281
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 |
|:----------------------------------------------------------------------------|:----------|:--------|-------:|
| workflow automation : applications , technology , and research ( tutorial ) |           |         |   1995 |

Entity B:
| title                              | authors   | venue                                                                             | year   |
|:-----------------------------------|:----------|:----------------------------------------------------------------------------------|:-------|
| workflow automation : applications | a sheth   | & hellip ; and research &#39; &#39; tutorial notes from sigmod conference , may , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1662
rtable_id: 42565
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 database and information system research group at the university of ulm | p dadam , w klas | sigmod record |   1997 |

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: 535
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 |
|:---------------------------------------------|:----------|:--------|-------:|
| database management systems and the internet | s malaika | vldb    |   1996 |

Entity B:
| title                 | authors     | venue               |   year |
|:----------------------|:------------|:--------------------|-------:|
| isdn and the internet | k demartino | computer networks , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1841
rtable_id: 32987
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 integrity in a relational data base system | m hammer , d mcleod | vldb ,  |   1975 |



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

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

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

Entity A:
| title                                            | authors   | venue   |   year |
|:-------------------------------------------------|:----------|:--------|-------:|
| the semantic web : semantics for data on the web |           |         |   2003 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2049
rtable_id: 44449
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 |
|:-------------------------------------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| dyda : data warehouse maintenance in fully concurrent environments | j chen , x zhang , s chen , a koeller , e rundensteiner | sigmod conference |   2001 |

Entity B:
| title                                         | authors                                        | venue   | year   |
|:----------------------------------------------|:-----------------------------------------------|:--------|:-------|
| view maintenance in a warehousing environment | y zhuge , h garcia-molina , j hammer , j widom |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 603
rtable_id: 62192
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 |
|:----------------------------|:----------|:------------------|-------:|
| databases and visualization | d keim    | sigmod conference |   1996 |

Entity B:
| title                                      | authors       | venue   | year   |
|:-------------------------------------------|:--------------|:--------|:-------|
| delaunay : a database visualization system | ifcm averbuch |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1442
rtable_id: 41586
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 |
|:----------------------------------------------------------|:----------------------------------|:--------|-------:|
| online dynamic reordering for interactive data processing | v raman , b raman , j hellerstein | vldb    |   1999 |

Entity B:
| title                                                     | authors                            | venue   |   year |
|:----------------------------------------------------------|:-----------------------------------|:--------|-------:|
| online dynamic reordering for interactive data processing | v raman , b raman , jm hellerstein | vldb ,  |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1605
rtable_id: 27703
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 |
|:---------------------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| birch : an efficient data clustering method for very large databases | t zhang , r ramakrishnan , m livny | sigmod conference |   1996 |

Entity B:
| title                                                      | authors            | venue   | year   |
|:-----------------------------------------------------------|:-------------------|:--------|:-------|
| an efficient and flexible method for archiving a data base | c mohan , i narang |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1419
rtable_id: 28488
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 management systems and the internet | s malaika | vldb    |   1996 |

Entity B:
| title                                              | authors                      | venue         | year   |
|:---------------------------------------------------|:-----------------------------|:--------------|:-------|
| rule management in objectoriented database systems | o diaz , nw paton , pmd gray | proc . vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1841
rtable_id: 52385
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 |
|:-----------------------------------------------------------------|:----------------------|:------------------|-------:|
| mining quantitative association rules in large relational tables | r srikant , r agrawal | sigmod conference |   1996 |

Entity B:
| title                                      | authors                  | venue           | year   |
|:-------------------------------------------|:-------------------------|:----------------|:-------|
| mining fuzzy association rules in database | mk chan , f ada , hw man | sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1439
rtable_id: 631
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 |
|:-------------------------------------|:--------------------------|:------------------|-------:|
| cougar : the network is the database | w fung , d sun , j gehrke | sigmod conference |   2002 |

Entity B:
| title                                | authors                    | venue   | year   |
|:-------------------------------------|:---------------------------|:--------|:-------|
| cougar : the network is the database | wf fung , d sun , j gehrke |         |        |



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

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

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

Entity A:
| title                                                           | authors                                | venue   |   year |
|:----------------------------------------------------------------|:---------------------------------------|:--------|-------:|
| on efficiently implementing schemasql on an sql database system | l lakshmanan , f sadri , s subramanian | vldb    |   1999 |

Entity B:
| title                                     | authors                                 | venue    | year   |
|:------------------------------------------|:----------------------------------------|:---------|:-------|
| implementing data cubes efficiently [ j ] | v hafinarayan , a rajaraman , jd ullman | sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1408
rtable_id: 1958
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 |
|:------------------------------------------|:--------------------------|:------------------|-------:|
| extracting structured data from web pages | a arasu , h garcia-molina | sigmod conference |   2003 |

Entity B:
| title                                                                | authors         | venue                                                                |   year |
|:---------------------------------------------------------------------|:----------------|:---------------------------------------------------------------------|-------:|
| extracting a websiteâ ?? s content structure from its link structure | n liu , cc yang | proceedings of the 14th acm international conference on & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 212
rtable_id: 60183
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 trigs active object-oriented database system - an overview | g kappel , w retschitzegger | sigmod record |   1998 |

Entity B:
| title                                                                    | authors             | venue                            | year   |
|:-------------------------------------------------------------------------|:--------------------|:---------------------------------|:-------|
| effective clustering of complex data in object-oriented database systems | j cheng , ar hurson | proceedings acm sigmod , pages , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 604
rtable_id: 48163
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 |
|:----------------------------------------------------------|:----------------------------------|:--------|-------:|
| online dynamic reordering for interactive data processing | v raman , b raman , j hellerstein | vldb    |   1999 |

Entity B:
| title                     | authors                            | venue                                                                 |   year |
|:--------------------------|:-----------------------------------|:----------------------------------------------------------------------|-------:|
| online dynamic reordering | v raman , b raman , jm hellerstein | the vldb journal the international journal on very large & hellip ; , |   2000 |



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

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

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

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

Entity B:
| title                                                         | authors                                                | venue   |   year |
|:--------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| grid data servicesâ ?? relational database management systems | b collins , a borley , n hardman , a knox , s laws , j |         |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 54243
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   |
|:-------------------------------------------------|:-----------------------|:-----------|:-------|
| p. kreps the design and implementation of ingres | m stonebraker , e wong | acm tods , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1826
rtable_id: 19973
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 |
|:---------------------------------------------|:-------------------------|:------------------|-------:|
| datamine - interactive rule discovery system | t imielinski , a virmani | sigmod conference |   1995 |

Entity B:
| title                                      | authors                  | venue   | year   |
|:-------------------------------------------|:-------------------------|:--------|:-------|
| datamine-interactive rule discovery system | t imielinski , a virmani |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1584
rtable_id: 28111
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 |
|:--------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| 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 |
|:-------------------------------------------------------------|:-------------------------|:---------------------|-------:|
| the value of information sharing in a two-level supply chain | hl lee , kc so , cs tang | management science , |   2000 |



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

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

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

Entity A:
| title                                                                | authors                          | venue   |   year |
|:---------------------------------------------------------------------|:---------------------------------|:--------|-------:|
| querying heterogeneous information sources using source descriptions | a levy , a rajaraman , j ordille | vldb    |   1996 |

Entity B:
| title                                                                                          | authors                     | venue                              | year   |
|:-----------------------------------------------------------------------------------------------|:----------------------------|:-----------------------------------|:-------|
| mind your vocabulary : query mapping across heterogeneous information sources . acm sigmod int | cck chang , h garcia-molina | conference on management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2581
rtable_id: 21049
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 |
|:------------------------------|:------------------------------------------|:----------------------------------------------------------------------|-------:|
| parametric query optimization | ye ioannidis , rt ng , k shim , tk sellis | the vldb journal the international journal on very large & hellip ; , |   1997 |



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

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

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

Entity A:
| title                                                          | authors                                      | venue             |   year |
|:---------------------------------------------------------------|:---------------------------------------------|:------------------|-------:|
| disima : a distributed and interoperable image database system | v oria , m жzsu , p iglinski , s lin , b yao | sigmod conference |   2000 |

Entity B:
| title                                                                | authors    | venue                  | year   |
|:---------------------------------------------------------------------|:-----------|:-----------------------|:-------|
| j. , and ram , e hydro : a heterogeneous distributed database system | wr perrizo | proceedings of the acm |        |



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

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

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

Entity A:
| title                                                           | authors   | venue             |   year |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| unisql/x unified relational and object-oriented database system | w kim     | sigmod conference |   1994 |

Entity B:
| title                                  | authors     | venue                                                                    |   year |
|:---------------------------------------|:------------|:-------------------------------------------------------------------------|-------:|
| the o2 object-oriented database system | f bancilhon | proceedings of the 1992 acm sigmod international conference & hellip ; , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1821
rtable_id: 36236
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   |
|:-----------------------------------------------------------------|:--------------------------------------------------|:----------------------------|:-------|
| query processing in a system for distributed databases ( sdd-1 ) | n goodman , pa bernstein , e wong , cl reeve , jb | acm trans . database syst , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1401
rtable_id: 19853
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 |
|:-------------------------------------------------------|:------------------------------|:----------------------------|-------:|
| formal query languages for secure relational databases | m winslett , k smith , x qian | acm trans . database syst . |   1994 |

Entity B:
| title                             | authors               | venue   |   year |
|:----------------------------------|:----------------------|:--------|-------:|
| watermarking relational databases | r agrawal , j kiernan | vldb ,  |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2310
rtable_id: 28180
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 practical and modular implementation of extended transaction models | r barga , c pu | vldb    |   1995 |

Entity B:
| title                                                                           | authors   | venue                                                                 | year   |
|:--------------------------------------------------------------------------------|:----------|:----------------------------------------------------------------------|:-------|
| c. pu . a practical and modular method to implement extended transaction models | r barga   | proceedings of the 21st international conference on very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1973
rtable_id: 64197
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 |
|:----------------------------|:-------------------|:------------------|-------:|
| optimizing queries on files | m consens , t milo | sigmod conference |   1994 |

Entity B:
| title                                    | authors                  | venue                                                                 |   year |
|:-----------------------------------------|:-------------------------|:----------------------------------------------------------------------|-------:|
| optimizing queries on compressed bitmaps | s amer-yahia , t johnson | proceedings of the 26th international conference on very & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1770
rtable_id: 26389
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 |
|:-----------------------------------------------------|:--------------------------|:--------------|-------:|
| integrating contents and structure in text retrieval | r baeza-yates , g navarro | sigmod record |   1996 |

Entity B:
| title                                                 | authors                 | venue                                                                |   year |
|:------------------------------------------------------|:------------------------|:---------------------------------------------------------------------|-------:|
| structural features in content oriented xml retrieval | g ramãrez , ap de vries | proceedings of the 14th acm international conference on & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 691
rtable_id: 32401
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 itemset counting and implication rules for market basket data | s brin , r motwani , j ullman , s tsur | sigmod conference |   1997 |

Entity B:
| title                                                                  | authors                                 | venue                                                                 | year   |
|:-----------------------------------------------------------------------|:----------------------------------------|:----------------------------------------------------------------------|:-------|
| dynamic iternset counting and impficalion rules for market basket data | s brin , r motwani , jd ullman , s tsur | acm sigmod international conference on the management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1235
rtable_id: 2066
label: 1