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 |
|:-----------------------------------------------------------------|:--------------------------------------------------------------------------------------------------|:--------------|-------:|
| deeds towards a distributed and active real-time database system | joakim eriksson , jonas mellin , sten andler , mikael berndtsson , bengt eftring , jörgen hansson | sigmod record |   1996 |

Entity B:
| title                                                  | authors                                                                                  | venue             |   year |
|:-------------------------------------------------------|:-----------------------------------------------------------------------------------------|:------------------|-------:|
| integrating temporal , real-time , an active databases | krithi ramamritham , raju sivasankaran , john a. stankovic , don t. towsley , ming xiong | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2315
rtable_id: 373
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 |
|:----------------------------------------------------------|:---------------------------------------------------------|:--------------|-------:|
| improving timeliness in real-time secure database systems | sang hyuk son , rasikan david , bhavani m. thuraisingham | sigmod record |   1996 |

Entity B:
| title                                           | authors        | venue             |   year |
|:------------------------------------------------|:---------------|:------------------|-------:|
| advances in real-time database systems research | azer bestavros | acm sigmod record |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 925
rtable_id: 372
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 |
|:-----------------------------------------------------------|:-----------------------------|:--------|-------:|
| lineage tracing for general data warehouse transformations | yingwei cui , jennifer widom | vldb    |   2001 |

Entity B:
| title                                                      | authors           | venue                                                                  |   year |
|:-----------------------------------------------------------|:------------------|:-----------------------------------------------------------------------|-------:|
| lineage tracing for general data warehouse transformations | y. cui , j. widom | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 19
rtable_id: 2119
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 |
|:--------------------------------------------|:------------------------------------------------------|:--------|-------:|
| query optimization by predicate move-around | inderpal singh mumick , alon y. levy , yehoshua sagiv | vldb    |   1994 |

Entity B:
| title                                       | authors                                               | venue                 |   year |
|:--------------------------------------------|:------------------------------------------------------|:----------------------|-------:|
| query optimization by predicate move-around | alon y. levy , inderpal singh mumick , yehoshua sagiv | very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 141
rtable_id: 2201
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 |
|:--------------------------------------------------|:----------------------------------------------|:------------------|-------:|
| selectivity estimation using probabilistic models | daphne koller , lise getoor , benjamin taskar | sigmod conference |   2001 |

Entity B:
| title                                                                           | authors                                      | venue                                          |   year |
|:--------------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| multi-dimensional selectivity estimation using compressed histogram information | ju-hong lee , deok-hwan kim , chin-wan chung | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 731
rtable_id: 205
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 |
|:--------------------------------------------------------------------------------------------|:---------------------------------------------------------------------|:--------|-------:|
| xcerpt and visxcerpt : from pattern-based to visual querying of xml and semistructured data | sacha berger , christoph wieser , sebastian schaffert , françois bry | vldb    |   2003 |

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: 2231
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 |
|:-------------------------------------|:-----------------------------------------------------------------|:--------------|-------:|
| bringing order to query optimization | giedrius slivinskas , richard t. snodgrass , christian s. jensen | sigmod record |   2002 |

Entity B:
| title                                                                   | authors                                      | venue                                          |   year |
|:------------------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| exploiting constraint-like data characterizations in query optimization | parke godfrey , jarek gryz , calisto zuzarte | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1857
rtable_id: 276
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 non-uniform data fragmentation strategy for parallel main-menory database systems | nick bassiliades , ioannis p. vlahavas | vldb    |   1995 |

Entity B:
| title                                                           | authors                                                                          | venue                                          |   year |
|:----------------------------------------------------------------|:---------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| towards self-tuning data placement in parallel database systems | mong li lee , masaru kitsuregawa , beng chin ooi , kian-lee tan , anirban mondal | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1965
rtable_id: 428
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 |
|:---------------------------------------|:--------------------------------------|:--------|-------:|
| orthogonally persistent object systems | malcolm p. atkinson , ronald morrison | vldb j. |   1995 |

