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 |
|:-------------------------------------------|:-----------------------------------|:--------------|-------:|
| open issues in parallel query optimization | w hasan , d florescu , p valduriez | sigmod record |   1996 |

Entity B:
| title                            | authors           | venue                                                              | year   |
|:---------------------------------|:------------------|:-------------------------------------------------------------------|:-------|
| dynamic query optimization plans | g graefe , k ward | proceedings of acm-sigmod international conference on & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 652
rtable_id: 12140
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 |
|:-----------------------------------------|:------------------------------------------------------|:------------------|-------:|
| algorithms for deferred view maintenance | l colby , t griffin , l libkin , i mumick , h trickey | sigmod conference |   1996 |

Entity B:
| title                                    | authors                                     | venue               |   year |
|:-----------------------------------------|:--------------------------------------------|:--------------------|-------:|
| algorithms for deferred view maintenance | ls colby , l libkin , is mumick , h trickey | sigmod conference , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1464
rtable_id: 43941
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 |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------------|:--------|-------:|
| implementation of two semantic query optimization techniques in db2 universal database | q cheng , j gryz , f koo , t leung , l liu , x qian , k schiefer | vldb    |   1999 |

Entity B:
| title                                                                 | authors                  | venue   |   year |
|:----------------------------------------------------------------------|:-------------------------|:--------|-------:|
| heterogeneous database query optimization in db2 universal datajoiner | s venkataraman , t zhang | vldb ,  |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1616
rtable_id: 24884
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 |
|:--------------------------------------------|:----------|:----------------------------|-------:|
| declarative updates of relational databases | w chen    | acm trans . database syst . |   1995 |

Entity B:
| title                                                    | authors                                           | venue               | year   |
|:---------------------------------------------------------|:--------------------------------------------------|:--------------------|:-------|
| updating relational databases through object-based views | a keller , t barsalou , n siambela , g wiederhold | proc . acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2249
rtable_id: 19950
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 |
|:----------------------------------------------|:-----------------------------------------------|:------------------|-------:|
| view maintenance in a warehousing environment | y zhuge , h garcia-molina , j hammer , j widom | sigmod conference |   1995 |

Entity B:
| title                                                                               | authors                      | venue   | year   |
|:------------------------------------------------------------------------------------|:-----------------------------|:--------|:-------|
| tackling the challenges of materialized view design in data warehousing environment | j yang , k karlapalem , q li |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1612
rtable_id: 34235
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 of externally materialized views | m staudt , m jarke | vldb    |   1996 |

Entity B:
| title                                                    | authors            | venue   |   year |
|:---------------------------------------------------------|:-------------------|:--------|-------:|
| incremental maintenance of externally materialized views | m staudt , m jarke | vldb ,  |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1830
rtable_id: 25298
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 |
|:-------------------------------------------------------------------------|:---------------------|:------------------|-------:|
| temporal conditions and integrity constraints in active database systems | a sistla , o wolfson | sigmod conference |   1995 |

Entity B:
| title                                    | authors   | venue               | year   |
|:-----------------------------------------|:----------|:--------------------|:-------|
| temporal database system implementations | mh bohlen | acm sigmod record , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1610
rtable_id: 7509
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 distance join algorithms for spatial databases | g hjaltason , h samet | sigmod conference |   1998 |

Entity B:
| title                                   | authors   | venue   |   year |
|:----------------------------------------|:----------|:--------|-------:|
| algorithms for loading object databases | jl wiener |         |   1995 |



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

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

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

Entity A:
| title                                       | authors                | venue         |   year |
|:--------------------------------------------|:-----------------------|:--------------|-------:|
| mining fuzzy association rules in databases | c kuok , a fu , m wong | sigmod record |   1998 |

Entity B:
| title                                                   | authors     | venue   | year   |
|:--------------------------------------------------------|:------------|:--------|:-------|
| metric operations on fuzzy spatial objects in databases | m schneider |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 612
rtable_id: 15843
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 |
|:--------------------------------------------|:---------------------------------|:------------------|-------:|
| fault tolerant design of multimedia servers | s berson , l golubchik , r muntz | sigmod conference |   1995 |

