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 |
|:---------------------------------------------------------------|:-----------------------|:------------------|-------:|
| an effective hash based algorithm for mining association rules | j park , m chen , p yu | sigmod conference |   1995 |

Entity B:
| title                                                             | authors                   | venue                                                                    | year   |
|:------------------------------------------------------------------|:--------------------------|:-------------------------------------------------------------------------|:-------|
| an effective hash-based algorithm forming association rules [ a ] | js park , ms chen , ps yu | proceedings of the 1995 acm sigmod international conference & hellip ; , |        |



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

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

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

Entity A:
| title                                                  | authors                 | venue             |   year |
|:-------------------------------------------------------|:------------------------|:------------------|-------:|
| on parallel execution of multiple pipelined hash joins | h hsiao , m chen , p yu | sigmod conference |   1994 |

Entity B:
| title                                                           | authors                                  | venue                       | year   |
|:----------------------------------------------------------------|:-----------------------------------------|:----------------------------|:-------|
| on optimal processor allocation to support pipelined hash joins | ms chen , ml lo , cv ravishankar , ps yu | proc . of acm sigmod conf , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1771
rtable_id: 39440
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 semantic modeling approach for image retrieval by content | w chu , i ieong , r taira | vldb j. |   1994 |

Entity B:
| title                                                        | authors                                  | venue                   |   year |
|:-------------------------------------------------------------|:-----------------------------------------|:------------------------|-------:|
| an attention-based approach to content-based image retrieval | a bamidele , fwm stentiford , j morphett | bt technology journal , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2541
rtable_id: 17156
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 editorial |           |         |   2002 |

Entity B:
| title     | authors             | venue                       |   year |
|:----------|:--------------------|:----------------------------|-------:|
| editorial | d hopwood , me boon | the histochemical journal , |   1988 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2466
rtable_id: 41580
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 | a segev   | sigmod record |   1994 |

Entity B:
| title           | authors                        | venue                                      | year   |
|:----------------|:-------------------------------|:-------------------------------------------|:-------|
| editors ' notes | n van note chism , dj bickford | new directions for teaching and learning , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1000
rtable_id: 50551
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 |
|:------------------------------------------------------------------------------------------------------------|:----------------------------------|:--------|-------:|
| deadlock detection in distributed database systems : a new algorithm and a comparative performance analysis | n krivokapic , a kemper , e gudes | vldb j. |   1999 |

Entity B:
| title                                    | authors     | venue                                  |   year |
|:-----------------------------------------|:------------|:---------------------------------------|-------:|
| distributed deadlock detection algorithm | r obermarck | acm transactions on database systems , |   1982 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2383
rtable_id: 8305
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   |
|:---------------------------------------------------------------|:----------------------|:-----------------------------------------------------------|:-------|
| raccoon : a peer-based system for data integration and sharing | c li , j li , q zhong | data engineering , 2004 . proceedings . 20th international |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1944
rtable_id: 63049
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 |
|:----------------------------------------------------------|:------------------------|:------------------------------------------------------|-------:|
| an efficient algorithm for discovering frequent subgraphs | m kuramochi , g karypis | ieee transactions on knowledge and data engineering , |   2004 |



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

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

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

Entity A:
| title                                                                   | authors              | venue   |   year |
|:------------------------------------------------------------------------|:---------------------|:--------|-------:|
| dynamic pipeline scheduling for improving interactive query performance | t urhan , m franklin | vldb    |   2001 |

Entity B:
| title                                                           | authors              | venue                                                            |   year |
|:----------------------------------------------------------------|:---------------------|:-----------------------------------------------------------------|-------:|
| dynamic mobile ip and nice-tcp for improving tcp/ip performance | v vulupala , v kumar | mobile data management , 2002 . proceedings . third & hellip ; , |   2002 |



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

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

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