Entity B:
| title                                        | authors                 | venue                                          |   year |
|:---------------------------------------------|:------------------------|:-----------------------------------------------|-------:|
| ptool : a scalable persistent object manager | r. l. grossman , x. qin | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 805
rtable_id: 1666
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 |
|:----------------------------------------|:-------------------------------------------|:------------------|-------:|
| query rewriting for semistructured data | vasilis vassalos , yannis papakonstantinou | sigmod conference |   1999 |

Entity B:
| title                                                                   | authors                                                                           | venue                 |   year |
|:------------------------------------------------------------------------|:----------------------------------------------------------------------------------|:----------------------|-------:|
| incremental maintenance for materialized views over semistructured data | serge abiteboul , jason mchugh , michael rys , vasilis vassalos , janet l. wiener | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 932
rtable_id: 986
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 |
|:-----------------------------------------------------------|:-----------------------------|:--------|-------:|
| coloring away communication in parallel query optimization | rajeev motwani , waqar hasan | vldb    |   1995 |

Entity B:
| title                                | authors                                                              | venue             |   year |
|:-------------------------------------|:---------------------------------------------------------------------|:------------------|-------:|
| bringing order to query optimization | giedrius slivinskas , christian s. jensen , richard thomas snodgrass | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 320
rtable_id: 759
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 |
|:--------------------------------------------------------|:------------------------------|:------------------|-------:|
| enhancing database correctness : a statistical approach | wen-chi hou , zhongyang zhang | sigmod conference |   1995 |

Entity B:
| title                                                   | authors                       | venue                                          |   year |
|:--------------------------------------------------------|:------------------------------|:-----------------------------------------------|-------:|
| enhancing database correctness : a statistical approach | wen-chi hou , zhongyang zhang | international conference on management of data |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 288
rtable_id: 1515
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 |
|:----------------------------------------------------------|:-------------------------------------------------------------------------|:------------------|-------:|
| genesys : a system for efficient spatial query processing | thomas brinkhoff , hans-peter kriegel , ralf schneider , bernhard seeger | sigmod conference |   1994 |

Entity B:
| title                                         | authors                                                   | venue                                          |   year |
|:----------------------------------------------|:----------------------------------------------------------|:-----------------------------------------------|-------:|
| the dedale system for complex spatial queries | st &#233; phane grumbach , philippe rigaux , luc segoufin | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2517
rtable_id: 1804
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 |
|:------------------------------------|:--------------------------------------------------------|:------------------|-------:|
| dynamic multidimensional histograms | piotr indyk , sudipto guha , nitin thaper , nick koudas | sigmod conference |   2002 |

Entity B:
| title                               | authors                                                 | venue                                          |   year |
|:------------------------------------|:--------------------------------------------------------|:-----------------------------------------------|-------:|
| dynamic multidimensional histograms | nitin thaper , sudipto guha , piotr indyk , nick koudas | international conference on management of data |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 699
rtable_id: 677
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 |
|:------------------------------------------------|:----------|:------------------|-------:|
| enterprise transaction processing on windows nt | greg hope | sigmod conference |   1995 |

Entity B:
| title                                                                   | authors                                            | venue             |   year |
|:------------------------------------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| databases and transaction processing : an application-oriented approach | philip m. lewis , arthur bernstein , michael kifer | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1384
rtable_id: 658
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 |
|:---------------------------------|:-----------------------------|:--------------|-------:|
| issues in data stream management | lukasz golab , m. tamer özsu | sigmod record |   2003 |

Entity B:
| title                                         | authors      | venue             |   year |
|:----------------------------------------------|:-------------|:------------------|-------:|
| data management issues in electronic commerce | asuman dogac | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1330
rtable_id: 347
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 |
|:-----------------------------------------------|:---------------|:--------|-------:|
| sampling large databases for association rules | hannu toivonen | vldb    |   1996 |

