MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | edward omiecinski , shamkant b. navathe , ashok savasere | vldb    |   1995 |

Entity B:
| title                                                                                      | authors                                | venue                                          |   year |
|:-------------------------------------------------------------------------------------------|:---------------------------------------|:-----------------------------------------------|-------:|
| parallel mining algorithms for generalized association rules with classification hierarchy | takahiko shintani , masaru kitsuregawa | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 863
rtable_id: 1789
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

Entity A:
| title             | authors          | venue         |   year |
|:------------------|:-----------------|:--------------|-------:|
| information rules | dale a. stirling | sigmod record |   2003 |

Entity B:
| title                             | authors               | venue             |   year |
|:----------------------------------|:----------------------|:------------------|-------:|
| environmental information systems | oliver g &#252; nther | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 1909
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------------|:------------------------------------------------------------------------------------------|:------------------|-------:|
| update propagation protocols for replicated databases | raghavan komondoor , abraham silberschatz , yuri breitbart , s. seshadri , rajeev rastogi | sigmod conference |   1999 |

Entity B:
| title                                                                                   | authors                                     | venue                 |   year |
|:----------------------------------------------------------------------------------------|:--------------------------------------------|:----------------------|-------:|
| fast algorithms for maintaining replica consistency in lazy master replicated databases | esther pacitti , pascale minet , eric simon | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1248
rtable_id: 828
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------------------------|:----------------|:--------|-------:|
| from data independence to knowledge independence : an on-going story | laurent vieille | vldb    |   1998 |

Entity B:
| title                                                                | authors         | venue                 |   year |
|:---------------------------------------------------------------------|:----------------|:----------------------|-------:|
| from data independence to knowledge independence : an on-going story | laurent vieille | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 930
rtable_id: 770
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 graphical query language for mobile information systems | ya-hui chang | sigmod record |   2003 |

Entity B:
| title                                             | authors                                                   | venue             |   year |
|:--------------------------------------------------|:----------------------------------------------------------|:------------------|-------:|
| a query language for a web-site management system | mary fernandez , daniela florescu , alon levy , dan suciu | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 427
rtable_id: 1862
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 mining in the bioinformatics domain | shalom tsur | vldb    |   2000 |

Entity B:
| title                                         | authors   | venue             |   year |
|:----------------------------------------------|:----------|:------------------|-------:|
| data analysis and mining in the life sciences | nam huyn  | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1219
rtable_id: 545
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-------------------------------------------------------------------------------------|:------------------------------------------------|:--------|-------:|
| optimizing multiple dimensional queries simultaneously in multidimensional databases | jeffrey xu yu , weifa liang , maria e. orlowska | vldb j. |   2000 |

Entity B:
| title                                          | authors                                                        | venue                 |   year |
|:-----------------------------------------------|:---------------------------------------------------------------|:----------------------|-------:|
| optimizing queries across diverse data sources | laura m. haas , donald kossmann , edward l. wimmers , jun yang | very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2062
rtable_id: 940
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------|:------------|:--------------|-------:|
| converting relational to object-oriented databases | joseph fong | sigmod record |   1997 |

Entity B:
| title                                                          | authors                                              | venue                 |   year |
|:---------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| odefs : a file system interface to an object-oriented database | narain h. gehani , h. v. jagadish , william d. roome | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 2243
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------------------------|:------------------------------------|:--------------|-------:|
| extraction of object-oriented structures from existing relational databases | julia e. hodges , shekar ramanathan | sigmod record |   1997 |

Entity B:
| title                                                              | authors                          | venue                                                                  |   year |
|:-------------------------------------------------------------------|:---------------------------------|:-----------------------------------------------------------------------|-------:|
| exact : an extensible approach to active object-oriented databases | oscar d &#237; az , arturo jaime | the vldb journal -- the international journal on very large data bases |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1542
rtable_id: 1159
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 prototype of the dare system | tiziana catarci , giuseppe santucci | sigmod conference |   2001 |

Entity B:
| title                               | authors                                                                                                                   | venue                                                                  |   year |
|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| the aditi deductive database system | jayen vaghani , kotagiri ramamohanarao , david b. kemp , zoltan somogyi , peter j. stuckey , tim s. leask , james harland | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 381
rtable_id: 576
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | babis theodoulidis , george karvelis , jayant chaudhary , aziz ait-braham , simon sou , george andrianopoulos | sigmod conference |   1994 |

Entity B:
| title                                                         | authors                                    | venue             |   year |
|:--------------------------------------------------------------|:-------------------------------------------|:------------------|-------:|
| relational data sharing in peer-based data management systems | beng chin ooi , yanfeng shu , kian-lee tan | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 78
rtable_id: 2240
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 and mining fine-grained semi-structured data | soumen chakrabarti | vldb    |   2002 |

