slice and dice

Author: JPryce-Aklundh

modules/ROOT/pages/functions/index.adoc

@@ -793,7 +793,7 @@ Vector functions allow you to compute the similarity scores of vector pairs.
 
 1.1+| xref::functions/vector.adoc#functions-vector[`vector()`]
 | `vector(vectorValue :: STRING \| LIST<INTEGER \| FLOAT>, dimension :: INTEGER, coordinateType :: [INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]) :: VECTOR`
-| label:new[Introduced in Neo4j 2025.xx]
+| Constructs a `VECTOR` value with a dimension and coordinate type. label:new[Introduced in Neo4j 2025.xx]
 
 1.1+| xref::functions/vector.adoc#functions-similarity-cosine[`vector.similarity.cosine()`]
 | `vector.similarity.cosine(a :: VECTOR \| LIST<INTEGER \| FLOAT>, b :: VECTOR \| LIST<INTEGER \| FLOAT>) :: FLOAT`

modules/ROOT/pages/functions/vector.adoc

@@ -1,17 +1,128 @@
 :description: Vector functions allow you to compute the similarity scores of vector pairs.
 :table-caption!:
-
 :link-vector-indexes: xref:indexes/semantic-indexes/vector-indexes.adoc
-
-[[query-functions-vector]]
 = Vector functions
 
-Vector functions allow you to create `VECTOR` values, compute the similarity scores of vector pairs, and calculate the size of a vector.
+Vector functions allow you to construct xref:values-and-types/vector.adoc[`VECTOR` values], compute the similarity and distance scores of vector pairs, and calculate the size of a vector.
 
 [role=label--new-2025.xx]
 [[functions-vector]]
 == vector()
 
