sentence-transformers How to use cristiano-sartori/stella_finetuned with sentence-transformers:
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("cristiano-sartori/stella_finetuned", trust_remote_code=True)
sentences = [
"Prove that x + |x - 7| ≥ 7",
"The subtyping relationship between `Iterable[Pair[A, Y]]` and `Map[A, Y]` can be understood by examining the covariance and structure of these types.\n\n1. **Covariance**: Both `Iterable` and `Pair` are covariant in their type parameters. This means that if `A` is a supertype of `B`, then `Iterable[Pair[A, Y]]` can be treated as a subtype of `Iterable[Pair[B, Y]]`.\n\n2. **Map's Structure**: The `Map` class extends `Iterable[Pair[U, V]]`, where `U` is invariant and `V` is covariant. Therefore, `Map[A, Y]` is considered an `Iterable[Pair[A, Y]]`. \n\n3. **Type Compatibility**: Since `Map[A, Y]` is an `Iterable[Pair[A, Y]]`, it follows that any instance of `Map[A, Y]` can be treated as an instance of `Iterable[Pair[A, Y]]`. \n\n4. **Subtyping**: Given that `Iterable[Pair[A, Y]]` can be seen as an interface that describes a broader category of collections, while `Map[A, Y]` is a specific implementation of that interface, we conclude that `Iterable[Pair[A, Y]]` is a supertype of `Map[A, Y]`. Thus, `Iterable[Pair[A, Y]]` can be assigned to a variable of type `Map[A, Y]`, making the relationship `Iterable[Pair[A, Y]] <: Map[A, Y]`.\n\nTherefore, the correct subtyping relationship is `Iterable[Pair[A, Y]] <: Map[A, Y]`.",
"To implement a function that inserts an element into a sorted list while maintaining the sorted order, we can use recursion. The idea is to check the first element of the list and decide whether to insert the new element before it or to continue the recursion with the rest of the list.\n\nHere’s how you can implement the `insert` function in Scala:\n\n```scala\ndef insert(elem: Int, list: List[Int]): List[Int] = list match {\n case Nil => List(elem) // If the list is empty, return a new list with the element\n case head :: tail =>\n if (elem <= head) {\n elem :: list // If the element is less than or equal to the head, insert it at the front\n } else {\n head :: insert(elem, tail) // Otherwise, keep the head and recurse on the tail\n }\n}\n```\n\n### Explanation:\n1. **Base Case**: \n - If the list is empty (`Nil`), we return a new list that contains only the element `elem`.\n \n2. **Recursive Case**:\n - The list is matched against its head and tail using pattern matching. `head` is the first element, and `tail` is the remainder of the list.\n - If `elem` is less than or equal to `head`, we prepend `elem` to the list (using `::`), resulting in a new list that maintains the sorted order.\n - If `elem` is greater than `head`, we keep `head` in the resulting list and recursively call `insert` with `elem` and `tail`. This continues until we find the correct position for `elem`.\n\n### Example Usage:\n```scala\nval sortedList = List(1, 3, 5, 7)\nval newElement = 4\nval newList = insert(newElement, sortedList)\n// newList will be List(1, 3, 4, 5, 7)\n```\n\nThis recursive approach effectively ensures that the newly inserted element maintains the sorted property of the list.",
"To prove the inequality \\( x + |x - 7| \\geq 7 \\), we will analyze it by considering two cases based on the definition of the absolute value function.\n\n### Step 1: Understanding the Absolute Value\n\nThe absolute value function \\( |x - 7| \\) can be expressed in terms of piecewise functions:\n\n\\[\n|x - 7| = \n\\begin{cases} \n7 - x & \\text{if } x < 7 \\\\\nx - 7 & \\text{if } x \\geq 7 \n\\end{cases}\n\\]\n\n### Step 2: Case 1: \\( x < 7 \\)\n\nIn this case, we have:\n\n\\[\n|x - 7| = 7 - x\n\\]\n\nSubstituting this into the inequality \\( x + |x - 7| \\):\n\n\\[\nx + |x - 7| = x + (7 - x) = 7\n\\]\n\nNow, we need to check if:\n\n\\[\n7 \\geq 7\n\\]\n\nThis statement is true. Therefore, for all \\( x < 7 \\), the inequality \\( x + |x - 7| \\geq 7 \\) holds.\n\n### Step 3: Case 2: \\( x \\geq 7 \\)\n\nIn this case, we have:\n\n\\[\n|x - 7| = x - 7\n\\]\n\nSubstituting this into the inequality \\( x + |x - 7| \\):\n\n\\[\nx + |x - 7| = x + (x - 7) = 2x - 7\n\\]\n\nNow, we need to check if:\n\n\\[\n2x - 7 \\geq 7\n\\]\n\nTo solve this inequality, we can rearrange it:\n\n\\[\n2x \\geq 14 \\\\\nx \\geq 7\n\\]\n\nThis statement is also true for all \\( x \\geq 7 \\).\n\n### Conclusion\n\nCombining both cases, we find that the inequality \\( x + |x - 7| \\geq 7 \\) holds true for all \\( x \\in \\mathbb{R} \\).\n\nThus, we have proven that:\n\n\\[\nx + |x - 7| \\geq 7 \\quad \\forall x \\in \\mathbb{R}.\n\\]"
]
embeddings = model.encode(sentences)
similarities = model.similarity(embeddings, embeddings)
print(similarities.shape)
# [4, 4] 
