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 |
|:---------------------------------------------------|:---------------------------------------|:--------|-------:|
| towards event-driven modelling for database design | m teisseire , p poncelet , r cicchetti | vldb    |   1994 |

Entity B:
| title                                            | authors                   | venue                       | year   |
|:-------------------------------------------------|:--------------------------|:----------------------------|:-------|
| modelling events in database applications design | v de antonellis , b zonta | proceedings of the 7th vldb |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 147
rtable_id: 7328
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 |
|:---------------------------------|:-----------------|:--------------|-------:|
| issues in data stream management | l golab , m жzsu | sigmod record |   2003 |

Entity B:
| title                    | authors    | venue   |   year |
|:-------------------------|:-----------|:--------|-------:|
| temporal data management | a shoshani | vldb ,  |   1986 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1975
rtable_id: 30120
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 |
|:-----------------------------------------------------------------------------------------|:----------|:--------------|-------:|
| act-net - the active database management system manifesto : a rulebase of adbms features |           | sigmod record |   1996 |

Entity B:
| title                                               | authors                            | venue                                  |   year |
|:----------------------------------------------------|:-----------------------------------|:---------------------------------------|-------:|
| a database management system for the federal courts | jr buchanan , rd fennell , h samet | acm transactions on database systems , |   1984 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 642
rtable_id: 11056
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 |
|:--------------------------------------------------------------------------------------------------------|:----------|:------------------|-------:|
| integration of heterogeneous databases without common domains using queries based on textual similarity | w cohen   | sigmod conference |   1998 |

Entity B:
| title                                                                                        | authors   | venue               |   year |
|:---------------------------------------------------------------------------------------------|:----------|:--------------------|-------:|
| integration of heterogeneous databases without common domains using queries based on textual | ww cohen  | sigmod conference , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1167
rtable_id: 25781
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 |
|:----------------------------------------------------------------|:----------|:------------------|-------:|
| unisql/x unified relational and object-oriented database system | w kim     | sigmod conference |   1994 |

Entity B:
| title                                                                                   | authors   | venue           |   year |
|:----------------------------------------------------------------------------------------|:----------|:----------------|-------:|
| a syntax and semantics for set-oriented production rules in relational database systems | j widom   | sigmod record , |   1989 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1821
rtable_id: 15065
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 |
|:------------------------------|:------------------------------------------------------------------|:--------|-------:|
| proximity search in databases | r goldman , n shivakumar , s venkatasubramanian , h garcia-molina | vldb    |   1998 |

Entity B:
| title                                             | authors                                              | venue                                | year   |
|:--------------------------------------------------|:-----------------------------------------------------|:-------------------------------------|:-------|
| fast nearest neighbor search in medical databases | f korn , n sidiropoulos , c faloutsos , e siegel , z | proc . conf . very large databases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1560
rtable_id: 41704
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 |
|:---------------------|:----------|:--------|-------:|
| treasurer 's message |           |         |   2001 |

Entity B:
| title                    | authors     | venue   | year   |
|:-------------------------|:------------|:--------|:-------|
| head/director 's message | rdae status |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 187
rtable_id: 39715
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 |
|:------------------------------------------------------|:------------------------------------------------------------------|:--------|-------:|
| dalэ : a high performance main memory storage manager | h jagadish , d lieuwen , r rastogi , a silberschatz , s sudarshan | vldb    |   1994 |

Entity B:
| title                                               | authors              | venue                                                                 |   year |
|:----------------------------------------------------|:---------------------|:----------------------------------------------------------------------|-------:|
| quickstore : a high performance mapped object store | sj white , dj dewitt | the vldb journal the international journal on very large & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 67
rtable_id: 36693
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 |
|:----------------------------------------------------|:-----------------------------------|:------------------|-------:|
| hd-eye : visual clustering of high dimensional data | a hinneburg , d keim , m wawryniuk | sigmod conference |   2002 |