Entity B:
| title                                                     | authors                                  | venue               |   year |
|:----------------------------------------------------------|:-----------------------------------------|:--------------------|-------:|
| fault-tolerant architectures for continuous media servers | , r rastogi , pj shenoy , a silberschatz | sigmod conference , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1559
rtable_id: 6969
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 |
|:---------------------------------------------------------------------|:--------------------------------------|:----------------------------------------------------------------------|-------:|
| tracking set-expression cardinalities over continuous update streams | s ganguly , m garofalakis , r rastogi | the vldb journal the international journal on very large & hellip ; , |   2004 |



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

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

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

Entity A:
| title                                                      | authors                          | venue   |   year |
|:-----------------------------------------------------------|:---------------------------------|:--------|-------:|
| the tv-tree : an index structure for high-dimensional data | k lin , h jagadish , c faloutsos | vldb j. |   1994 |

Entity B:
| title                                                                            | authors               | venue                        | year   |
|:---------------------------------------------------------------------------------|:----------------------|:-----------------------------|:-------|
| hans-peter . kriegel . the x-tree : an index structure for high-dimensional data | s berchtold , da keim | proceedings of the 22nd vldb |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2560
rtable_id: 57612
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 |
|:--------------------------------------------------------------|:--------------------------------------------------------|:--------|-------:|
| declarative data cleaning : language , model , and algorithms | h galhardas , d florescu , d shasha , e simon , c saita | vldb    |   2001 |

Entity B:
| title                                        | authors                                           | venue                                       | year   |
|:---------------------------------------------|:--------------------------------------------------|:--------------------------------------------|:-------|
| declarative data cleaning : language , model | h galhardas , d florescu , d shasha , e simon , c | and algorithms . technical report , inria , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1142
rtable_id: 6050
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 |
|:---------------------------------------------------|:---------------------|:--------|-------:|
| secure bufering in firm real-time database systems | b george , j haritsa | vldb j. |   2000 |

Entity B:
| title                                                       | authors                              | venue               |   year |
|:------------------------------------------------------------|:-------------------------------------|:--------------------|-------:|
| applying update streams in a soft real-time database system | b adelberg , h garcia-molina , b kao | sigmod conference , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2400
rtable_id: 40093
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 |
|:------------------------------------------------|:------------------------------------------------|:--------|-------:|
| caching strategies for data-intensive web sites | k yagoub , d florescu , v issarny , p valduriez | vldb    |   2000 |

Entity B:
| title                                          | authors                              | venue           |   year |
|:-----------------------------------------------|:-------------------------------------|:----------------|-------:|
| design principles for data-intensive web sites | s ceri , p fraternali , s paraboschi | sigmod record , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1203
rtable_id: 45999
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 |
|:-----------------------------------------------------------|:--------------------|:--------|-------:|
| coloring away communication in parallel query optimization | w hasan , r motwani | vldb    |   1995 |

Entity B:
| title                                              | authors   | venue   | year   |
|:---------------------------------------------------|:----------|:--------|:-------|
| scheduling problems in parallel query optimization | c chekuri |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1969
rtable_id: 31084
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 of views with duplicates | t griffin , l libkin | sigmod conference |   1995 |

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: 1
original: ltable_id: 1618
rtable_id: 39437
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 |
|:----------------------------------------------|:------------|:------------------|-------:|
| efficient execution of joins in a star schema | a weininger | sigmod conference |   2002 |

Entity B:
| title                                         | authors     | venue   | year   |
|:----------------------------------------------|:------------|:--------|:-------|
| efficient execution of joins in a star schema | a weininger |         |        |



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

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

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

Entity A:
| title                                            | authors   | venue   |   year |
|:-------------------------------------------------|:----------|:--------|-------:|
| index configuration in object-oriented databases | e bertino | vldb j. |   1994 |

