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 |
|:---------------------------------------|:----------------------------|:------------------------|-------:|
| an introduction to electronic commerce | sge garrett , pj skevington | bt technology journal , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1531
rtable_id: 55962
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 |
|:--------------------------------------------------|:----------------------------|:--------|-------:|
| merging ranks from heterogeneous internet sources | l gravano , h garcia-molina | vldb    |   1997 |

Entity B:
| title                                                      | authors            | venue   | year   |
|:-----------------------------------------------------------|:-------------------|:--------|:-------|
| semi-structured data extraction from heterogeneous sources | x gao , l sterling |         |        |



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

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

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

Entity A:
| title                                     | authors                                                  | venue                       |   year |
|:------------------------------------------|:---------------------------------------------------------|:----------------------------|-------:|
| space optimization in deductive databases | d srivastava , s sudarshan , r ramakrishnan , j naughton | acm trans . database syst . |   1995 |

Entity B:
| title                                     | authors                        | venue                                | year   |
|:------------------------------------------|:-------------------------------|:-------------------------------------|:-------|
| integrity checking in deductive databases | r kowalsky , f sadri , p soper | proc . of the 13th vldb , brighton , |        |



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

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

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

Entity A:
| title                                                           | authors                     | venue                       |   year |
|:----------------------------------------------------------------|:----------------------------|:----------------------------|-------:|
| improving database design through the analysis of relationships | d dey , v storey , t barron | acm trans . database syst . |   1999 |

Entity B:
| title                                                            | authors   | venue                                  |   year |
|:-----------------------------------------------------------------|:----------|:---------------------------------------|-------:|
| a new normal form for the design of relational database schemata | c zaniolo | acm transactions on database systems , |   1982 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2318
rtable_id: 3405
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 |
|:-------------------------------------------------------------|:----------------------------|:------------------|-------:|
| cure : an efficient clustering algorithm for large databases | s guha , r rastogi , k shim | sigmod conference |   1998 |

Entity B:
| title                                                                | authors     | venue   |   year |
|:---------------------------------------------------------------------|:------------|:--------|-------:|
| birch : an efficient data clustering method for very large databases | tzrrm livny |         |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1133
rtable_id: 41109
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 |
|:--------------------------------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| storing and querying ordered xml using a relational database system | i tatarinov , s viglas , k beyer , j shanmugasundaram , e shekita , c zhang | sigmod conference |   2002 |

Entity B:
| title                                                               | authors     | venue               |   year |
|:--------------------------------------------------------------------|:------------|:--------------------|-------:|
| storing and querying ordered xml using a relational database system | i tatarinov | sigmod conference , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 526
rtable_id: 34865
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 |
|:--------------------------------------------------------------------|:------------------|:------------------|-------:|
| minimal probing : supporting expensive predicates for top-k queries | k chang , s hwang | sigmod conference |   2002 |

Entity B:
| title                                                         | authors        | venue                                  | year   |
|:--------------------------------------------------------------|:---------------|:---------------------------------------|:-------|
| optimization techniques for queries with expensive predicates | jm hellerstein | acm transactions on database systems , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 544
rtable_id: 42537
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 |
|:-----------------------------------------------|:----------------------------------|:----------------------------|-------:|
| lh * - a scalable , distributed data structure | w litwin , m neimat , d schneider | acm trans . database syst . |   1996 |

Entity B:
| title                                                                 | authors                            | venue   | year   |
|:----------------------------------------------------------------------|:-----------------------------------|:--------|:-------|
| lh * : a scalable distributed data structure . ( nov. 1993 ) . to app | w litwin , ma neimat , d schneider |         |        |



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

Entity B:
| title                                                      | authors                            | venue   |   year |
|:-----------------------------------------------------------|:-----------------------------------|:--------|-------:|
| association rules between sets of items in large databases | r agrawal , t imielinski , a swami |         |   1993 |



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

Entity B:
| title                        | authors                  | venue   | year   |
|:-----------------------------|:-------------------------|:--------|:-------|
| data grid management systems | rw moore , a jagatheesan |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 288
rtable_id: 538
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 |
|:---------------------------------------------------------------------|:-------------------|:--------------|-------:|
| applications of the java programming language to database management | b burton , v marek | sigmod record |   1998 |

Entity B:
| title                                                  | authors    | venue   |   year |
|:-------------------------------------------------------|:-----------|:--------|-------:|
| concurrent programming : the java programming language | sj hartley |         |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 595
rtable_id: 8986
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 |
|:---------------------------------------------|:----------|:--------|-------:|
| foreword : management of semistructured data |           |         |   1997 |

Entity B:
| title                                                                      | authors                | venue   | year   |
|:---------------------------------------------------------------------------|:-----------------------|:--------|:-------|
| al. ( 1997 ) . lore : a database management system for semistructured data | j mchugh , s abiteboul | sigmod  |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 528
rtable_id: 60742
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 |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | l liu     | sigmod record |   2003 |