Entity B:
| title                                      | authors                                               | venue                                          |   year |
|:-------------------------------------------|:------------------------------------------------------|:-----------------------------------------------|-------:|
| extracting schema from semistructured data | svetlozar nestorov , serge abiteboul , rajeev motwani | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1159
rtable_id: 1799
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------------------------------------------------|:-------------------------------------------------|:----------------------------|-------:|
| using semantic values to falilitate interoperability among heterogeneous information systems | edward sciore , michael siegel , arnon rosenthal | acm trans . database syst . |   1994 |

Entity B:
| title                                                          | authors                                              | venue                 |   year |
|:---------------------------------------------------------------|:-----------------------------------------------------|:----------------------|-------:|
| quality-driven integration of heterogenous information systems | felix naumann , ulf leser , johann christoph freytag | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1112
rtable_id: 790
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------------------------------------------------|:--------------------------------|:--------|-------:|
| pm3 : an orthogonal persistent systems programming language - design , implementation , performance | antony l. hosking , jiawan chen | vldb    |   1999 |

Entity B:
| title                                                                                               | authors                         | venue                 |   year |
|:----------------------------------------------------------------------------------------------------|:--------------------------------|:----------------------|-------:|
| pm3 : an orthogonal persistent systems programming language - design , implementation , performance | antony l. hosking , jiawan chen | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1487
rtable_id: 815
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| template-based wrappers in the tsimmis system | joachim hammer , hector garcia-molina , svetlozar nestorov , ramana yerneni , markus m. breunig , vasilis vassalos | sigmod conference |   1997 |

Entity B:
| title                                         | authors                                                                                                                       | venue                                          |   year |
|:----------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| template-based wrappers in the tsimmis system | joachim hammer , h &#233; ctor garc &#237; a-molina , svetlozar nestorov , ramana yerneni , marcus breunig , vasilis vassalos | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2425
rtable_id: 1840
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

Entity A:
| title                                         | authors                                                       | venue         |   year |
|:----------------------------------------------|:--------------------------------------------------------------|:--------------|-------:|
| database research at arizona state university | suzanne w. dietrich , forouzan golshani , susan darling urban | sigmod record |   1996 |

Entity B:
| title                                                                      | authors                                                                                                                                                         | venue             |   year |
|:---------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| florida international university high performance database research center | naphtali rishe , wei sun , david barton , yi deng , cyril orji , michael alexopoulos , leonardo loureiro , carlos ordonez , mario sanchez , artyom shaposhnikov | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1020
rtable_id: 1555
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------|:----------------------------------------------------------------------------------------------|:--------|-------:|
| vxmlr : a visual xml-relational database system | aoying zhou , wenyun ji , shihui zheng , hongjun lu , yuqi liang , zengping tian , long zhang | vldb    |   2001 |

Entity B:
| title                                                           | authors   | venue                                          |   year |
|:----------------------------------------------------------------|:----------|:-----------------------------------------------|-------:|
| unisql/x unified relational and object-oriented database system | won kim   | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1738
rtable_id: 1630
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------------------------------------------------|:--------------------------------------|:--------|-------:|
| investigation of algebraic query optimisation techniques for database programming languages | alexandra poulovassilis , carol small | vldb    |   1994 |

Entity B:
| title                                                            | authors                             | venue             |   year |
|:-----------------------------------------------------------------|:------------------------------------|:------------------|-------:|
| applications of java programming language to database management | bradley f. burton , victor w. marek | acm sigmod record |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 99
rtable_id: 1769
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------|:------------------|-------:|
| dbis-toolkit : adaptable middleware for large scale data delivery | demet aksoy , mehmet altinel , stanley b. zdonik , thomas baby , william shapiro , michael j. franklin | sigmod conference |   1999 |

Entity B:
| title                                                             | authors                                                                                       | venue                                          |   year |
|:------------------------------------------------------------------|:----------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| dbis-toolkit : adaptable middleware for large scale data delivery | mehmet altinel , demet aksoy , thomas baby , michael franklin , william shapiro , stan zdonik | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1667
rtable_id: 16
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------------|:--------------|:--------------|-------:|
| text databases : a survey of text models and systems | arjan loeffen | sigmod record |   1994 |

Entity B:
| title                                         | authors                          | venue             |   year |
|:----------------------------------------------|:---------------------------------|:------------------|-------:|
| a survey of logical models for olap databases | panos vassiliadis , timos sellis | acm sigmod record |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 948
rtable_id: 506
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:-----------------------------------------------------|:---------------------------------------------------|:--------|-------:|
| optimizing multi-feature queries for image databases | ulrich güntzer , werner kießling , wolf-tilo balke | vldb    |   2000 |

