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 |
|:------------------------------------------------|:--------------------|:--------|-------:|
| efficient index structures for string databases | t kahveci , a singh | vldb    |   2001 |

Entity B:
| title                                       | authors                 | venue                                           |   year |
|:--------------------------------------------|:------------------------|:------------------------------------------------|-------:|
| efficiently monitoring relational databases | op buneman , ek clemons | acm transactions on database systems ( tods ) , |   1979 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1145
rtable_id: 19222
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 general techniques for querying xml documents using a relational database system | j shanmugasundaram , e shekita , j kiernan , r krishnamurthy , s viglas , j naughton , i tatarinov | sigmod record |   2001 |

Entity B:
| title                                                                                      | authors                          | venue                                                      | year   |
|:-------------------------------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------|:-------|
| relational databases for querying xml documents : limitations and opportunities . vldb '99 | j shanmugasundaram , h gangâ ? ¦ | proceedings of 25th international conference on very large |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 182
rtable_id: 33250
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 |
|:---------------------------------------|:-----------|:--------------|-------:|
| knowledge discovery in data warehouses | t palpanas | sigmod record |   2000 |

Entity B:
| title                                               | authors                                      | venue                                                                              |   year |
|:----------------------------------------------------|:---------------------------------------------|:-----------------------------------------------------------------------------------|-------:|
| controlling data warehouses with knowledge networks | e schaefer , jd becker , a boehmer , m jarke | & hellip ; international conference on very large data bases table of & hellip ; , |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 293
rtable_id: 6260
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 |
|:-----------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| aurora : a data stream management system | d abadi , d carney , u чetintemel , m cherniack , c convey , c erwin , e galvez , m hatoun , a maskey , a rasin , a singer , m stonebraker , n tatbul , y xing , r yan , s zdonik | sigmod conference |   2003 |

Entity B:
| title                                               | authors                                                 | venue   | year   |
|:----------------------------------------------------|:--------------------------------------------------------|:--------|:-------|
| stream : the stanford data stream management system | a arasu , b babcock , s babu , j cieslewicz , m datar , |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 280
rtable_id: 28876
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 quantitative association rules in large relational tables | r srikant , r agrawal | sigmod conference |   1996 |

Entity B:
| title                                                             | authors               | venue                                                                 | year   |
|:------------------------------------------------------------------|:----------------------|:----------------------------------------------------------------------|:-------|
| fast algorithms for mining association rules in large datab as es | r agrawal , r srikant | proceedings of the 20th international conference on very & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1439
rtable_id: 45920
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 |
|:---------------------------------------------------------------------|:-----------------------------------|:------------------|-------:|
| birch : an efficient data clustering method for very large databases | t zhang , r ramakrishnan , m livny | sigmod conference |   1996 |

Entity B:
| title                                                        | authors                             | venue               | year   |
|:-------------------------------------------------------------|:------------------------------------|:--------------------|:-------|
| an efficient data clustering method for very large databases | t zhang , r ramakrishnan , mb livny | proc . acm sigmod , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1419
rtable_id: 42678
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 | j widom   | sigmod record |   1996 |

Entity B:
| title           | authors   | venue                                                                    | year   |
|:----------------|:----------|:-------------------------------------------------------------------------|:-------|
| editor 's notes | tw banta  | implementing outcomes assessment : promise and perils . new & hellip ; , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 661
rtable_id: 16311
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 |
|:----------------------------------------------------|:-------------------------------------------------|:----------------------------|-------:|
| probview : a flexible probabilistic database system | l lakshmanan , n leone , r ross , v subrahmanian | acm trans . database syst . |   1997 |

Entity B:
| title                                 | authors                  | venue   |   year |
|:--------------------------------------|:-------------------------|:--------|-------:|
| the theory of probabilistic databases | r cavallo , m pittarelli | vldb ,  |   1987 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2350
rtable_id: 16813
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 quantitative association rules in large relational tables | r srikant , r agrawal | sigmod conference |   1996 |

Entity B:
| title                                                                                     | authors          | venue                                     |   year |
|:------------------------------------------------------------------------------------------|:-----------------|:------------------------------------------|-------:|
| mining fuzzy association rules in a database containing relational and transactional data | kcc chan , wh au | studies in fuzziness and soft computing , |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1439
rtable_id: 60331
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 |
|:-------------------------------------------------------------|:-------------------------|:------------------|-------:|
| distributing queries over low-power wireless sensor networks | s madden , j hellerstein | sigmod conference |   2002 |

Entity B:
| title                                                  | authors                          | venue   | year   |
|:-------------------------------------------------------|:---------------------------------|:--------|:-------|
| an ultra-low power adc for distributed sensor networks | md scott , be boser , ksj pister |         |        |



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

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

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

Entity A:
| title                                                                | authors            | venue   |   year |
|:---------------------------------------------------------------------|:-------------------|:--------|-------:|
| a-topss - a publish/subscribe system supporting approximate matching | h liu , h jacobsen | vldb    |   2002 |