+.Details
+|===
+| *Syntax* 3+| `vector(vectorValue[, dimension, coordinateType])`
+| *Description* 3+| Constructs a `VECTOR` value with a dimension and coordinate type.
+.4+| *Arguments* | *Name* | *Type* | *Description*
+| `vectorValue` | `STRING` \| `LIST<INTEGER \| FLOAT>` | The numeric values to create the vector coordinate from.
+ or `FLOAT` values, or a `STRING` defining the coordinates in the resulting `VECTOR`.
+| `dimension` | `INTEGER` | The number of dimensions (coordinates) in the vector.
+| `coordinateType` | `[INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]` | The type of each coordinate in the vector.
+| *Returns* 3+| `VECTOR`
+|===
+
+[NOTE]
+The `VECTOR` values generated by the `vector()` function can be xref:values-and-types/vector.adoc#store-vector-properties[stored as properties].
+As such, the `vector()` function can be used to store the embeddings generated by Neo4j's xref:genai-integrations.adoc[GenAI plugin] as `VECTOR` property values.
+`VECTOR` properties can semantically searched by a xref:indexes/semantic-indexes/vector-indexes.adoc[vector index].
+
+
+
+.Considerations
+|===
+
+| If a `STRING` is used in `vectorValue`, it must start and end with square brackets (`[]`).
+The values inside the brackets must be a number represented in either decimal or scientific notation and must be comma separated.
+| `null`, NaN, and infinity values are not allowed in `vectorValue`.
+| If `vectorValue` contain elements that are not of the specified `coordinateType`, they will be coerced to that coordinate type if possible.
+This includes the potential of lossy conversion in cases where a larger type, e.g. `INTEGER64` does not fit into the specified type, e.g. `FLOAT32`.
+| If `dimension` is omitted, it is calculated by taking the size of the `vectorValue`.
+For example a `vectorValue` with 1024 elements generates a `VECTOR` value with the dimension `1024`.
+| `dimension` must be greater than `0` and less than or equal to `4096`.
+| If `coordinateType` is omitted, the type will be determined by Cypher.
+If the `LIST` used as `vectorValue` is mixed containing exclusively `INTEGER` values, then the largest of those types will be set as the `coordinateType`.
+For example, `LIST<INTEGER64 \| INTEGER32`> generates a `VECTOR` value with a `coordinateType` of `INTEGER64`.
+If the `vectorValue` contains both `FLOAT` and `INTEGER` values, then the `coordinateType` will be that of the largest `FLOAT` present in `vectorValue`.
+For example, `LIST<INTEGER64 \| FLOAT64`> generates a `VECTOR` value with a `coordinateType` of `FLOAT64`.
+| A `null` `vectorValue`, `dimension`, or `coordinateType` will return `null`.
+|===
+
+.vector()
+=====
+
+.Construct a `VECTOR` value
+[source, cypher]
+----
+WITH vector([1, 2, 3], 3, INTEGER) AS vector
+RETURN vector, valueType(vector) AS vectorType
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| vector | vectorType
+
+| [1, 2, 3] | "VECTOR<INTEGER64 NOT NULL>(3) NOT NULL"
+
+2+d|Rows: 1
+|===
+
+
+.Construct a `VECTOR` value with a `STRING` `vectorValue`
+[source, cypher]
+----
+WITH vector("[1.05000e+00, 0.123, 5]", 3, FLOAT32) as vector
+RETURN vector, valueType(vector) AS vectorType
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| vector | vectorType
+
+| | "VECTOR<FLOAT32 NOT NULL>(3) NOT NULL"
+
+2+d|Rows: 1
+|===
+
+.Construct a `VECTOR` value omitting both `dimension` and `coordinateType`
+[source, cypher]
+----
+WITH vector([1, 2.5, 3]) AS vector
+RETURN vector, valueType(vector) AS vectorType
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| vector | vectorType
+
+| [1, 2, 3] | "VECTOR<FLOAT64 NOT NULL>(3) NOT NULL"
+
+2+d|Rows: 1
+|===
+
+When constructing a `VECTOR` value with the `vector()` function, a 
+
+.`null` values
+[source, cypher]
+----
+RETURN vector(null, 3, FLOAT32) AS nullVectorValue,
+       vector([1, 2, 3], null, INTEGER8) AS nullDimension,
+       vector([1, 2, 3], 3, null) AS nullCoordinateType
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="3*<m"]
+|===
+| nullVectorValue | nullDimension | nullCoordinateType
+
+| null | null | null
+
+3+d|Rows: 1
+|===
+
+=====
 
 [[functions-similarity-cosine]]
 == vector.similarity.cosine()
@@ -90,9 +201,9 @@ To create the graph used in this example, run the following query in an empty Ne
 [source, cypher, role=test-setup]
 ----
 CREATE
-  (:Node { id: 1, vector: [1.0, 4.0, 2.0]}),
-  (:Node { id: 2, vector: [3.0, -2.0, 1.0]}),
-  (:Node { id: 3, vector: [2.0, 8.0, 3.0]});
+  (:Node { id: 1, vector: vector([1.0, 4.0, 2.0], 3, FLOAT32) }),
+  (:Node { id: 2, vector: vector([3.0, -2.0, 1.0], 3, FLOAT32) }),
+  (:Node { id: 3, vector: vector([2.0, 8.0, 3.0], 3, FLOAT32) });
 ----
 
 Given a parameter `query` (here set to `[4.0, 5.0, 6.0]`), you can query for the two nearest neighbors of that query vector by Euclidean distance.
@@ -105,7 +216,7 @@ MATCH (node:Node)
 WITH node, vector.similarity.euclidean($query, node.vector) AS score
 RETURN node, score
 ORDER BY score DESCENDING
-LIMIT 2;
+LIMIT 2
 ----
 
 This returns the two nearest neighbors.
@@ -189,7 +300,7 @@ RETURN vector_dimension_count(vector([1, 2, 3], 3, INTEGER)) AS size
 | *Returns* 3+| `FLOAT`
 |===
 
-.`vectorDistanceMetric` algorithms
+.Supported `vectorDistanceMetric` algorithms
 [cols="1,3", options="header"]
 |===
 | Distance Type | Formula
