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 |
|:----------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| the mlpq/gis constraint database system | p revesz , r chen , p kanjamala , y li , y liu , y wang | sigmod conference |   2000 |

Entity B:
| title                                        | authors                                              | venue                                              | year   |
|:---------------------------------------------|:-----------------------------------------------------|:---------------------------------------------------|:-------|
| the ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j | proc . acm sigmod int &#39; l conf . management of |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 899
rtable_id: 53104
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 |
|:--------------------------------------------------------------|:---------------------------|:----------------------------|-------:|
| tracing the lineage of view data in a warehousing environment | y cui , j widom , j wiener | acm trans . database syst . |   2000 |

Entity B:
| title                                                         | authors                     | venue                                                            | year   |
|:--------------------------------------------------------------|:----------------------------|:-----------------------------------------------------------------|:-------|
| tracing the lineage of vlew data in a warehousing environment | y cui , j widom , jl wiener | technical report , stanford university database group , november |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2312
rtable_id: 29125
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 magic-sets in a relational database system | i mumick , h pirahesh | sigmod conference |   1994 |

Entity B:
| title                                                                         | authors           | venue         | year   |
|:------------------------------------------------------------------------------|:------------------|:--------------|:-------|
| cost estimation of user-defined methods in object-relational database systems | b jihad , o kinji | sigmod record |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1749
rtable_id: 4663
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 |
|:----------------------------------------------|:-------------------------------|:------------------|-------:|
| xsb as an efficient deductive database engine | k sagonas , t swift , d warren | sigmod conference |   1994 |

Entity B:
| title                       | authors                         | venue                                                                    |   year |
|:----------------------------|:--------------------------------|:-------------------------------------------------------------------------|-------:|
| xsb as a deductive database | k sagonas , t swift , ds warren | proceedings of the 1994 acm sigmod international conference & hellip ; , |   1994 |



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

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

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

Entity A:
| title           | authors    | venue         |   year |
|:----------------|:-----------|:--------------|-------:|
| editor 's notes | m franklin | sigmod record |   1999 |

Entity B:
| title           | authors               | venue                                   |   year |
|:----------------|:----------------------|:----------------------------------------|-------:|
| editors ' notes | r picciotto , rc rist | new directions for program evaluation , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 267
rtable_id: 57406
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 |           |         |   2003 |

Entity B:
| title     | authors                 | venue                   |   year |
|:----------|:------------------------|:------------------------|-------:|
| editorial | m shackleton , p marrow | bt technology journal , |   2000 |



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

Entity B:
| title                             | authors   | venue                                                                    |   year |
|:----------------------------------|:----------|:-------------------------------------------------------------------------|-------:|
| standard for multimedia databases | jr smith  | proceedings of the 2001 acm sigmod international conference & hellip ; , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2396
rtable_id: 24966
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 |
|:---------------------------------------------------------------------------------|:----------|:--------|-------:|
| computing complete answers to queries in the presence of limited access patterns | c li      | vldb j. |   2003 |

Entity B:
| title                                                        | authors              | venue                       |   year |
|:-------------------------------------------------------------|:---------------------|:----------------------------|-------:|
| processing first-order queries under limited access patterns | a nash , b ludascher | submitted for publication , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2289
rtable_id: 41072
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 |
|:-------------------------------------------------------------------------------------|:--------------------|:--------|-------:|
| aquery : query language for ordered data , optimization techniques , and experiments | a lerner , d shasha | vldb    |   2003 |

Entity B:
| title                                                    | authors                           | venue                                  |   year |
|:---------------------------------------------------------|:----------------------------------|:---------------------------------------|-------:|
| an implementation technique for database query languages | p buneman , re frankel , r nikhil | acm transactions on database systems , |   1982 |



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

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

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

Entity A:
| title            | authors   | venue   |   year |
|:-----------------|:----------|:--------|-------:|
| chair 's message |           |         |   2002 |

Entity B:
| title                | authors   | venue   |   year |
|:---------------------|:----------|:--------|-------:|
| treasurer 's message | j hammer  | sigmod  |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 52
rtable_id: 45743
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 survey of approaches to automatic schema matching | e rahm , p bernstein | vldb j. |   2001 |

Entity B:
| title                                        | authors               | venue   | year   |
|:---------------------------------------------|:----------------------|:--------|:-------|
| a survey of schema-based matching approaches | p shvaiko , j euzenat |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2490
rtable_id: 2045
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   |
|:------------------|:--------------|:--------|:-------|
| management system | csd recording |         |        |



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

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

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

Entity A:
| title                                                                     | authors                                         | venue             |   year |
|:--------------------------------------------------------------------------|:------------------------------------------------|:------------------|-------:|
| the algres testbed of chimera : an active object-oriented database system | s ceri , p fraternali , s paraboschi , g psaila | sigmod conference |   1995 |