Entity B:
| title                                              | authors   | venue           |   year |
|:---------------------------------------------------|:----------|:----------------|-------:|
| converting relational to object-oriented databases | j fong    | sigmod record , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2564
rtable_id: 1043
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 of queries with user-defined predicates | s chaudhuri , k shim | acm trans . database syst . |   1999 |

Entity B:
| title                                        | authors              | venue                       | year   |
|:---------------------------------------------|:---------------------|:----------------------------|:-------|
| optimization and evaluation of array queries | r ritsch , p baumann | submitted for publication , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2374
rtable_id: 59439
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 at the crossroads ( panel ) | s chaudhuri | sigmod conference |   1997 |

Entity B:
| title                                                  | authors     | venue                                                | year   |
|:-------------------------------------------------------|:------------|:-----------------------------------------------------|:-------|
| query optimization at the crossroads ( panel session ) | s chaudhuri | proc . 1997 acm sigmod int . conf . on management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1377
rtable_id: 50973
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 |
|:--------------------------------------------------------------|:--------------------------------|:------------------|-------:|
| dbxplorer : enabling keyword search over relational databases | s agrawal , s chaudhuri , g das | sigmod conference |   2002 |

Entity B:
| title                                    | authors   | venue                                 |   year |
|:-----------------------------------------|:----------|:--------------------------------------|-------:|
| object systems over relational databases | mk crowe  | information and software technology , |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 9979
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 |
|:----------------------------------------------------|:--------------------|:--------|-------:|
| maintaining data privacy in association rule mining | s rizvi , j haritsa | vldb    |   2002 |

Entity B:
| title                                                         | authors            | venue   | year   |
|:--------------------------------------------------------------|:-------------------|:--------|:-------|
| eect of data skewness in parallel mining of association rules | dw cheung , y xiao |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2126
rtable_id: 54663
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 |
|:----------------------------------------------------------------|:---------------------------------------------|:--------------|-------:|
| energy and rate based mac protocol for wireless sensor networks | r kannan , r kalidindi , s iyengar , v kumar | sigmod record |   2003 |

Entity B:
| title                                                     | authors          | venue   | year   |
|:----------------------------------------------------------|:-----------------|:--------|:-------|
| a multi-channel mac protocol for ad hoc wireless networks | j so , nh vaidya |         |        |



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

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

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

Entity A:
| title                                 | authors                       | venue   |   year |
|:--------------------------------------|:------------------------------|:--------|-------:|
| streaming queries over streaming data | s chandrasekaran , m franklin | vldb    |   2002 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2212
rtable_id: 4298
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 research at nthu and itri | a chen    | sigmod record |   1994 |

Entity B:
| title                                  | authors                                         | venue               |   year |
|:---------------------------------------|:------------------------------------------------|:--------------------|-------:|
| selected database research at stanford | a keller , p rathmann , j ullman , g wiederhold | acm sigmod record , |   1990 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 973
rtable_id: 13533
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 |
|:-----------------------------------------------------------------------------------------------------|:-----------------------------------|:--------------|-------:|
| management of data and services in the environmental information system ( uis ) of baden-wќrttemberg | w riekert , r mayer-fіll , g wiest | sigmod record |   1997 |

Entity B:
| title                                                                 | authors   | venue                                      |   year |
|:----------------------------------------------------------------------|:----------|:-------------------------------------------|-------:|
| managing information resources and services in a distance environment | rs tolsma | new directions for teaching and learning , |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 718
rtable_id: 45464
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 |
|:-----------------------------------------------------------------------------------------------|:----------------------------------------------------------|:--------|-------:|
| algorithms for mining association rules for binary segmentations of huge categorical databases | y morimoto , t fukuda , h matsuzawa , t tokuyama , k yoda | vldb    |   1998 |

Entity B:
| title                                                                       | authors                         | venue                                                                    | year   |
|:----------------------------------------------------------------------------|:--------------------------------|:-------------------------------------------------------------------------|:-------|
| fast algorithm to find frequent item . sets for mining of association rules | xp du , k kaneko , a makinouchi | proc . int conf info society in the 21st century : emerging & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1640
rtable_id: 14087
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 algorithms for processing xpath queries | g gottlob , c koch , r pichler | vldb    |   2002 |