@@ -243,7 +354,7 @@ RETURN vector_distance(vector([1, 2, 3], 3, INT), vector([1, 2, 4], 3, INT), COS
 
 |===
 
-.Calculate the distance between two `VECTOR` values using the `EUCLIDEAN` vector distance algorithm
+.Calculate the distance between two `VECTOR` values using the `EUCLIDEAN` distance algorithm
 [source, cypher]
 ----
 RETURN vector_distance(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), vector([5.0, 2.5, 3.1, 9.0], 4, FLOAT), EUCLIDEAN)
@@ -262,11 +373,69 @@ RETURN vector_distance(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), vector([5.0, 2.5,
 
 =====
 
-
-
 [role=label--new-2025.xx]
 [[functions-vector_norm]]
 == vector_norm()
 
-* `vector_norm(vector :: VECTOR, vectorDistanceMetric :: [EUCLIDEAN, MANHATTAN]) :: FLOAT`
-* Returns a `FLOAT` representing the distance between the given vector and a vector of the same dimension with all coordinates set to zero, calculated using the specified `vectorDistanceMetric`.
+.Details
+|===
+| *Syntax* 3+| `vector_norm(vector, vectorDistanceMetric)`
+| *Description* 3+|  Returns a `FLOAT` representing the norm (distance) between the given vector and an origin vector of the same dimension with all coordinates set to zero, calculated using the specified `vectorDistanceMetric`.
+.4+| *Arguments* | *Name* | *Type* | *Description*
+| `vector` | `VECTOR` | A vector for which the norm to the origin vector will be computed.
+| `vectorDistanceMetric` | `[EUCLIDEAN, MANHATTAN]` | The vector distance algorithm to calculate the distance by.
+| *Returns* 3+| `FLOAT`
+|===
+
+.Supported `vectorDistanceMetric` algorithms
+[cols="1,3", options="header"]
+|===
+| Distance Type | Formula
+
+| `EUCLIDEAN`
+| √( (A₁ - B₁)² + (A₂ - B₂)² + ... + (Aᴰ - Bᴰ)² )
+
+| `MANHATTAN`
+| \|A₁ - B₁\| + \|A₂ - B₂\| + ... + \|Aᴰ - Bᴰ\|
+
+|===
+
+
+.vector_norm()
+=====
+
+.Measure the norm between a vector and an origin vector using the `EUCLIDEAN` distance algorithm
+[source, cypher]
+----
+RETURN vector_norm(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), EUCLIDEAN) AS norm
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+
+| norm
+| 8.93812060782355
+
+1+d|Rows: 1
+
+|===
+
+.Measure the norm between a vector and an origin vector using the `EUCLIDEAN` distance algorithm
+[source, cypher]
+----
+RETURN vector_norm(Vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), 'MANHATTAN') AS norm
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+
+| norm
+| 15.7
+
+1+d|Rows: 1
+
+|===
+
+=====

modules/ROOT/pages/genai-integrations.adoc

@@ -202,7 +202,7 @@ Each returned row contains the following columns:
 * The `resource` (a `STRING`) is the name of the input resource.
 * The `vector` (a `LIST<FLOAT>`) is the generated vector embedding for this resource.
 
-[[store-multiple-embedding-vector]]
+[[store-multiple-embeddings-vector]]
 [role=label--new-2025.xx label--enterprise-edition]
 === Store multiple embeddings as vector properties
 

modules/ROOT/pages/indexes/semantic-indexes/vector-indexes.adoc