Entity B:
| title                                                                            | authors             | venue   | year   |
|:---------------------------------------------------------------------------------|:--------------------|:--------|:-------|
| a-topss : a publish/subscribe system supporting imperfect information processing | h liu , ha jacobsen |         |        |



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

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

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

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

Entity B:
| title           | authors   | venue                                   |   year |
|:----------------|:----------|:----------------------------------------|-------:|
| editor 's notes | nl smith  | new directions for program evaluation , |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1922
rtable_id: 5278
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 |
|:-------------------------|:--------------------|:--------|-------:|
| projecting xml documents | a marian , j simщon | vldb    |   2003 |

Entity B:
| title                    | authors             | venue                                                                  |   year |
|:-------------------------|:--------------------|:-----------------------------------------------------------------------|-------:|
| projecting xml documents | a marian , j simeon | proceedings of the international conference on very large & hellip ; , |   2003 |



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

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

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

Entity A:
| title                                                  | authors                          | venue                       |   year |
|:-------------------------------------------------------|:---------------------------------|:----------------------------|-------:|
| fast incremental maintenance of approximate histograms | p gibbons , y matias , v poosala | acm trans . database syst . |   2002 |

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: 0
original: ltable_id: 938
rtable_id: 25298
label: 0
Task: Entity-Matching (source dataset: DBLP-Scholar)

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

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

Entity A:
| title                                                               | authors                                                                     | venue             |   year |
|:--------------------------------------------------------------------|:----------------------------------------------------------------------------|:------------------|-------:|
| storing and querying ordered xml using a relational database system | i tatarinov , s viglas , k beyer , j shanmugasundaram , e shekita , c zhang | sigmod conference |   2002 |

Entity B:
| title                                                          | authors                      | venue   |   year |
|:---------------------------------------------------------------|:-----------------------------|:--------|-------:|
| integration of time versions into a relational database system | p dadam , vy lum , hd werner | vldb ,  |   1984 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 526
rtable_id: 30724
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   |
|:---------------------------------------------------------------|:-------------------------------|:--------|:-------|
| the r + - tree : a dynamic index for multi-dimensional objects | tsn roussopoulos , c faloutsos | proc .  |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2560
rtable_id: 39755
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 database system implementations | m bіhlen  | sigmod record |   1995 |

Entity B:
| title                                       | authors        | venue   |   year |
|:--------------------------------------------|:---------------|:--------|-------:|
| an introduction to spatial database systems | portal.acm.org |         |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 842
rtable_id: 13096
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 |
|:---------------------------------------|:-----------------------------------------------|:--------|-------:|
| architecture of oracle parallel server | r bamford , d butler , b klots , n macnaughton | vldb    |   1998 |

Entity B:
| title                                     | authors   | venue                                                                  |   year |
|:------------------------------------------|:----------|:-----------------------------------------------------------------------|-------:|
| cache coherency in oracle parallel server | b klots   | proceedings of the international conference on very large & hellip ; , |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1547
rtable_id: 52886
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 |
|:-----------------------------------------------------------------------------------|:---------------|:------------------|-------:|
| continually evaluating similarity-based pattern queries on a streaming time series | l gao , x wang | sigmod conference |   2002 |

Entity B:
| title                                                                              | authors         | venue               |   year |
|:-----------------------------------------------------------------------------------|:----------------|:--------------------|-------:|
| continually evaluating similarity-based pattern queries on a streaming time series | l gao , xs wang | sigmod conference , |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 510
rtable_id: 46906
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 |
|:-----------------------------------------------------------|:--------------|:--------|-------:|
| maximizing buffer and disk utilizations for news on-demand | r ng , j yang | vldb    |   1994 |

Entity B:
| title                                                    | authors        | venue                                            | year   |
|:---------------------------------------------------------|:---------------|:-------------------------------------------------|:-------|
| maximizing buffer and disk utilization for news ondemand | rt ng , j yang | proc . int &#39; l conf . very large databases , |        |



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

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

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

Entity A:
| title                                                                  | authors                               | venue   |   year |
|:-----------------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| an efficient algorithm for mining association rules in large databases | a savasere , e omiecinski , s navathe | vldb    |   1995 |

Entity B:
| title                                                       | authors                    | venue   | year   |
|:------------------------------------------------------------|:---------------------------|:--------|:-------|
| hash based parallel algorithms for mining association rules | t shintani , m kitsuregawa |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1953
rtable_id: 61384
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 |
|:---------------------------------------------------------------|:--------------------------------|:--------|-------:|
| odefs : a file system interface to an object-oriented database | n gehani , h jagadish , w roome | vldb    |   1994 |

Entity B:
| title                                                                    | authors             | venue                            | year   |
|:-------------------------------------------------------------------------|:--------------------|:---------------------------------|:-------|
| effective clustering of complex data in object-oriented database systems | j cheng , ar hurson | proceedings acm sigmod , pages , |        |



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

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

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