Entity B:
| title           | authors             | venue                                   | year   |
|:----------------|:--------------------|:----------------------------------------|:-------|
| editor 's notes | dj rog , d fournier | new directions for program evaluation , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1914
rtable_id: 33904
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 |
|:----------------------------------|:---------------------------------------------------|:--------|-------:|
| object fusion in mediator systems | y papakonstantinou , s abiteboul , h garcia-molina | vldb    |   1996 |

Entity B:
| title                                                                                 | authors                  | venue                                                             | year   |
|:--------------------------------------------------------------------------------------|:-------------------------|:------------------------------------------------------------------|:-------|
| object fusion in mediator systems extended version . available by anonymous ftp at db | yp pgm , h garcia-molina | stanford . edu as the le pubpapakonstantinou1995fusion-extended . |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1996
rtable_id: 22931
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 aqua approximate query answering system | s acharya , p gibbons , v poosala , s ramaswamy | sigmod conference |   1999 |

Entity B:
| title                                                         | authors                           | venue   |   year |
|:--------------------------------------------------------------|:----------------------------------|:--------|-------:|
| icicles : self-tuning samples for approximate query answering | v ganti , ml lee , r ramakrishnan | vldb ,  |   2000 |



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

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

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

Entity A:
| title                                           | authors                 | venue             |   year |
|:------------------------------------------------|:------------------------|:------------------|-------:|
| optimizing queries over multimedia repositories | s chaudhuri , l gravano | sigmod conference |   1996 |

Entity B:
| title                                                    | authors            | venue                                  | year   |
|:---------------------------------------------------------|:-------------------|:---------------------------------------|:-------|
| virtual document generation from multimedia repositories | if cruz , wt lucas | proc . 5th acm int . multimedia conf , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1429
rtable_id: 4900
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 |
|:------------------------------------------|:--------------------------------------------------------------|:------------------|-------:|
| closest pair queries in spatial databases | a corral , y manolopoulos , y theodoridis , m vassilakopoulos | sigmod conference |   2000 |

Entity B:
| title                                       | authors                            | venue                                                   | year   |
|:--------------------------------------------|:-----------------------------------|:--------------------------------------------------------|:-------|
| selectivity estimation in spatial databases | s achaya , v poosala , s ramaswamy | proc . acm sigmod intâ ?? l conf . management of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 787
rtable_id: 13699
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 |
|:--------------------------------------|:-------------------------|:--------|-------:|
| comparing hybrid peer-to-peer systems | b yang , h garcia-molina | vldb    |   2001 |

Entity B:
| title                                              | authors                  | venue                                                                      | year   |
|:---------------------------------------------------|:-------------------------|:---------------------------------------------------------------------------|:-------|
| comparing hybrid peer-to-peer systems ( extended ) | b yang , h garcia-molina | 27th international conference on very large data bases , rome & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1092
rtable_id: 9774
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 |
|:---------------------------------------|:---------------|:--------------|-------:|
| materialized views and data warehouses | n roussopoulos | sigmod record |   1998 |

Entity B:
| title                                                         | authors                  | venue           |   year |
|:--------------------------------------------------------------|:-------------------------|:----------------|-------:|
| efficient materialization and use of views in data warehouses | mf de souza , mc sampaio | sigmod record , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 615
rtable_id: 32571
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 |
|:-----------------------------------------------------------------|:------------------------------------------------------------------------|:--------------|-------:|
| deeds towards a distributed and active real-time database system | s andler , j hansson , j eriksson , j mellin , m berndtsson , b eftring | sigmod record |   1996 |

Entity B:
| title                                                                  | authors                            | venue   | year   |
|:-----------------------------------------------------------------------|:-----------------------------------|:--------|:-------|
| disima distributed image database system : experiences and reflections | m tamerozsu , v oria , pj iglinski |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 670
rtable_id: 56828
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 |
|:-----------------------------------------|:------------------|:--------------|-------:|
| data management for earth system science | j frew , j dozier | sigmod record |   1997 |

Entity B:
| title                                          | authors               | venue           |   year |
|:-----------------------------------------------|:----------------------|:----------------|-------:|
| database management for life sciences research | hv jagadish , f olken | sigmod record , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 574
rtable_id: 1386
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 mariposa distributed database management system | j sidell  | sigmod record |   1996 |

Entity B:
| title                                                     | authors                | venue                                                   | year   |
|:----------------------------------------------------------|:-----------------------|:--------------------------------------------------------|:-------|
| the arechitecture of an active database management system | r dennis , du mccarthy | proc . of acm sigmod symposium on man agement of data , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 758
rtable_id: 57253
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 |
|:---------------------------------------------------------------------------------------|:-------------------------------------|:------------------|-------:|
| semi-automatic , self-adaptive control of garbage collection rates in object databases | j cook , a klauser , a wolf , b zorn | sigmod conference |   1996 |

Entity B:
| title                                                                       | authors                     | venue   |   year |
|:----------------------------------------------------------------------------|:----------------------------|:--------|-------:|
| partition selection policies in object oriented database garbage collection | je cook , al wolf , bg zorn |         |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1513
rtable_id: 27387
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 |
|:-------------------------------------------|:--------------------------------------------------------------------|:--------|-------:|
| building knowledge base management systems | j mylopoulos , v chaudhri , d plexousakis , a shrufi , t topaloglou | vldb j. |   1996 |