Entity A:
| title                                  | authors                                               | venue             |   year |
|:---------------------------------------|:------------------------------------------------------|:------------------|-------:|
| the araneus web-base management system | g mecca , p atzeni , a masci , p merialdo , g sindoni | sigmod conference |   1998 |

Entity B:
| title                                               | authors              | venue   | year   |
|:----------------------------------------------------|:---------------------|:--------|:-------|
| native xml database management systems : the survey | k chatzinas , h meng |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1264
rtable_id: 41762
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 |
|:-------------------------------------|:-----------------|:--------------|-------:|
| continuous queries over data streams | s babu , j widom | sigmod record |   2001 |

Entity B:
| title                                | authors          | venue           | year   |
|:-------------------------------------|:-----------------|:----------------|:-------|
| continuous queries over data streams | j widom , s babu | sigmod record , |        |



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

Entity B:
| title                                                   | authors                       | venue                                           | year   |
|:--------------------------------------------------------|:------------------------------|:------------------------------------------------|:-------|
| sprint : a scalable parallel classifier for data mining | cs john , r agrawal , m mehta | proc . 22nd int . conf . very large databases , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1288
rtable_id: 26660
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 |
|:----------------------------------------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| proceedings of the 2000 acm sigmod international conference on management of data , may 16-18 , 2000 , dallas , texas , usa |           |         |   2000 |

Entity B:
| title                                                         | authors               | venue                                                                    |   year |
|:--------------------------------------------------------------|:----------------------|:-------------------------------------------------------------------------|-------:|
| source international conference on management of data archive | s mehrotra , t sellis | proceedings of the 2001 acm sigmod international conference & hellip ; , |   2001 |



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

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

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

Entity A:
| title                                                                                  | authors              | venue   |   year |
|:---------------------------------------------------------------------------------------|:---------------------|:--------|-------:|
| integrating a structured-text retrieval system with an object-oriented database system | t yan , j annevelink | vldb    |   1994 |

Entity B:
| title                                              | authors   | venue               |   year |
|:---------------------------------------------------|:----------|:--------------------|-------:|
| a modular and open object-oriented database system | sm thatte | acm sigmod record , |   1991 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 203
rtable_id: 49169
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 |
|:--------------------------|:-----------------------------------|:--------|-------:|
| hyper-programming in java | e zirintsis , g kirby , r morrison | vldb    |   1999 |

Entity B:
| title                                               | authors                              | venue   | year   |
|:----------------------------------------------------|:-------------------------------------|:--------|:-------|
| demonstration of hyper-programming in javaâ ? cents | e zirintsis , gnc kirby , r morrison |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1607
rtable_id: 60567
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 logical foundation for deductive object-oriented databases | m liu , g dobbie , t ling | acm trans . database syst . |   2002 |

Entity B:
| title                                            | authors   | venue   |   year |
|:-------------------------------------------------|:----------|:--------|-------:|
| a model of queries for object-oriented databases | w kim     | vldb ,  |   1989 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2338
rtable_id: 30082
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 |
|:----------------------------------------------------------|:------------------------------------------------------------------|:--------|-------:|
| legodb : customizing relational storage for xml documents | p bohannon , j freire , j haritsa , m ramanath , p roy , j simщon | vldb    |   2002 |

Entity B:
| title                                                       | authors                                        | venue                            |   year |
|:------------------------------------------------------------|:-----------------------------------------------|:---------------------------------|-------:|
| efficient relational storage and retrieval of xml documents | a schmidt , ml kersten , m windhouwer , f waas | webdb ( informal proceedings ) , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2174
rtable_id: 29821
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 |
|:-----------------------------|:---------------|:----------------------------|-------:|
| amalgamating knowledge bases | v subrahmanian | acm trans . database syst . |   1994 |