Entity B:
| title                                        | authors    | venue                                                              |   year |
|:---------------------------------------------|:-----------|:-------------------------------------------------------------------|-------:|
| a survey of object oriented database systems | rw thearle | conference proceedings on data management 91 table of & hellip ; , |   1992 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1683
rtable_id: 44760
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 |
|:-----------------------------------------------------|:--------------------------------------|:------------------|-------:|
| concurrency and recovery in generalized search trees | m kornacker , c mohan , j hellerstein | sigmod conference |   1997 |

Entity B:
| title                                                | authors                              | venue              | year   |
|:-----------------------------------------------------|:-------------------------------------|:-------------------|:-------|
| concurrency and recovery in generalized search trees | m komacker , c mohan , j hellerstein | proc . of sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1240
rtable_id: 48100
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 |
|:---------------------------------------------|:----------|:--------------|-------:|
| building database-driven electronic catalogs | s danish  | sigmod record |   1998 |

Entity B:
| title                                        | authors   | venue           |   year |
|:---------------------------------------------|:----------|:----------------|-------:|
| building database-driven electronic catalogs | s danish  | sigmod record , |   1998 |



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

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

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

Entity A:
| title                                        | authors                                                                             | venue             |   year |
|:---------------------------------------------|:------------------------------------------------------------------------------------|:------------------|-------:|
| the ores temporal database management system | b theodoulidis , a ait-braham , g andrianopoulos , j chaudhary , g karvelis , s sou | sigmod conference |   1994 |

Entity B:
| title                                                                 | authors                                 | venue                       |   year |
|:----------------------------------------------------------------------|:----------------------------------------|:----------------------------|-------:|
| texor : temporal xml database on an object-relational database system | k nã ¸ rvag , m limstrand , l myklebust | submitted for publication , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1840
rtable_id: 17297
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 |
|:--------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| research activities in database management and information retrieval at the university of illinois at chicago | i cruz , a khokhar , b liu , a sistla , o wolfson , c yu | sigmod record |   2002 |

Entity B:
| title                                                               | authors                                               | venue           |   year |
|:--------------------------------------------------------------------|:------------------------------------------------------|:----------------|-------:|
| database research at the university of illinois at urbana-champaign | m winslett , kcc chang , ah doan , j han , c zhai , y | sigmod record , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 44
rtable_id: 51641
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 |
|:----------|:----------|:--------|-------:|
| editorial |           |         |   2001 |

Entity B:
| title           | authors   | venue              |   year |
|:----------------|:----------|:-------------------|-------:|
| guest editorial | rc holte  | machine learning , |   2001 |



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

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

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

Entity A:
| title                                                  | authors                       | venue                       |   year |
|:-------------------------------------------------------|:------------------------------|:----------------------------|-------:|
| formal query languages for secure relational databases | m winslett , k smith , x qian | acm trans . database syst . |   1994 |

Entity B:
| title                                            | authors   | venue   | year   |
|:-------------------------------------------------|:----------|:--------|:-------|
| example-based graphical database query languages | , h wang  |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2310
rtable_id: 16029
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 performance evaluation of oid mapping techniques | a eickler , c gerlhof , d kossmann | vldb    |   1995 |

Entity B:
| title                                                        | authors     | venue   | year   |
|:-------------------------------------------------------------|:------------|:--------|:-------|
| a performance evaluation of alternative xml document schemas | pf sullivan |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1921
rtable_id: 11938
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 introduction to spatial database systems | r gќting  | vldb j. |   1994 |

Entity B:
| title                                              | authors                                               | venue                                                                    |   year |
|:---------------------------------------------------|:------------------------------------------------------|:-------------------------------------------------------------------------|-------:|
| data densification in a relational database system | a gupta , s subramanian , s bellamkonda , t bozkaya , | proceedings of the 2004 acm sigmod international conference & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2538
rtable_id: 15491
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 |
|:---------------------------------------------------------------------|:-----------------------------------------------------------------|:--------|-------:|
| business-to-business interactions : issues and enabling technologies | b medjahed , b benatallah , a bouguettaya , a ngu , a elmagarmid | vldb j. |   2003 |

Entity B:
| title                                                 | authors                                              | venue              | year   |
|:------------------------------------------------------|:-----------------------------------------------------|:-------------------|:-------|
| b 2 b interactions : issues and enabling technologies | b medjahed , b benatalla , a bouguettaya , ahh ngu , | the vldb journal , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2460
rtable_id: 35060
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 |
|:----------------------------------------------------|:-----------------------------|:------------------|-------:|
| wavelet-based histograms for selectivity estimation | y matias , j vitter , m wang | sigmod conference |   1998 |

Entity B:
| title                                                                   | authors   | venue                                                                  |   year |
|:------------------------------------------------------------------------|:----------|:-----------------------------------------------------------------------|-------:|
| bloom histogram : path selectivity estimation for xml data with updates | w wang    | proceedings of the international conference on very large & hellip ; , |   2004 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1172
rtable_id: 49327
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 caching and optimization in distributed mediator systems | s adali , k candan , y papakonstantinou , v subrahmanian | sigmod conference |   1996 |

Entity B:
| title                                                 | authors         | venue   |   year |
|:------------------------------------------------------|:----------------|:--------|-------:|
| distributed query optimization using two-step pruning | k hyeokmanâ ? ¦ |         |   1997 |



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

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

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

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