Entity A:
| title                                   | authors                             | venue   |   year |
|:----------------------------------------|:------------------------------------|:--------|-------:|
| data management for pervasive computing | m cherniack , m franklin , s zdonik | vldb    |   2001 |

Entity B:
| title                                                 | authors                                           | venue                                | year   |
|:------------------------------------------------------|:--------------------------------------------------|:-------------------------------------|:-------|
| data management for peer-to-peer computing : a vision | a kementsietsidis , j mylopoulos , l serafini , i | acm sigmod webdb workshop &#39; 02 , |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2183
rtable_id: 35371
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 system for watermarking relational databases | r agrawal , p haas , j kiernan | sigmod conference |   2003 |

Entity B:
| title                                            | authors            | venue               |   year |
|:-------------------------------------------------|:-------------------|:--------------------|-------:|
| a note on decompositions of relational databases | c beeri , my vardi | acm sigmod record , |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 50350
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 processing in spatial network databases | d papadias , j zhang , n mamoulis , y tao | vldb    |   2003 |

Entity B:
| title                                                                              | authors           | venue                                                       | year   |
|:-----------------------------------------------------------------------------------|:------------------|:------------------------------------------------------------|:-------|
| queueing network models for concurrent transaction processing in a database system | kb irani , hl lin | proceedings of the 1979 acm sigmod international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2001
rtable_id: 17286
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 |
|:--------------------------------------------------------------------------------------------------|:----------|:--------|-------:|
| imielinski , and a. swami , mining association rules between sets of items in large databases . . | r agrawal |         |   1993 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 95
rtable_id: 63071
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 retrieval of similar shapes | d rafiei , a mendelzon | vldb j. |   2002 |

Entity B:
| title                                                   | authors                | venue                            |   year |
|:--------------------------------------------------------|:-----------------------|:---------------------------------|-------:|
| efficient retrieval of similar time sequences using dft | d rafiei , a mendelzon | arxiv preprint cs.db / 9809033 , |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2449
rtable_id: 34650
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 multiview project : object-oriented view technology and applications | e rundensteiner , h kuno , y ra , v crestana-taube , m jones , p marrѓn | sigmod conference |   1996 |

Entity B:
| title                                               | authors                      | venue   | year   |
|:----------------------------------------------------|:-----------------------------|:--------|:-------|
| an object-oriented environment for ois applications | o nierstrasz , d tsichritzis |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1484
rtable_id: 54987
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 |
|:-------------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| bess : storage support for interactive visualization systems | a biliris , t funkhouser , w o'connell , e panagos | sigmod conference |   1996 |

Entity B:
| title                                                                   | authors     | venue   | year   |
|:------------------------------------------------------------------------|:------------|:--------|:-------|
| implementing an interactive visualization system on a simd architecture | rf erbacher |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1434
rtable_id: 16878
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 role of integrity constraints in database interoperation | m vermeer , p apers | vldb    |   1996 |

Entity B:
| title                                                 | authors    | venue   | year   |
|:------------------------------------------------------|:-----------|:--------|:-------|
| temporal inegrity constraints in relational databases | j chomicki |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1999
rtable_id: 23788
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 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 o 2 object-oriented database system | f bancilhon | proceedings of the 1992 acm sigmod-international conference |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 899
rtable_id: 41920
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 system for watermarking relational databases | r agrawal , p haas , j kiernan | sigmod conference |   2003 |

Entity B:
| title                                                  | authors                       | venue                                  |   year |
|:-------------------------------------------------------|:------------------------------|:---------------------------------------|-------:|
| an improved third normal form for relational databases | tw ling , fw tompa , t kameda | acm transactions on database systems , |   1981 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 277
rtable_id: 61072
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 design and implementation of a sequence database system | p seshadri , m livny , r ramakrishnan | vldb    |   1996 |

Entity B:
| title                                                                     | authors                  | venue                                                                    | year   |
|:--------------------------------------------------------------------------|:-------------------------|:-------------------------------------------------------------------------|:-------|
| design and implementation of a biodiversity information management system | sj bedathur , jr haritsa | & hellip ; of the tenth international conference on management of data , |        |



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

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

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

Entity A:
| title                            | authors          | venue         |   year |
|:---------------------------------|:-----------------|:--------------|-------:|
| issues in data stream management | l golab , m жzsu | sigmod record |   2003 |

Entity B:
| title                                         | authors   | venue           |   year |
|:----------------------------------------------|:----------|:----------------|-------:|
| data management issues in electronic commerce | mt oezsu  | sigmod record , |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1975
rtable_id: 52266
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 |
|:--------------------------------------------|:------------------------------------|:------------------|-------:|
| selectivity estimation in spatial databases | s acharya , v poosala , s ramaswamy | sigmod conference |   1999 |

Entity B:
| title                                    | authors          | venue   | year   |
|:-----------------------------------------|:-----------------|:--------|:-------|
| topological queries in spatial databases | ch papadimitriou |         |        |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1023
rtable_id: 47385
label: 0