Entity B:
| title                                      | authors                                          | venue                                               | year   |
|:-------------------------------------------|:-------------------------------------------------|:----------------------------------------------------|:-------|
| building knowledge base management systems | j my1opou , vc os , d plexousakis , a shrufi , t | technical report , the vldb journal ( to appear ) , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2303
rtable_id: 35151
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 |
|:-----------------------------------------------------------|:--------------|:----------------------------|-------:|
| optimization techniques for queries with expensive methods | j hellerstein | acm trans . database syst . |   1998 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2355
rtable_id: 6494
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 |
|:--------------------------------------------------------|:----------|:--------------|-------:|
| an annotated bibliography on real-time database systems | ж ulusoy  | sigmod record |   1995 |

Entity B:
| title                             | authors           | venue               |   year |
|:----------------------------------|:------------------|:--------------------|-------:|
| bibliography on database security | g pernul , g luef | acm sigmod record , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 859
rtable_id: 25371
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 |
|:-------------------------------------|:---------------------------------------------------|:------------------|-------:|
| minimization of tree pattern queries | s amer-yahia , s cho , l lakshmanan , d srivastava | sigmod conference |   2001 |

Entity B:
| title                                   | authors                                         | venue                                                                 |   year |
|:----------------------------------------|:------------------------------------------------|:----------------------------------------------------------------------|-------:|
| complex spatio-temporal pattern queries | m hadjieleftheriou , g kollios , p bakalov , vj | proceedings of the 31st international conference on very & hellip ; , |   2005 |



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

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

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

Entity A:
| title                      | authors            | venue   |   year |
|:---------------------------|:-------------------|:--------|-------:|
| query optimization for xml | j mchugh , j widom | vldb    |   1999 |

Entity B:
| title                                    | authors                    | venue          | year   |
|:-----------------------------------------|:---------------------------|:---------------|:-------|
| query processing and optimization in rdb | g antoshnekov , m ziauddin | vldb journal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1431
rtable_id: 25395
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 |
|:----------------------------------------------------|:----------|:--------|-------:|
| vldb workshop on technologies in e-services ( tes ) |           |         |   2000 |

Entity B:
| title                       | authors                     | venue   | year   |
|:----------------------------|:----------------------------|:--------|:-------|
| technologies for e-services | f casati , d georgakopoulos |         |        |



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

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

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

Entity A:
| title                                        | authors   | venue   |   year |
|:---------------------------------------------|:----------|:--------|-------:|
| database management systems and the internet | s malaika | vldb    |   1996 |

Entity B:
| title                               | authors   | venue                            |   year |
|:------------------------------------|:----------|:---------------------------------|-------:|
| elements of data management systems | gg dodd   | acm computing surveys ( csur ) , |   1969 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1841
rtable_id: 39128
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 |
|:-------------------------------------------------------------------------|:----------------------------------|:--------|-------:|
| rp * : a family of order preserving scalable distributed data structures | w litwin , m neimat , d schneider | vldb    |   1994 |