@@ -41,7 +41,7 @@ Each word or token in a text is typically represented as high-dimensional vector
 
 The embedding for a particular data object can be created by both proprietary (such as https://cloud.google.com/vertex-ai[Vertex AI] or https://openai.com/[OpenAI]) and open source (such as https://github.com/UKPLab/sentence-transformers[sentence-transformers]) embedding generators, which can produce vector embeddings with dimensions such as 256, 768, 1536, and 3072.
 Vector embeddings are stored as `LIST<INTEGER | FLOAT>` properties on a node or relationship.
-As of Neo4j 2025.xx, they can also be more efficiently stored as xref:values-and-types/vector.adoc[`VECTOR` types].
+As of Neo4j 2025.xx, they can also be more efficiently stored as xref:values-and-types/vector.adoc[`VECTOR`] property types.
 
 [NOTE]
 ====

modules/ROOT/pages/values-and-types/ordering-equality-comparison.adoc

@@ -38,6 +38,9 @@ For example, `1 > b` and `1 < b` are both `false` when `b` is NaN.
 * xref:values-and-types/spatial.adoc[Spatial values] and xref:values-and-types/vector.adoc[`VECTOR`] values cannot be compared using the operators `\<=`, `<`,`>=`, `>`.
 To compare spatial values within a specific range, use either the xref:functions/spatial.adoc#functions-withinBBox[`point.withinBBox()`] or the xref:functions/spatial.adoc#functions-point-wgs84-2d[`point()`] function.
 
+[NOTE]
+See also xref:values-and-types/vector.adoc#ordering-vector[`VECTOR` values -> Ordering `VECTOR` values].
+
 [[value-hierarchy]]
 === Hierarchy of values
 
@@ -146,61 +149,3 @@ If they have the same time and offset but different named time zones, they are s
 Since the length of a day, month, or year varies, Cypher does not define a strict ordering for durations.
 As a result, comparing two durations `(e.g, duration1 < duration2)` will always return `null`.
 
-[role=label--new-2025.xx]
-[[ordering-vector]]
-=== Vector values
-
-`VECTOR` values with a defined coordinate type and no dimension are ordered before values with only a defined dimension.
-Values with both a defined coordinate type and dimension are ordered according to the ordering of the vector coordinate types, listed in ascending order below:
-
-* `INTEGER8`
-* `INTEGER16`
-* `INTEGER32`
-* `INTEGER64`
-* `FLOAT32`
-* `FLOAT64`
-
-Within the same coordinate type, `VECTOR` values are ordered by their dimension, with smaller values first.
-`VECTOR` values of the same coordinate type and dimension are then ordered pairwise, similar to how `LIST` values are ordered.
-
-.Ordering rules for `VECTOR` values
-[cols="3,3,2,6", options="header"]
-|===
-| A | B | Ordered As | Reason
-
-| `VECTOR<FLOAT32>(12345)`
-| `VECTOR<FLOAT32>(123456)`
-| A < B
-| Same coordinate type, compare by dimension ascending.
-
-| `VECTOR<INTEGER32>(1234)`
-| `VECTOR<FLOAT32>(1234)`
-| A < B
-| Coordinate type order: `INTEGER32` < `FLOAT32`
-
-| `VECTOR<INTEGER8>`
-| `VECTOR(3)`
-| A < B
-| Coordinate type defined and no dimension < dimension defined and no coordinate type
-
-| `VECTOR<INTEGER64>(123456)`
-| `VECTOR<FLOAT32>(3)`
-| A < B
-| Coordinate type order: `INTEGER64` < `FLOAT32`, compare coordinate type first.
-
-| `VECTOR<FLOAT64>(1234)`
-| `VECTOR<FLOAT32>(1234)`
-| B < A
-| Coordinate type order: `FLOAT32` < `FLOAT64`
-
-| `VECTOR<FLOAT32>([1, 2])`
-| `VECTOR<FLOAT32>([2, 1])`
-| A < B
-| Same coordinate type and dimension, pairwise value comparison.
-
-| `VECTOR<INTEGER16>(1234)`
-| `LIST<INTEGER>`
-| A < B
-| `VECTOR` values are ordered before `LIST` values
-
-|===

modules/ROOT/pages/values-and-types/property-structural-constructed.adoc

@@ -3,7 +3,6 @@
 :description: This section provides an overview of the property, structural, and constructed data types supported by Cypher.
 :page-aliases: values-and-types/property-structural-composite.adoc
 
-
 Cypher provides first class support for a number of data value types.
 These fall into the following three categories: *property*, *structural*, and *constructed*.
 This section will first provide a brief overview of each type, and then go into more detail about the property data type.