Entity B:
| title                                       | authors                        | venue   | year   |
|:--------------------------------------------|:-------------------------------|:--------|:-------|
| blas : an efficient xpath processing system | y chen , sb davidson , y zheng |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2188
rtable_id: 51162
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 rules | d stirling | sigmod record |   2003 |

Entity B:
| title                             | authors                                            | venue                                                                    | year   |
|:----------------------------------|:---------------------------------------------------|:-------------------------------------------------------------------------|:-------|
| informationorganizationusingrufus | p schwartz , a luniewski , k shoens , j stamosetal | inproceedings of the acm sigmod conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1960
rtable_id: 39844
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 |
|:---------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| schema and database evolution in the o2 object database system | f ferrandina , t meyer , r zicari , g ferran , j madec | vldb    |   1995 |

Entity B:
| title                                | authors   | venue   | year   |
|:-------------------------------------|:----------|:--------|:-------|
| standardization and database systems | eh sibley | vldb ,  |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 5
rtable_id: 61919
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 |
|:-------------------------------------------------------------------------------------------|:---------------------------|:------------------|-------:|
| parallel mining algorithms for generalized association rules with classification hierarchy | t shintani , m kitsuregawa | sigmod conference |   1998 |

Entity B:
| title                                | authors               | venue   | year   |
|:-------------------------------------|:----------------------|:--------|:-------|
| parallel mining of association rules | r agrawal , jc shafer |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1213
rtable_id: 3053
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 |
|:---------------------------------|:-------------------------------------------|:------------------|-------:|
| energy efficient indexing on air | t imielinski , s viswanathan , b badrinath | sigmod conference |   1994 |

Entity B:
| title                          | authors                                    | venue                                                                    | year   |
|:-------------------------------|:-------------------------------------------|:-------------------------------------------------------------------------|:-------|
| energy e cient indexing on air | t imielinski , s viswanathan , b badrinath | proc . acm sigmod international conference on management of & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1707
rtable_id: 20303
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 |
|:-----------------------------------------------------------------|:----------------------------------|:--------|-------:|
| implementing lazy database updates for an object database system | f ferrandina , t meyer , r zicari | vldb    |   1994 |

Entity B:
| title                                                 | authors                                         | venue                                                              |   year |
|:------------------------------------------------------|:------------------------------------------------|:-------------------------------------------------------------------|-------:|
| implementation of the coral deductive database system | r ramakrishnan , d srivastava , s sudarshan , p | proceedings of acm sigmod international conference on & hellip ; , |   1993 |



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

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

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

Entity A:
| title                                                                    | authors                  | venue         |   year |
|:-------------------------------------------------------------------------|:-------------------------|:--------------|-------:|
| performance evaluation of a new distributed deadlock detection algorithm | c yeung , s hung , k lam | sigmod record |   1994 |

Entity B:
| title                                                       | authors                            | venue                                  |   year |
|:------------------------------------------------------------|:-----------------------------------|:---------------------------------------|-------:|
| performance evaluation of attribute-based tree organization | v gopalakrishna , ce veni madhavan | acm transactions on database systems , |   1980 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1015
rtable_id: 9659
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 |
|:---------------------------------------------------------------|:------------------------------------------------------------------------------------|:--------|-------:|
| banks : browsing and keyword searching in relational databases | b aditya , g bhalotia , s chakrabarti , a hulgeri , c nakhe , p parag , s sudarshan | vldb    |   2002 |

Entity B:
| title                                         | authors                        | venue                                                                    |   year |
|:----------------------------------------------|:-------------------------------|:-------------------------------------------------------------------------|-------:|
| joining interval data in relational databases | j enderle , m hampel , t seidl | proceedings of the 2004 acm sigmod international conference & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2161
rtable_id: 45579
label: 0