Entity B:
| title                                                            | authors                               | venue                                          |   year |
|:-----------------------------------------------------------------|:--------------------------------------|:-----------------------------------------------|-------:|
| mining quantitative association rules in large relational tables | ramakrishnan srikant , rakesh agrawal | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1428
rtable_id: 1951
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 |
|:---------------------------------------------------|:------------------------------------------------------------------|:--------|-------:|
| locating data sources in large distributed systems | david j. dewitt , leonidas galanis , shawn r. jeffery , yuan wang | vldb    |   2003 |

Entity B:
| title                                                          | authors                                                            | venue                                          |   year |
|:---------------------------------------------------------------|:-------------------------------------------------------------------|:-----------------------------------------------|-------:|
| query caching and optimization in distributed mediator systems | s. adali , k. s. candan , y. papakonstantinou , v. s. subrahmanian | international conference on management of data |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1129
rtable_id: 1962
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 |
|:---------------------------------------------------------------|:----------------------------------------------------------------------------------|:--------|-------:|
| schema and database evolution in the o2 object database system | fabrizio ferrandina , guy ferran , thorsten meyer , roberto zicari , joëlle madec | vldb    |   1995 |

Entity B:
| title                                      | authors                                                            | venue                                          |   year |
|:-------------------------------------------|:-------------------------------------------------------------------|:-----------------------------------------------|-------:|
| on-line reorganization in object databases | mohana k. lakhamraju , rajeev rastogi , s. seshadri , s. sudarshan | international conference on management of data |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1662
rtable_id: 66
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 |
|:---------------------------------------------------|:--------------------------------------------------------------------------------------|:--------------|-------:|
| distributed deviation detection in sensor networks | dimitrios gunopulos , themistoklis palpanas , dimitris papadopoulos , vana kalogeraki | sigmod record |   2003 |

Entity B:
| title                                              | authors                                                                               | venue             |   year |
|:---------------------------------------------------|:--------------------------------------------------------------------------------------|:------------------|-------:|
| distributed deviation detection in sensor networks | themistoklis palpanas , dimitris papadopoulos , vana kalogeraki , dimitrios gunopulos | acm sigmod record |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1505
rtable_id: 2198
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 |
|:---------------------------------------------------------------|:----------------------------------------------------------------|:--------------|-------:|
| eiha ?!? : deploying web and wap services using xml technology | jean-christophe r. pazzaglia , chiara biancheri , gavino paddeu | sigmod record |   2001 |

Entity B:
| title                                                          | authors                                                      | venue             |   year |
|:---------------------------------------------------------------|:-------------------------------------------------------------|:------------------|-------:|
| eiha ?!? : deploying web and wap services using xml technology | chiara biancheri , jean-christophe pazzaglia , gavino paddeu | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 894
rtable_id: 474
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 |
|:------------------------------------------------------------|:-----------------------------------------|:--------|-------:|
| query processing techniques for multiversion access methods | jochen van den bercken , bernhard seeger | vldb    |   1996 |

Entity B:
| title                                                      | authors               | venue                                         |   year |
|:-----------------------------------------------------------|:----------------------|:----------------------------------------------|-------:|
| optimization techniques for queries with expensive methods | joseph m. hellerstein | acm transactions on database systems ( tods ) |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2118
rtable_id: 139
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 |
|:-------------------------------------------------|:--------------|:--------|-------:|
| index configuration in object-oriented databases | elisa bertino | vldb j. |   1994 |

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: 644
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 |
|:--------------------------------------------------------------|:--------------------------------------------------|:------------------|-------:|
| efficient algorithms for mining outliers from large data sets | kyuseok shim , sridhar ramaswamy , rajeev rastogi | sigmod conference |   2000 |

Entity B:
| title                                                        | authors                                      | venue                                          |   year |
|:-------------------------------------------------------------|:---------------------------------------------|:-----------------------------------------------|-------:|
| cure : an efficient clustering algorithm for large databases | sudipto guha , rajeev rastogi , kyuseok shim | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1317
rtable_id: 1785
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 query language and optimization techniques for unstructured data | gerd g. hillebrand , peter buneman , susan b. davidson , dan suciu | sigmod conference |   1996 |