Entity B:
| title                                         | authors                         | venue                                | year   |
|:----------------------------------------------|:--------------------------------|:-------------------------------------|:-------|
| query optimization in heterogeneous databases | w du , r krishnamurthy , m shan | proc . vldb conference , vancouver , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2256
rtable_id: 23585
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 |
|:----------------------------------------------|:----------------------|:------------------|-------:|
| temporal aggregation in active database rules | i motakis , c zaniolo | sigmod conference |   1997 |

Entity B:
| title              | authors             | venue           | year   |
|:-------------------|:--------------------|:----------------|:-------|
| temporal databases | i ahn , r snodgrass | ieee computer , |        |



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

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

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

Entity A:
| title           | authors   | venue         |   year |
|:----------------|:----------|:--------------|-------:|
| editor 's notes | l liu     | sigmod record |   2002 |

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: 115
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 |
|:----------------------------------------------|:-----------------------------------------|:------------------|-------:|
| efficient view maintenance at data warehouses | d agrawal , a abbadi , a singh , t yurek | sigmod conference |   1997 |

Entity B:
| title                                                        | authors                              | venue                                       | year   |
|:-------------------------------------------------------------|:-------------------------------------|:--------------------------------------------|:-------|
| andj . widom . view maintenance in a warehousing environment | y zhuge , h garcia-molina , j hammer | proceedings of acm sigmod conference ( june |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1341
rtable_id: 47632
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 |
|:------------------------------------------------------------------------|:---------------------|:--------------|-------:|
| timer-driven database triggers and alerters : semantics and a challenge | e hanson , l noronha | sigmod record |   1999 |

Entity B:
| title                                                                   | authors               | venue           |   year |
|:------------------------------------------------------------------------|:----------------------|:----------------|-------:|
| timer-driven database triggers and alerters : semantics and a challenge | en hanson , l noronha | sigmod record , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 499
rtable_id: 17509
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 structured approach for the definition of the semantics of active databases | p fraternali , l tanca | acm trans . database syst . |   1995 |

Entity B:
| title                                                     | authors   | venue   | year   |
|:----------------------------------------------------------|:----------|:--------|:-------|
| interactive query formulation in semistructured databases | a trigoni |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2263
rtable_id: 53098
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 |
|:-----------------------------------------------------------------------|:----------------------|:----------------------------|-------:|
| searching in metric spaces with user-defined and approximate distances | p ciaccia , m patella | acm trans . database syst . |   2002 |

Entity B:
| title                                        | authors   | venue   |   year |
|:---------------------------------------------|:----------|:--------|-------:|
| truth and approximate truth in metric spaces | ce ortiz  |         |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 935
rtable_id: 20775
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 |
|:------------------------------------------------------|:--------------------------------------------|:------------------|-------:|
| continuously adaptive continuous queries over streams | s madden , m shah , j hellerstein , v raman | sigmod conference |   2002 |

Entity B:
| title                                       | authors   | venue               | year   |
|:--------------------------------------------|:----------|:--------------------|:-------|
| survey : continuous query over data streams | s rahul   | acm sigmod record , |        |



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

Entity B:
| title                                                | authors        | venue                                                                 | year   |
|:-----------------------------------------------------|:---------------|:----------------------------------------------------------------------|:-------|
| srikant . fast algorithmsformining association rules | r agrawal andr | proceedings of the 20th international conference on very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 95
rtable_id: 3210
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 |
|:----------------------------------------------------------|:--------------------------------------------------------------------------------------------------------|:--------|-------:|
| information integration : the momis project demonstration | d beneventano , s bergamaschi , s castano , a corni , r guidetti , g malvezzi , m melchiori , m vincini | vldb    |   2000 |

Entity B:
| title                                 | authors   | venue                                                          | year   |
|:--------------------------------------|:----------|:---------------------------------------------------------------|:-------|
| the information integration system k2 | v tannen  | bioinformatics : managing scientific data , t. critchlow and z |        |



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

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

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

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

Entity B:
| title           | authors   | venue                          |   year |
|:----------------|:----------|:-------------------------------|-------:|
| guest editorial | h simon   | public administration review , |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2588
rtable_id: 27909
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 |
|:--------------------------------------------|:------------------------------|:--------|-------:|
| is web-site management a database problem ? | d florescu , a levy , d suciu | vldb    |   1998 |

Entity B:
| title                                  | authors   | venue   |   year |
|:---------------------------------------|:----------|:--------|-------:|
| multimedia database management systems | g lu      |         |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1776
rtable_id: 50005
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 |
|:------------------------------------------------------|:--------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | i ilyas , w aref , a elmagarmid | vldb    |   2003 |

Entity B:
| title                                                        | authors                    | venue                                                                  |   year |
|:-------------------------------------------------------------|:---------------------------|:-----------------------------------------------------------------------|-------:|
| querying multiple features of groups in relational databases | d chatziantoniou , ka ross | proceedings of the international conference on very large & hellip ; , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2005
rtable_id: 468
label: 0