Entity B:
| title                                                    | authors                     | venue   | year   |
|:---------------------------------------------------------|:----------------------------|:--------|:-------|
| subspace clustering for high dimensional data : a review | l parsons , e haque , h liu |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 457
rtable_id: 25614
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 bucky object-relational benchmark ( experience paper ) | m carey , d dewitt , j naughton , m asgarian , p brown , j gehrke , d shah | sigmod conference |   1997 |

Entity B:
| title                                                      | authors                                             | venue               | year   |
|:-----------------------------------------------------------|:----------------------------------------------------|:--------------------|:-------|
| the bucky object-relational benchmark ( experience paper ) | mj carey , dj dewitt , jf naughton , m asgarian , p | sigmod conference , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1311
rtable_id: 20446
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 evolution of the web and implications for an incremental crawler | j cho , h garcia-molina | vldb    |   2000 |

Entity B:
| title                                                                                                      | authors   | venue   | year   |
|:-----------------------------------------------------------------------------------------------------------|:----------|:--------|:-------|
| garcia-molina h. ( 2000b ) , â ?? the evolution of the web and implications for an incremental crawlerâ ?? | j cho     |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1376
rtable_id: 11385
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 |
|:----------------------------------------|:------------------------------------|:--------|-------:|
| view management in multimedia databases | k candan , e lemar , v subrahmanian | vldb j. |   2000 |

Entity B:
| title                                     | authors   | venue   | year   |
|:------------------------------------------|:----------|:--------|:-------|
| similarity search in multimedia databases | m patella |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2396
rtable_id: 17487
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 sr-tree : an index structure for high-dimensional nearest neighbor queries | n katayama , s satoh | sigmod conference |   1997 |

Entity B:
| title                                                                          | authors   | venue   | year   |
|:-------------------------------------------------------------------------------|:----------|:--------|:-------|
| the convex polyhedra technique : an index structure for high-dimensional space | j an      |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1397
rtable_id: 60186
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 placement in shared-nothing parallel database systems | m mehta , d dewitt | vldb j. |   1997 |

Entity B:
| title                                        | authors                       | venue                                  |   year |
|:---------------------------------------------|:------------------------------|:---------------------------------------|-------:|
| parallelism and recovery in database systems | r bayer , h heller , a reiser | acm transactions on database systems , |   1980 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2515
rtable_id: 60594
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 | p atzeni , ao mendelzon | the vldb journal the international journal on very large & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 228
rtable_id: 6003
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 aspect of query optimization in multidatabase systems ( extended abstract ) | c lee , c chen , h lu | sigmod record |   1995 |

Entity B:
| title                                                  | authors            | venue                                  |   year |
|:-------------------------------------------------------|:-------------------|:---------------------------------------|-------:|
| set query optimization in distributed database systems | b gavish , a segev | acm transactions on database systems , |   1986 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 882
rtable_id: 34097
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 |
|:---------------------------------------------------|:--------------------------------|:------------------|-------:|
| enhanced hypertext categorization using hyperlinks | s chakrabarti , b dom , p indyk | sigmod conference |   1998 |

Entity B:
| title                                                           | authors                       | venue   | year   |
|:----------------------------------------------------------------|:------------------------------|:--------|:-------|
| hypertext categorization using hyperlink patterns and meta data | r ghani , s slattery , y yang |         |        |



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

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

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

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

Entity B:
| title                                     | authors                | venue                                 |   year |
|:------------------------------------------|:-----------------------|:--------------------------------------|-------:|
| introduction to object-oriented databases | ma garvey , ms jackson | information and software technology , |   1989 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 49648
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 |
|:----------------------------------------|:----------|:--------|-------:|
| dwms : data warehouse management system | n mohan   | vldb    |   1996 |