Entity B:
| title                                                                            | authors                                                | venue                                                                  |   year |
|:---------------------------------------------------------------------------------|:-------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| combining multi-visual features for efficient indexing in a large image database | anne h. h. ngu , quan z. sheng , du q. huynh , ron lei | the vldb journal -- the international journal on very large data bases |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1034
rtable_id: 1267
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:--------------------------------------------------|:--------------|:------------------|-------:|
| paradise : a database system for gis applications | paradise team | sigmod conference |   1995 |

Entity B:
| title                                                       | authors                                                                            | venue                                          |   year |
|:------------------------------------------------------------|:-----------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| web caching for database applications with oracle web cache | jesse anton , lawrence jacobs , xiang liu , jordan parker , zheng zeng , tie zhong | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 306
rtable_id: 722
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

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

Entity B:
| title                                                               | authors                                                                                                   | venue                                          |   year |
|:--------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| storing and querying ordered xml using a relational database system | igor tatarinov , stratis d. viglas , kevin beyer , jayavel shanmugasundaram , eugene shekita , chun zhang | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1108
rtable_id: 689
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

Entity A:
| title                         | authors   | venue             |   year |
|:------------------------------|:----------|:------------------|-------:|
| parallel database systems 101 | jim gray  | sigmod conference |   1995 |

Entity B:
| title                                       | authors                    | venue                                                                  |   year |
|:--------------------------------------------|:---------------------------|:-----------------------------------------------------------------------|-------:|
| an introduction to spatial database systems | ralf hartmut g &#252; ting | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 838
rtable_id: 589
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 multidatabase system for tracking and retrieval of financial data | munir cochinwala , john bradley | vldb    |   1994 |

Entity B:
| title                                                     | authors        | venue             |   year |
|:----------------------------------------------------------|:---------------|:------------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 861
rtable_id: 1884
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 | susan malaika | vldb    |   1996 |

Entity B:
| title                        | authors                            | venue                                          |   year |
|:-----------------------------|:-----------------------------------|:-----------------------------------------------|-------:|
| data grid management systems | arun jagatheesan , arcot rajasekar | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1481
rtable_id: 2250
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 mid-query re-optimization of sub-optimal query execution plans | david j. dewitt , navin kabra | sigmod conference |   1998 |

Entity B:
| title                                          | authors                        | venue                                          |   year |
|:-----------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| optimization of dynamic query evaluation plans | richard l. cole , goetz graefe | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 432
rtable_id: 1719
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------|:-------------|:--------------|-------:|
| mpeg-7 and multimedia database systems | harald kosch | sigmod record |   2002 |

Entity B:
| title                                  | authors      | venue             |   year |
|:---------------------------------------|:-------------|:------------------|-------:|
| mpeg-7 and multimedia database systems | harald kosch | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 797
rtable_id: 755
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

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

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

Entity A:
| title                                | authors                                                                   | venue         |   year |
|:-------------------------------------|:--------------------------------------------------------------------------|:--------------|-------:|
| view maintenance in mobile computing | ouri wolfson , kailash narayanan , son dao , ramya raj , a. prasad sistla | sigmod record |   1995 |

Entity B:
| title                                        | authors                                                  | venue             |   year |
|:---------------------------------------------|:---------------------------------------------------------|:------------------|-------:|
| digital library services in mobile computing | bharat bhargava , melliyal annamalai , evaggelia pitoura | acm sigmod record |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2066
rtable_id: 1615
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:------------------------------------------------|:----------------------------------|:------------------|-------:|
| eddies : continuously adaptive query processing | ron avnur , joseph m. hellerstein | sigmod conference |   2000 |

Entity B:
| title                                                 | authors                                                                 | venue                                          |   year |
|:------------------------------------------------------|:------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| continuously adaptive continuous queries over streams | samuel madden , mehul shah , joseph m. hellerstein , vijayshankar raman | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2589
rtable_id: 647
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:----------------------------------------------------------|:---------------|:--------------|-------:|
| olap , relational , and multidimensional database systems | george colliat | sigmod record |   1996 |

Entity B:
| title                                                                | authors                                  | venue             |   year |
|:---------------------------------------------------------------------|:-----------------------------------------|:------------------|-------:|
| report on first international workshop on real-time database systems | azer bestavros , kwei-jay lin , sang son | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2108
rtable_id: 1873
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

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 |
|:---------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|-------:|
| lore : a lightweight object repository for semistructured data | janet l. wiener , jason mchugh , serge abiteboul , qingshan luo , anand rajaraman , dallan quass , jeffrey d. ullman , roy goldman , hugo rivero , jennifer widom , svetlozar nestorov , kevin haas | sigmod conference |   1996 |

Entity B:
| title                             | authors   | venue             |   year |
|:----------------------------------|:----------|:------------------|-------:|
| management of semistructured data | dan suciu | acm sigmod record |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 746
rtable_id: 1752
label: 0