Entity B:
| title                                                                                  | authors                                                                                                | venue                 |   year |
|:---------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------|:----------------------|-------:|
| implementation of two semantic query optimization techniques in db2 universal database | qi cheng , jarek gryz , fred koo , t. y. cliff leung , linqi liu , xiaoyan qian , k. bernhard schiefer | very large data bases |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 561
rtable_id: 791
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 |
|:----------------------------------------|:------------------------------------|:--------|-------:|
| guest editorial : databases and the web | alberto o. mendelzon , paolo atzeni | vldb j. |   2000 |

Entity B:
| title           | authors                                                     | venue                                                                  |   year |
|:----------------|:------------------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| guest editorial | philip a. bernstein , yannis ioannidis , raghu ramakrishnan | the vldb journal -- the international journal on very large data bases |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1397
rtable_id: 2290
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 |
|:-------------------------|:---------------------------------------------------------------|:--------|-------:|
| business process cockpit | umeshwar dayal , mehmet sayal , ming-chien shan , fabio casati | vldb    |   2002 |

Entity B:
| title                                  | authors     | venue                                          |   year |
|:---------------------------------------|:------------|:-----------------------------------------------|-------:|
| real business processing meets the web | james chong | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1917
rtable_id: 160
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 |
|:--------------------------------------------------------|:-----------------------------------------------------------------------------------------------|:------------------|-------:|
| fast parallel similarity search in multimedia databases | christian böhm , bernhard braunmüller , hans-peter kriegel , daniel a. keim , stefan berchtold | sigmod conference |   1997 |

Entity B:
| title                                                   | authors                                                                                                      | venue                                          |   year |
|:--------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------|:-----------------------------------------------|-------:|
| fast parallel similarity search in multimedia databases | stefan berchtold , christian b &#246; hm , bernhard braunm &#252; ller , daniel a. keim , hans-peter kriegel | international conference on management of data |   1997 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 368
rtable_id: 1921
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 |
|:---------------------------------------------------------------------------------|:------------------------------|:--------------|-------:|
| research issues for data communication in mobile ad-hoc network database systems | leslie d. fife , le gruenwald | sigmod record |   2003 |

Entity B:
| title                                                                              | authors   | venue                                          |   year |
|:-----------------------------------------------------------------------------------|:----------|:-----------------------------------------------|-------:|
| sigmod challenges paper : database issues in telecommunications network management | ilsoo ahn | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2248
rtable_id: 1740
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 |
|:-----------------------------------------------------------------------------|:---------------------------------|:----------------------------|-------:|
| iterative dynamic programming : a new class of query optimization algorithms | donald kossmann , konrad stocker | acm trans . database syst . |   2000 |

Entity B:
| title                                                           | authors                               | venue                                                                  |   year |
|:----------------------------------------------------------------|:--------------------------------------|:-----------------------------------------------------------------------|-------:|
| algebraic query optimisation for database programming languages | alexandra poulovassilis , carol small | the vldb journal -- the international journal on very large data bases |   1996 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 787
rtable_id: 1209
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 |
|:--------------------------------------------|:---------------------------------------|:--------|-------:|
| probabilistic optimization of top n queries | donko donjerkovic , raghu ramakrishnan | vldb    |   1999 |

Entity B:
| title                                                                    | authors                                                               | venue                                          |   year |
|:-------------------------------------------------------------------------|:----------------------------------------------------------------------|:-----------------------------------------------|-------:|
| simultaneous optimization and evaluation of multiple dimensional queries | yihong zhao , prasad m. deshpande , jeffrey f. naughton , amit shukla | international conference on management of data |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 994
rtable_id: 1801
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 gathering in the world-wide web : the w3ql query language and the w3qs system | david konopnicki , oded shmueli | acm trans . database syst . |   1998 |

Entity B:
| title                                        | authors                         | venue                 |   year |
|:---------------------------------------------|:--------------------------------|:----------------------|-------:|
| w3qs : a query system for the world-wide web | david konopnicki , oded shmueli | very large data bases |   1995 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1565
rtable_id: 1460
label: 0