Entity B:
| title                                   | authors     | venue                                                                    |   year |
|:----------------------------------------|:------------|:-------------------------------------------------------------------------|-------:|
| open object database management systems | ja blakeley | proceedings of the 1994 acm sigmod international conference & hellip ; , |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1842
rtable_id: 11839
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   |
|:---------------------------------------------------------------------------------|:-----------|:---------------------------------------------------|:-------|
| nodose { a tool for semi-automatically extracting semi-structured data from text | b adelberg | proc . of the sigmod conference , seattle , june , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 212
rtable_id: 51230
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 |
|:----------------------------------------------|:-----------|:--------|-------:|
| information integration and xml in ibm 's db2 | p selinger | vldb    |   2002 |

Entity B:
| title                                         | authors                    | venue                                                        | year   |
|:----------------------------------------------|:---------------------------|:-------------------------------------------------------------|:-------|
| infomaster-an information integration toolkit | om duschka , mr genesereth | technical report , department of computer science . stanford |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2139
rtable_id: 59537
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 approximation of optimization queries under parametric aggregation constraints | s guha , d gunopulos , n koudas , d srivastava , m vlachos | vldb    |   2003 |

Entity B:
| title                                                                        | authors                                | venue                                             | year   |
|:-----------------------------------------------------------------------------|:---------------------------------------|:--------------------------------------------------|:-------|
| optimization of constrained frequent set queries with 2-variable constraints | lvs laksmanan , rt ng , j han , a pang | proc . acm sigmod ( philadelphia , pennsylvania , |        |



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

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

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

Entity A:
| title                                                         | authors               | venue         |   year |
|:--------------------------------------------------------------|:----------------------|:--------------|-------:|
| relational data sharing in peer-based data management systems | b ooi , y shu , k tan | sigmod record |   2003 |

Entity B:
| title                        | authors                     | venue                                                                    | year   |
|:-----------------------------|:----------------------------|:-------------------------------------------------------------------------|:-------|
| data grid management systems | a rajasekar , a jagatheesan | proceedings of the 2003 acm sigmod international conference & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1944
rtable_id: 6551
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 |
|:---------------------------------------------------|:----------|:--------------|-------:|
| parameterized complexity for the database theorist | m grohe   | sigmod record |   2002 |

Entity B:
| title                                    | authors   | venue   | year   |
|:-----------------------------------------|:----------|:--------|:-------|
| parameterized complexity for the skeptic | r downey  |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 123
rtable_id: 8319
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 nd-tree : a dynamic indexing technique for multidimensional non-ordered discrete data spaces | g qian , q zhu , q xue , s pramanik | vldb    |   2003 |

Entity B:
| title                                                                                            | authors                             | venue                                                                  |   year |
|:-------------------------------------------------------------------------------------------------|:------------------------------------|:-----------------------------------------------------------------------|-------:|
| the nd-tree : a dynamic indexing technique for multidimensional non-ordered discrete data spaces | g qian , q zhu , q xue , s pramanik | proceedings of the international conference on very large & hellip ; , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2111
rtable_id: 27532
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 |
|:---------------------------------------------------------------------------|:-----------------------------------------------|:--------------|-------:|
| design and management of data warehouses : report on the dmdw '99 workshop | s gatziu , m jeusfeld , m staudt , y vassiliou | sigmod record |   1999 |

Entity B:
| title                                                                                                    | authors                                         | venue           |   year |
|:---------------------------------------------------------------------------------------------------------|:------------------------------------------------|:----------------|-------:|
| report on the 5 thinternational workshop on the design and management of data warehouses ( dmdwâ ?? 03 ) | hj lenz , p vassiliadis , m jeusfeld , m staudt | sigmod record , |   2003 |



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

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

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

Entity A:
| title                                                              | authors          | venue   |   year |
|:-------------------------------------------------------------------|:-----------------|:--------|-------:|
| exact : an extensible approach to active object-oriented databases | o dэaz , a jaime | vldb j. |   1997 |

Entity B:
| title                                                                          | authors                  | venue                                 |   year |
|:-------------------------------------------------------------------------------|:-------------------------|:--------------------------------------|-------:|
| mga : rule-based specification of active object-oriented database applications | p sawyer , i sommerville | information and software technology , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2432
rtable_id: 46596
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 |
|:------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| incremental maintenance for materialized views over semistructured data | s abiteboul , j mchugh , m rys , v vassalos , j wiener | vldb    |   1998 |

Entity B:
| title                                            | authors           | venue                                                                    |   year |
|:-------------------------------------------------|:------------------|:-------------------------------------------------------------------------|-------:|
| incremental maintenance of views with duplicates | t grin , l libkin | proceedings of the 1995 acm-sigmod international conference & hellip ; , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1558
rtable_id: 39437
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 cost model for clustered object-oriented databases | g gardarin , j gruser , z tang | vldb    |   1995 |

Entity B:
| title                         | authors                         | venue                                                                 |   year |
|:------------------------------|:--------------------------------|:----------------------------------------------------------------------|-------:|
| an object-oriented data model | c lecluse , p richard , f velez | proceedings of the acmsigmod international conference on & hellip ; , |   1988 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1981
rtable_id: 8802
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 |
|:--------------------------------------------------------------|:---------------------------------------------|:--------|-------:|
| walking through a very large virtual environment in real-time | l shou , j chionh , z huang , y ruan , k tan | vldb    |   2001 |

Entity B:
| title                                                                    | authors                                       | venue                             | year   |
|:-------------------------------------------------------------------------|:----------------------------------------------|:----------------------------------|:-------|
| walking through a very large virtual environment in real-time . 27th int | l shou , j chionh , z huang , y ruan , kl tan | conf . on very large data bases , |        |



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

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

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

Entity A:
| title                                                | authors                   | venue   |   year |
|:-----------------------------------------------------|:--------------------------|:--------|-------:|
| a new sql-like operator for mining association rules | r meo , g psaila , s ceri | vldb    |   1996 |

Entity B:
| title                               | authors               | venue                                                    | year   |
|:------------------------------------|:----------------------|:---------------------------------------------------------|:-------|
| mining generfized association rules | r srikant , r agrawal | proc . 1995 int . conf . very large data bases , zrich , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1815
rtable_id: 18752
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 |
|:-----------------------------------------------|:-------------------------------------------|:--------|-------:|
| answering queries with aggregation using views | d srivastava , s dar , h jagadish , a levy | vldb    |   1996 |

Entity B:
| title                                          | authors                                      | venue                                                                      | year   |
|:-----------------------------------------------|:---------------------------------------------|:---------------------------------------------------------------------------|:-------|
| answering sql queries using materialized views | s dar , hv jagadish , ay levy , d srivastava | proc . 22nd international conference on very large data bases & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1802
rtable_id: 62397
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 |
|:----------------------------------------|:----------|:--------|-------:|
| open object database management systems |           |         |   1994 |

Entity B:
| title                                                     | authors               | venue                          | year   |
|:----------------------------------------------------------|:----------------------|:-------------------------------|:-------|
| the architecture of an active data base management system | dr mecartny , u dayal | proc . acm sigmod , portland , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1829
rtable_id: 51042
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 index structures for string databases | t kahveci , a singh | vldb    |   2001 |

Entity B:
| title                                           | authors   | venue           |   year |
|:------------------------------------------------|:----------|:----------------|-------:|
| efficiently mining long patterns from databases | â ? ¦     | sigmod record , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1145
rtable_id: 49730
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 |
|:-----------------------------------------------|:-----------------------------|:------------------|-------:|
| meaningful change detection in structured data | s chawathe , h garcia-molina | sigmod conference |   1997 |

Entity B:
| title                            | authors                          | venue   | year   |
|:---------------------------------|:---------------------------------|:--------|:-------|
| detecting change in data streams | s ben-david , j gehrke , d kifer |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1326
rtable_id: 18044
label: 0