Entity B:
| title                                                                                              | authors   | venue                                                            | year   |
|:---------------------------------------------------------------------------------------------------|:----------|:-----------------------------------------------------------------|:-------|
| lh * g : a high-availability scalable distributed data structure through record grouping . with t. | w litwin  | res . rep. ceria , u. dauphine & u. linkoping ( may . 1997 ) . ( |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 238
rtable_id: 59034
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 |
|:---------------------------------------------------------|:----------|:----------------|-------:|
| database management systems on a multi-computer computer | m sinutko | sigmod record , |   1977 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 288
rtable_id: 15339
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 | m franklin | sigmod record |   1999 |

Entity B:
| title              | authors    | venue                                 |   year |
|:-------------------|:-----------|:--------------------------------------|-------:|
| editorâ ?? s notes | gr maughan | new directions for higher education , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 267
rtable_id: 32584
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 |
|:-------------------------------------------------------------------------|:----------|:--------|-------:|
| versioning and configuration management in an object-oriented data model | e sciore  | vldb j. |   1994 |

Entity B:
| title                                                   | authors          | venue                                                     | year   |
|:--------------------------------------------------------|:-----------------|:----------------------------------------------------------|:-------|
| transaction management in an object-oriented data model | jf garza , w kim | proceedings of the acm sigmod international conference on |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2559
rtable_id: 25595
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 |
|:------------------------------------------------------------------------------------------------------|:---------------------|:--------|-------:|
| optimal grid-clustering : towards breaking the curse of dimensionality in high-dimensional clustering | a hinneburg , d keim | vldb    |   1999 |

Entity B:
| title                                                                         | authors                           | venue                                                        | year   |
|:------------------------------------------------------------------------------|:----------------------------------|:-------------------------------------------------------------|:-------|
| the pyramid-technique : towards breaking the curse of dimensional data spaces | s berchtold , d keim , hp kriegel | proc . acm sigmod int . conf . managment of data , seattle , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1418
rtable_id: 14294
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 |
|:----------------------------------------|:----------|:--------------|-------:|
| theory of answering queries using views | a halevy  | sigmod record |   2000 |

Entity B:
| title                             | authors                                      | venue            | year   |
|:----------------------------------|:---------------------------------------------|:-----------------|:-------|
| answering sql queries using views | s dar , hv jagadish , ay levy , d srivastava | proc . of vldb , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 336
rtable_id: 7510
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 |
|:-----------------------------------------------------------------------------------------|:----------|:--------|-------:|
| report on the nsf workshop on building an infrastructure for mobile and wireless systems |           |         |   2002 |

Entity B:
| title                                            | authors   | venue                   |   year |
|:-------------------------------------------------|:----------|:------------------------|-------:|
| venture leader for mobility and wireless systems | p smyth   | bt technology journal , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 10
rtable_id: 27763
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 efficient algorithm for mining association rules in large databases | a savasere , e omiecinski , s navathe | vldb    |   1995 |

Entity B:
| title                                                           | authors          | venue   |   year |
|:----------------------------------------------------------------|:-----------------|:--------|-------:|
| algorithms for mining distance-based outliers in large datasets | em knorr , rt ng | vldb ,  |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 30360
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-topss - a publish/subscribe system supporting approximate matching | h liu , h jacobsen | vldb    |   2002 |

Entity B:
| title                                               | authors                             | venue                            |   year |
|:----------------------------------------------------|:------------------------------------|:---------------------------------|-------:|
| s-topss : semantic toronto publish/subscribe system | m petrovic , i burcea , ha jacobsen | arxiv preprint cs.dc / 0311041 , |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2170
rtable_id: 42308
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 |
|:-----------------------------|:----------|:--------|-------:|
| e-services - guest editorial |           |         |   2001 |

Entity B:
| title     | authors                 | venue                   |   year |
|:----------|:------------------------|:------------------------|-------:|
| editorial | pd o'brien , pj kearney | bt technology journal , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2500
rtable_id: 49692
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 |
|:------------------------------------------------------------------------------------------|:-----------------------------------------------------|:------------------|-------:|
| aqr-toolkit : an adaptive query routing middleware for distributed data intensive systems | l liu , c pu , d buttler , w han , h paques , w tang | sigmod conference |   2000 |

Entity B:
| title                                                    | authors                                            | venue               | year   |
|:---------------------------------------------------------|:---------------------------------------------------|:--------------------|:-------|
| an adaptive query processing system for data integration | z ives , d florescu , m friedman , a levy , d weld | proc . acm sigmod , |        |



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

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

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

Entity A:
| title                                                                                             | authors            | venue                       |   year |
|:--------------------------------------------------------------------------------------------------|:-------------------|:----------------------------|-------:|
| semantics for update rule programs and implementations in a relational database management system | l raschid , j lobo | acm trans . database syst . |   1996 |

Entity B:
| title                                          | authors    | venue                                   | year   |
|:-----------------------------------------------|:-----------|:----------------------------------------|:-------|
| analytic models for database management system | i miyamoto | proc . of int . conf . on vldb , sept , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2272
rtable_id: 35825
label: 0