[Feature branch] Lower bounds for min-max normalization in hybrid query

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased 3.0](https://github.com/opensearch-project/neural-search/compare/2.x...HEAD)
 ### Features
+- Lower bound for min-max normalization technique in hybrid query ([#1195](https://github.com/opensearch-project/neural-search/pull/1195))
 ### Enhancements
 - Set neural-search plugin 3.0.0 baseline JDK version to JDK-21 ([#838](https://github.com/opensearch-project/neural-search/pull/838))
 ### Bug Fixes

src/main/java/org/opensearch/neuralsearch/processor/CompoundTopDocs.java

@@ -13,6 +13,7 @@
 import static org.opensearch.neuralsearch.search.util.HybridSearchResultFormatUtil.isHybridQueryStartStopElement;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
@@ -150,4 +151,78 @@
         FieldDoc fieldDoc = (FieldDoc) scoreDoc;
         return new FieldDoc(fieldDoc.doc, fieldDoc.score, fieldDoc.fields, fieldDoc.shardIndex);
     }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (other == null || getClass() != other.getClass()) return false;
+        CompoundTopDocs that = (CompoundTopDocs) other;
+
+        if (this.topDocs.size() != that.topDocs.size()) {
+            return false;
+        }
+        for (int i = 0; i < topDocs.size(); i++) {
+            TopDocs thisTopDoc = this.topDocs.get(i);
+            TopDocs thatTopDoc = that.topDocs.get(i);
+            if ((thisTopDoc == null) != (thatTopDoc == null)) {
+                return false;
+            }
+            if (thisTopDoc == null) {
+                continue;
+            }
+            if (Objects.equals(thisTopDoc.totalHits, thatTopDoc.totalHits) == false) {
+                return false;
+            }
+            if (compareScoreDocs(thisTopDoc.scoreDocs, thatTopDoc.scoreDocs) == false) {
+                return false;
+            }
+        }
+        return Objects.equals(totalHits, that.totalHits) && Objects.equals(searchShard, that.searchShard);
+    }
+
+    private boolean compareScoreDocs(ScoreDoc[] first, ScoreDoc[] second) {
+        if (first.length != second.length) {
+            return false;
+        }
+
+        for (int i = 0; i < first.length; i++) {
+            ScoreDoc firstDoc = first[i];
+            ScoreDoc secondDoc = second[i];
+            if ((firstDoc == null) != (secondDoc == null)) {
+                return false;
+            }
+            if (firstDoc == null) {
+                continue;
+            }
+            if (firstDoc.doc != secondDoc.doc || Float.compare(firstDoc.score, secondDoc.score) != 0) {
+                return false;
+            }
+            if (firstDoc instanceof FieldDoc != secondDoc instanceof FieldDoc) {
+                return false;
+            }
+            if (firstDoc instanceof FieldDoc firstFieldDoc) {
+                FieldDoc secondFieldDoc = (FieldDoc) secondDoc;
+                if (Arrays.equals(firstFieldDoc.fields, secondFieldDoc.fields) == false) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Objects.hash(totalHits, searchShard);
+        for (TopDocs topDoc : topDocs) {
+            result = 31 * result + topDoc.totalHits.hashCode();
+            for (ScoreDoc scoreDoc : topDoc.scoreDocs) {
+                result = 31 * result + Float.floatToIntBits(scoreDoc.score);
+                result = 31 * result + scoreDoc.doc;
+                if (scoreDoc instanceof FieldDoc fieldDoc && fieldDoc.fields != null) {
+                    result = 31 * result + Arrays.deepHashCode(fieldDoc.fields);
+                }
+            }
+        }
+        return result;
+    }
 }

src/main/java/org/opensearch/neuralsearch/processor/factory/NormalizationProcessorFactory.java

@@ -58,7 +58,8 @@ public SearchPhaseResultsProcessor create(
                 TECHNIQUE,
                 MinMaxScoreNormalizationTechnique.TECHNIQUE_NAME
             );
-            normalizationTechnique = scoreNormalizationFactory.createNormalization(normalizationTechniqueName);
+            Map<String, Object> normalizationParams = readOptionalMap(NormalizationProcessor.TYPE, tag, normalizationClause, PARAMETERS);
+            normalizationTechnique = scoreNormalizationFactory.createNormalization(normalizationTechniqueName, normalizationParams);
         }
 
         Map<String, Object> combinationClause = readOptionalMap(NormalizationProcessor.TYPE, tag, config, COMBINATION_CLAUSE);

src/main/java/org/opensearch/neuralsearch/processor/normalization/L2ScoreNormalizationTechnique.java

@@ -10,6 +10,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.TopDocs;
@@ -32,6 +33,14 @@ public class L2ScoreNormalizationTechnique implements ScoreNormalizationTechniqu
     public static final String TECHNIQUE_NAME = "l2";
     private static final float MIN_SCORE = 0.0f;
 
+    public L2ScoreNormalizationTechnique() {
+        this(Map.of(), new ScoreNormalizationUtil());
+    }
+
+    public L2ScoreNormalizationTechnique(final Map<String, Object> params, final ScoreNormalizationUtil scoreNormalizationUtil) {
+        scoreNormalizationUtil.validateParameters(params, Set.of(), Map.of());
+    }
+
     /**
      * L2 normalization method.
      * n_score_i = score_i/sqrt(score1^2 + score2^2 + ... + scoren^2)