Entity B:
| title                        | authors                | venue   | year   |
|:-----------------------------|:-----------------------|:--------|:-------|
| what is knowledge management | ro barclay , pc murray |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2513
rtable_id: 37437
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 |           |         |   2001 |

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: 376
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 |
|:-----------------------------------------------------|:----------------------|:------------------|-------:|
| a framework for expressing and combining preferences | r agrawal , e wimmers | sigmod conference |   2000 |

Entity B:
| title                                                                           | authors                             | venue   | year   |
|:--------------------------------------------------------------------------------|:------------------------------------|:--------|:-------|
| a general framework for expressing preferences in causal reasoning and planning | pj delgrande , t schaub , h tompits |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 795
rtable_id: 34699
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 |
|:----------------------------------------------------------------------------|:------------------------------|:--------|-------:|
| efficacious data cube exploration by semantic summarization and compression | l lakshmanan , j pei , y zhao | vldb    |   2003 |

Entity B:
| title                                                                                         | authors                       | venue   | year   |
|:----------------------------------------------------------------------------------------------|:------------------------------|:--------|:-------|
| efficacious data cube exploration by semantic summarization and compression ( demo paper ) in | l lakshmanan , j pei , y zhao |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2055
rtable_id: 51699
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 |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | a segev   | sigmod record |   1994 |

Entity B:
| title             | authors          | venue                                               |   year |
|:------------------|:-----------------|:----------------------------------------------------|-------:|
| editorsâ ?? notes | l yorks , e kasl | new directions for adult and continuing education , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1000
rtable_id: 12540
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 |
|:--------------------------------------------------------------|:------------------------------|:------------------|-------:|
| walrus : a similarity retrieval algorithm for image databases | a natsev , r rastogi , k shim | sigmod conference |   1999 |

Entity B:
| title                                           | authors                    | venue   | year   |
|:------------------------------------------------|:---------------------------|:--------|:-------|
| similarity searching in medical image databases | egm petrakis , c faloutsos |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1061
rtable_id: 31615
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 algres testbed of chimera : an active object-oriented database system | s ceri , p fraternali , s paraboschi , g psaila | sigmod conference |   1995 |

Entity B:
| title                                                           | authors   | venue                                                                    |   year |
|:----------------------------------------------------------------|:----------|:-------------------------------------------------------------------------|-------:|
| a deductive and object-oriented database system : why and how ? | l vieille | proceedings of the 1993 acm sigmod international conference & hellip ; , |   1993 |



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

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

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

Entity A:
| title                                                                        | authors                                               | venue   |   year |
|:-----------------------------------------------------------------------------|:------------------------------------------------------|:--------|-------:|
| an effective deductive object-oriented database through language integration | m barja , n paton , a fernandes , m williams , a dinn | vldb    |   1994 |

Entity B:
| title                                                                            | authors                 | venue   | year   |
|:---------------------------------------------------------------------------------|:------------------------|:--------|:-------|
| query language approach based on the deductive object-oriented database paradigm | t niemi , m christensen |         |        |



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

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

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

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

Entity B:
| title                                 | authors        | venue                                  |   year |
|:--------------------------------------|:---------------|:---------------------------------------|-------:|
| view indexing in relational databases | n roussopoulos | acm transactions on database systems , |   1982 |



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

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

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

Entity A:
| title                                                                                                                       | authors   | venue   |   year |
|:----------------------------------------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| efficient processing of expressive node-selecting queries on xml data in secondary storage : a tree automata-based approach | c koch    | vldb    |   2003 |

Entity B:
| title                                                                               | authors    | venue   |   year |
|:------------------------------------------------------------------------------------|:-----------|:--------|-------:|
| efficient processing of interactive relational data base queries expressed in logic | dhd warren | vldb ,  |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2078
rtable_id: 17611
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 mariposa distributed database management system | j sidell  | sigmod record |   1996 |

Entity B:
| title                                      | authors       | venue    | year   |
|:-------------------------------------------|:--------------|:---------|:-------|
| principles of distributed database systems | , p valduriez | prentice |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 758
rtable_id: 45879
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 prototype content-based retrieval system that uses virtual images to save space | l brown , l gruenwald | vldb    |   2001 |

Entity B:
| title                                                      | authors                         | venue                                                                    |   year |
|:-----------------------------------------------------------|:--------------------------------|:-------------------------------------------------------------------------|-------:|
| mclover : mobile content-based leaf image retrieval system | s kim , y tak , y nam , e hwang | proceedings of the 13th annual acm international conference & hellip ; , |   2005 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1066
rtable_id: 30605
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 |
|:---------------------------------------------------|:----------|:--------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record |   1997 |

Entity B:
| title                                                                         | authors                               | venue            |   year |
|:------------------------------------------------------------------------------|:--------------------------------------|:-----------------|-------:|
| semantics and implementation of schema evolution in object-oriented databases | j barnejee , w kim , hj kim , h korth | sigmod records , |   1987 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 562
rtable_id: 50062
label: 0