question stringlengths 6 3.53k | text stringlengths 17 2.05k | source stringclasses 1 value |
|---|---|---|
Design a one-pass (streaming) algorithm that, for a stream that possesses a majority element (appearing more than $m/2$ times), terminates with this element. Prove the correctness of your algorithm. | If a second pass is not performed and there is no majority the algorithm will not detect that no majority exists. In the case that no strict majority exists, the returned element can be arbitrary; it is not guaranteed to be the element that occurs most often (the mode of the sequence). It is not possible for a streaming algorithm to find the most frequent element in less than linear space, for sequences whose number of repetitions can be small. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Design a one-pass (streaming) algorithm that, for a stream that possesses a majority element (appearing more than $m/2$ times), terminates with this element. Prove the correctness of your algorithm. | In computing, a one-pass algorithm or single-pass algorithm is a streaming algorithm which reads its input exactly once. It does so by processing items in order, without unbounded buffering; it reads a block into an input buffer, processes it, and moves the result into an output buffer for each step in the process. A one-pass algorithm generally requires O(n) (see 'big O' notation) time and less than O(n) storage (typically O(1)), where n is the size of the input. An example of a one-pass algorithm is the Sondik partially observable Markov decision process. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $f\colon \mathbb{R}\rightarrow \mathbb{R}$ and $g\colon\mathbb{R}\rightarrow \mathbb{R}$ are two functions defined on all $\mathbb{R}$. If $f\circ g$ is injective, then $g$ is injective. | If f {\displaystyle f} and g {\displaystyle g} are both injective then f ∘ g {\displaystyle f\circ g} is injective. If g ∘ f {\displaystyle g\circ f} is injective, then f {\displaystyle f} is injective (but g {\displaystyle g} need not be). f: X → Y {\displaystyle f:X\to Y} is injective if and only if, given any functions g , {\displaystyle g,} h: W → X {\displaystyle h:W\to X} whenever f ∘ g = f ∘ h , {\displaystyle f\circ g=f\circ h,} then g = h . {\displaystyle g=h.} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $f\colon \mathbb{R}\rightarrow \mathbb{R}$ and $g\colon\mathbb{R}\rightarrow \mathbb{R}$ are two functions defined on all $\mathbb{R}$. If $f\circ g$ is injective, then $g$ is injective. | Let f: A → B {\displaystyle f:A\to B} and g: B → A {\displaystyle g:B\to A} be the two injective functions. Then define the sets: C 0 = A ∖ g ( B ) {\displaystyle C_{0}=A\setminus g(B)\quad } and C k + 1 = g ( f ( C k ) ) {\displaystyle \quad C_{k+1}=g(f(C_{k}))} for k ∈ { 0 , 1 , 2 , 3 , . . . } | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Suppose that you are given an insertion only stream of items. For every $k\geq 1$, give an algorithm that at each point in the stream maintains $k$ uniformly random elements from the prefix of the stream sampled without replacement. Your algorithm must use $O(k\log n)$ space. | If we associate with each item of the input a uniformly generated random number, the k items with the largest (or, equivalently, smallest) associated values form a simple random sample. A simple reservoir-sampling thus maintains the k items with the currently largest associated values in a priority queue. The expected running time of this algorithm is O ( n + k log k log ( n / k ) ) {\displaystyle O(n+k\log k\log(n/k))} and it is relevant mainly because it can easily be extended to items with weights. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Suppose that you are given an insertion only stream of items. For every $k\geq 1$, give an algorithm that at each point in the stream maintains $k$ uniformly random elements from the prefix of the stream sampled without replacement. Your algorithm must use $O(k\log n)$ space. | A k_insert operation assigns the elements uniformly random to the processors which insert the elements into their local queues. Note that single elements can still be inserted into the queue. Using this strategy the global smallest elements are in the union of the local smallest elements of every processor with high probability. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the problem of finding a maximum cardinality set packing in the semi-streaming model. An instance of this problem consists of a known universe $U$ of $n$ elements and sets $S \subseteq U$ are streamed one-by-one. The goal is to select a family $\mathcal{T}$ of pairwise disjoint sets (i.e., $S\cap S' = \emptyset$ for any two distinct sets $S, S' \in \mathcal{T}$) of maximum cardinality while only using $O(n\cdot \textrm{poly}\log n)$ storage space. Devise an algorithm in this setting that returns a set packing of cardinality at least $1/k$ times that of a maximum cardinality set packing, assuming that each streamed set $S$ has cardinality at most $k$, i.e., $|S| \leq k$. \\[0mm] {\em (In this problem you are asked to (i) design the algorithm, (ii) show that it uses $O(n\cdot \textrm{\textnormal{poly}}{\log n})$ space, and (iii) prove that it returns a solution of cardinality at least $1/k$ times the cardinality of a maximum cardinality set packing. Recall that you are allowed to refer to material covered in the course.) } | The problem is clearly in NP since, given t {\displaystyle t} subsets, we can easily verify that they are pairwise disjoint in polynomial time. The optimization version of the problem, maximum set packing, asks for the maximum number of pairwise disjoint sets in the list. It is a maximization problem that can be formulated naturally as an integer linear program, belonging to the class of packing problems. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the problem of finding a maximum cardinality set packing in the semi-streaming model. An instance of this problem consists of a known universe $U$ of $n$ elements and sets $S \subseteq U$ are streamed one-by-one. The goal is to select a family $\mathcal{T}$ of pairwise disjoint sets (i.e., $S\cap S' = \emptyset$ for any two distinct sets $S, S' \in \mathcal{T}$) of maximum cardinality while only using $O(n\cdot \textrm{poly}\log n)$ storage space. Devise an algorithm in this setting that returns a set packing of cardinality at least $1/k$ times that of a maximum cardinality set packing, assuming that each streamed set $S$ has cardinality at most $k$, i.e., $|S| \leq k$. \\[0mm] {\em (In this problem you are asked to (i) design the algorithm, (ii) show that it uses $O(n\cdot \textrm{\textnormal{poly}}{\log n})$ space, and (iii) prove that it returns a solution of cardinality at least $1/k$ times the cardinality of a maximum cardinality set packing. Recall that you are allowed to refer to material covered in the course.) } | Set packing is a classical NP-complete problem in computational complexity theory and combinatorics, and was one of Karp's 21 NP-complete problems. Suppose one has a finite set S and a list of subsets of S. Then, the set packing problem asks if some k subsets in the list are pairwise disjoint (in other words, no two of them share an element). More formally, given a universe U {\displaystyle {\mathcal {U}}} and a family S {\displaystyle {\mathcal {S}}} of subsets of U {\displaystyle {\mathcal {U}}} , a packing is a subfamily C ⊆ S {\displaystyle {\mathcal {C}}\subseteq {\mathcal {S}}} of sets such that all sets in C {\displaystyle {\mathcal {C}}} are pairwise disjoint. The size of the packing is | C | {\displaystyle |{\mathcal {C}}|} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this problem, we consider a generalization of the min-cost perfect matching problem. The generalization is called the \emph{min-cost perfect $b$-matching problem} and is defined as follows: \begin{description} \item[Input:] A graph $G = (V,E)$ with edge costs $c: E \rightarrow \mathbb{R}$ and degree bounds $b: V \rightarrow \{1,2, \ldots, n\}$. \item[Output:] A subset $F \subseteq E$ of minimum cost $\sum_{e\in F} c(e)$ such that for each vertex $v\in V$: \begin{itemize} \item The number of edges incident to $v$ in $F$ equals $b(v)$, i.e., $|\{e\in F : v \in e\}| = b(v)$. \end{itemize} \end{description} Note that min-cost perfect matching problem is the special case when $b(v) =1$ for all $v\in V$. An example with general $b$'s is as follows: \begin{tikzpicture} \node at (1, 2.8) {Input}; \node[vertex] (u1) at (0,2) {$u_1$}; \node[vertex] (u2) at (0,0) {$u_2$}; \node[vertex] (v1) at (2,2) {$v_1$}; \node[vertex] (v2) at (2,0) {$v_2$}; \node[left = 0.1cm of u1] {$b(u_1) = 1$}; \node[left = 0.1cm of u2] {$b(u_2) = 2$}; \node[right = 0.1cm of v1] {$b(v_1) = 1$}; \node[right = 0.1cm of v2] {$b(v_2) = 2$}; \draw (u1) edge[ultra thick] (v1) edge (v2); \draw (u2) edge (v1) edge[ultra thick] (v2); \begin{scope}[xshift=7cm] \node at (1, 2.8) {Output}; \node[vertex] (u1) at (0,2) {$u_1$}; \node[vertex] (u2) at (0,0) {$u_2$}; \node[vertex] (v1) at (2,2) {$v_1$}; \node[vertex] (v2) at (2,0) {$v_2$}; \draw (u1) edge (v2); \draw (u2) edge (v1) edge[ultra thick] (v2); \end{scope} \end{tikzpicture} On the left, we illustrate the input graph with the degree bounds (the $b$'s). Thin and thick edges have cost $1$ and $2$, respectively. On the right, we illustrate a solution of cost $1+1 +2 = 4$. It is a feasible solution since the degree of each vertex $v$ equals $b(v)$ in the solution. Your task is to prove the following statement: If the input graph $G=(V,E)$ is bipartite then any extreme point solution to the following linear programming relaxation (that has a variable $x_e$ for every edge $e\in E$) is integral: \begin{align*} \textbf{Minimize} \hspace{0.8cm} & \sum_{e\in E} c(e) x_e\\ \textbf{subject to}\hspace{0.8cm} & \sum_{e\in E: v\in e} x_e = b(v) \qquad \mbox{for all $v\in V$}\\ \hspace{0.8cm} & \hspace{0.9cm} 0 \leq x_e \leq 1 \hspace{0.9cm} \mbox{for all $e\in E$}. \end{align*} {\em (In this problem you are asked to prove that every extreme point solution to the above linear program is integral assuming that the input graph $G$ is bipartite. Recall that you are allowed to refer to material covered in the lecture notes.)} | The algorithm can equivalently be described by formulating the problem using a bipartite graph. We have a complete bipartite graph G = ( S , T ; E ) {\displaystyle G=(S,T;E)} with n worker vertices (S) and n job vertices (T), and the edges (E) each have a nonnegative cost c ( i , j ) {\displaystyle c(i,j)} . We want to find a perfect matching with a minimum total cost. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this problem, we consider a generalization of the min-cost perfect matching problem. The generalization is called the \emph{min-cost perfect $b$-matching problem} and is defined as follows: \begin{description} \item[Input:] A graph $G = (V,E)$ with edge costs $c: E \rightarrow \mathbb{R}$ and degree bounds $b: V \rightarrow \{1,2, \ldots, n\}$. \item[Output:] A subset $F \subseteq E$ of minimum cost $\sum_{e\in F} c(e)$ such that for each vertex $v\in V$: \begin{itemize} \item The number of edges incident to $v$ in $F$ equals $b(v)$, i.e., $|\{e\in F : v \in e\}| = b(v)$. \end{itemize} \end{description} Note that min-cost perfect matching problem is the special case when $b(v) =1$ for all $v\in V$. An example with general $b$'s is as follows: \begin{tikzpicture} \node at (1, 2.8) {Input}; \node[vertex] (u1) at (0,2) {$u_1$}; \node[vertex] (u2) at (0,0) {$u_2$}; \node[vertex] (v1) at (2,2) {$v_1$}; \node[vertex] (v2) at (2,0) {$v_2$}; \node[left = 0.1cm of u1] {$b(u_1) = 1$}; \node[left = 0.1cm of u2] {$b(u_2) = 2$}; \node[right = 0.1cm of v1] {$b(v_1) = 1$}; \node[right = 0.1cm of v2] {$b(v_2) = 2$}; \draw (u1) edge[ultra thick] (v1) edge (v2); \draw (u2) edge (v1) edge[ultra thick] (v2); \begin{scope}[xshift=7cm] \node at (1, 2.8) {Output}; \node[vertex] (u1) at (0,2) {$u_1$}; \node[vertex] (u2) at (0,0) {$u_2$}; \node[vertex] (v1) at (2,2) {$v_1$}; \node[vertex] (v2) at (2,0) {$v_2$}; \draw (u1) edge (v2); \draw (u2) edge (v1) edge[ultra thick] (v2); \end{scope} \end{tikzpicture} On the left, we illustrate the input graph with the degree bounds (the $b$'s). Thin and thick edges have cost $1$ and $2$, respectively. On the right, we illustrate a solution of cost $1+1 +2 = 4$. It is a feasible solution since the degree of each vertex $v$ equals $b(v)$ in the solution. Your task is to prove the following statement: If the input graph $G=(V,E)$ is bipartite then any extreme point solution to the following linear programming relaxation (that has a variable $x_e$ for every edge $e\in E$) is integral: \begin{align*} \textbf{Minimize} \hspace{0.8cm} & \sum_{e\in E} c(e) x_e\\ \textbf{subject to}\hspace{0.8cm} & \sum_{e\in E: v\in e} x_e = b(v) \qquad \mbox{for all $v\in V$}\\ \hspace{0.8cm} & \hspace{0.9cm} 0 \leq x_e \leq 1 \hspace{0.9cm} \mbox{for all $e\in E$}. \end{align*} {\em (In this problem you are asked to prove that every extreme point solution to the above linear program is integral assuming that the input graph $G$ is bipartite. Recall that you are allowed to refer to material covered in the lecture notes.)} | Let G′ = (V′ = A ∪ B, E′ = E). Assign the capacity of all the edges in E′ to 1. Add a source vertex s and connect it to all the vertices in A′ and add a sink vertex t and connect all vertices inside group B′ to this vertex. The capacity of all the new edges is 1 and their costs is 0. It is proved that there is minimum weight perfect bipartite matching in G if and only if there a minimum cost flow in G′. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Two excellent students, Alice from EPFL and Bob from MIT, have both built their own spam filters. A spam filter is an algorithm that takes as input an email and outputs $1$ if the email is spam and $0$ otherwise. Alice and Bob now want to compare their two spam filters. To perform the comparison, they both download the same huge data set consisting of $n$ emails out of which some are spam. Alice then runs her spam filter on the data set to obtain $a_1, a_2, \ldots, a_n$ where $a_i \in \{0,1\}$ is the output of her spam filter on the $i$:th email in the data set. Similarly, Bob runs his spam filter on the data set to obtain $b_1, b_2, \ldots, b_n$ where $b_i \in \{0,1\}$ is the output of his spam filter on the $i$:th email in the data set. Their goal is then to determine whether their outputs are the same. An issue that they face is that $a_1, a_2,\ldots, a_n$ are stored on Alice's computer and $b_1, b_2, \ldots, b_n$ are stored on Bob's computer. They thus need to transfer (or communicate) information to solve the problem. A trivial solution is for Alice to transfer all her outputs $a_1, a_2,\ldots, a_n$ to Bob who then performs the comparison. However, this requires Alice to send $n$ bits of information to Bob; an operation that is very costly for a huge data set. In the following, we use randomization to achieve a huge improvement on the number of bits transfered between Alice and Bob. \\[0mm] Specifically, motivated by something called pseudo-random generators, we assume that Alice and Bob have access to the same randomness (called shared randomness). That is, Alice and Bob have access to the same infinite stream of random bits $r_1, r_2, \ldots$. Your task is now to use this shared randomness to devise a randomized protocol of the following type: \begin{itemize} \item As a function of $a_1, a_2, \ldots, a_n$ and the random bits $r_1, r_2, \ldots$, Alice computes a message $m$ that consists of only $2$ bits. She then transmits this $2$-bit message $m$ to Bob. \item Bob then, as a function of $b_1, b_2, \ldots, b_n$, the message $m$, and the random bits $r_1, r_2, \ldots$, outputs \textsc{Equal} or \textsc{Not Equal}. \end{itemize} Bob's output is correct if he outputs $\textsc{Equal}$ when $a_i = b_i$ for all $i\in \{1,\ldots, n\}$ and $\textsc{Not Equal}$ otherwise. Your protocol should ensure that Bob outputs the correct answer with probability at least $2/3$, where the probability is over the random bits $r_1, r_2, \ldots $.\\ {\em (In this problem you are asked to (i) explain how Alice computes the message $m$ of $2$ bits (ii) explain how Bob calculates his output, and (iii) prove that Bob's output is correct with probability at least $2/3$. A correct solution where Alice sends a message $m$ of $O(\log n)$ bits is rewarded $12$ points. Recall that you are allowed to refer to material covered in the lecture notes.) }\\ \noindent {\small An interesting fact (but unrelated to the exam) is that any correct deterministic strategy would require Alice and Bob to send $n$ bits of information.} | Statistics show that the current probability of any message being spam is 80%, at the very least: Pr ( S ) = 0.8 ; Pr ( H ) = 0.2 {\displaystyle \Pr(S)=0.8;\Pr(H)=0.2} However, most bayesian spam detection software makes the assumption that there is no a priori reason for any incoming message to be spam rather than ham, and considers both cases to have equal probabilities of 50%: Pr ( S ) = 0.5 ; Pr ( H ) = 0.5 {\displaystyle \Pr(S)=0.5;\Pr(H)=0.5} The filters that use this hypothesis are said to be "not biased", meaning that they have no prejudice regarding the incoming email. This assumption permits simplifying the general formula to: Pr ( S | W ) = Pr ( W | S ) Pr ( W | S ) + Pr ( W | H ) {\displaystyle \Pr(S|W)={\frac {\Pr(W|S)}{\Pr(W|S)+\Pr(W|H)}}} This is functionally equivalent to asking, "what percentage of occurrences of the word "replica" appear in spam messages?" This quantity is called "spamicity" (or "spaminess") of the word "replica", and can be computed. The number Pr ( W | S ) {\displaystyle \Pr(W|S)} used in this formula is approximated to the frequency of messages containing "replica" in the messages identified as spam during the learning phase. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Two excellent students, Alice from EPFL and Bob from MIT, have both built their own spam filters. A spam filter is an algorithm that takes as input an email and outputs $1$ if the email is spam and $0$ otherwise. Alice and Bob now want to compare their two spam filters. To perform the comparison, they both download the same huge data set consisting of $n$ emails out of which some are spam. Alice then runs her spam filter on the data set to obtain $a_1, a_2, \ldots, a_n$ where $a_i \in \{0,1\}$ is the output of her spam filter on the $i$:th email in the data set. Similarly, Bob runs his spam filter on the data set to obtain $b_1, b_2, \ldots, b_n$ where $b_i \in \{0,1\}$ is the output of his spam filter on the $i$:th email in the data set. Their goal is then to determine whether their outputs are the same. An issue that they face is that $a_1, a_2,\ldots, a_n$ are stored on Alice's computer and $b_1, b_2, \ldots, b_n$ are stored on Bob's computer. They thus need to transfer (or communicate) information to solve the problem. A trivial solution is for Alice to transfer all her outputs $a_1, a_2,\ldots, a_n$ to Bob who then performs the comparison. However, this requires Alice to send $n$ bits of information to Bob; an operation that is very costly for a huge data set. In the following, we use randomization to achieve a huge improvement on the number of bits transfered between Alice and Bob. \\[0mm] Specifically, motivated by something called pseudo-random generators, we assume that Alice and Bob have access to the same randomness (called shared randomness). That is, Alice and Bob have access to the same infinite stream of random bits $r_1, r_2, \ldots$. Your task is now to use this shared randomness to devise a randomized protocol of the following type: \begin{itemize} \item As a function of $a_1, a_2, \ldots, a_n$ and the random bits $r_1, r_2, \ldots$, Alice computes a message $m$ that consists of only $2$ bits. She then transmits this $2$-bit message $m$ to Bob. \item Bob then, as a function of $b_1, b_2, \ldots, b_n$, the message $m$, and the random bits $r_1, r_2, \ldots$, outputs \textsc{Equal} or \textsc{Not Equal}. \end{itemize} Bob's output is correct if he outputs $\textsc{Equal}$ when $a_i = b_i$ for all $i\in \{1,\ldots, n\}$ and $\textsc{Not Equal}$ otherwise. Your protocol should ensure that Bob outputs the correct answer with probability at least $2/3$, where the probability is over the random bits $r_1, r_2, \ldots $.\\ {\em (In this problem you are asked to (i) explain how Alice computes the message $m$ of $2$ bits (ii) explain how Bob calculates his output, and (iii) prove that Bob's output is correct with probability at least $2/3$. A correct solution where Alice sends a message $m$ of $O(\log n)$ bits is rewarded $12$ points. Recall that you are allowed to refer to material covered in the lecture notes.) }\\ \noindent {\small An interesting fact (but unrelated to the exam) is that any correct deterministic strategy would require Alice and Bob to send $n$ bits of information.} | The question asked to the program is: "what is the probability for a given text to be spam knowing which words appear and don't appear in this text?" It can be formalized by: P ( Spam ∣ w 0 ∧ ⋯ ∧ w N − 1 ) {\displaystyle P({\text{Spam}}\mid w_{0}\wedge \cdots \wedge w_{N-1})} which can be computed as follows: P ( Spam ∣ w 0 ∧ ⋯ ∧ w N − 1 ) = P ( Spam ) ∏ n = 0 N − 1 ∑ Spam ] {\displaystyle {\begin{aligned}&P({\text{Spam}}\mid w_{0}\wedge \cdots \wedge w_{N-1})\\={}&{\frac {\displaystyle P({\text{Spam}})\prod _{n=0}^{N-1}}{\displaystyle \sum _{\text{Spam}}]}}\end{aligned}}} The denominator appears to be a normalization constant. It is not necessary to compute it to decide if we are dealing with spam. For instance, an easy trick is to compute the ratio: P ( ∣ w 0 ∧ ⋯ ∧ w N − 1 ) P ( ∣ w 0 ∧ ⋯ ∧ w N − 1 ) = P ( ) P ( ) × ∏ n = 0 N − 1 ) P ( w n ∣ ) ] {\displaystyle {\begin{aligned}&{\frac {P(\mid w_{0}\wedge \cdots \wedge w_{N-1})}{P(\mid w_{0}\wedge \cdots \wedge w_{N-1})}}\\={}&{\frac {P()}{P()}}\times \prod _{n=0}^{N-1}\left)}{P(w_{n}\mid )}}\right]\end{aligned}}} This computation is faster and easier because it requires only 2 N {\displaystyle 2N} products. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following algorithm that takes as input an undirected graph $G=(V,E)$: \begin{center} \begin{boxedminipage}[t]{0.85\textwidth} \begin{minipage}{14cm} \begin{verse} \textsc{SimpleCut}$(G=(V,E))$: \\[2mm] 1. Let $\mathcal{H}$ be a $2$-universal family of hash functions $h: V \to \{0,1\}$. \\[1mm] 2. Select $h \in \mathcal{H}$ at random. \\[1mm] 3. \RETURN the vertex set $S = \{v\in V: h(v) = 0\}$. \end{verse} \end{minipage} \end{boxedminipage} \end{center} Prove the following: \begin{itemize} \item[]In expectation, the set $S$ returned by \textsc{SimpleCut} cuts at least $|E|/2$ edges. \end{itemize} {\em (In this problem you are asked to prove the above statement. Recall that you are allowed to refer to material covered in the lecture notes.)} | Since m {\displaystyle m} is a constant, hashing requires time O ( n log n log log n ) {\displaystyle O(n\log n\log \log n)} . They proved that the hash function family is collision resistant by showing that if there is a polynomial-time algorithm that succeeds with non-negligible probability in finding b ≠ b ′ ∈ D m {\displaystyle b\neq b'\in D^{m}} such that h ( b ) = h ( b ′ ) {\displaystyle h(b)=h(b')} , for a randomly chosen hash function h ∈ R m {\displaystyle h\in R^{m}} , then a certain problem called the “shortest vector problem” is solvable in polynomial time for every ideal of the ring Z / ⟨ f ⟩ {\displaystyle \mathbb {Z} /\langle f\rangle } . Based on the work of Lyubashevsky and Micciancio in 2006, Micciancio and Regev defined the following algorithm of hash functions based on ideal lattices: Parameters: Integers q , n , m , d {\displaystyle q,n,m,d} with n ∣ m {\displaystyle n\mid m} , and vector f ∈ Z n {\displaystyle \in \mathbb {Z} ^{n}} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following algorithm that takes as input an undirected graph $G=(V,E)$: \begin{center} \begin{boxedminipage}[t]{0.85\textwidth} \begin{minipage}{14cm} \begin{verse} \textsc{SimpleCut}$(G=(V,E))$: \\[2mm] 1. Let $\mathcal{H}$ be a $2$-universal family of hash functions $h: V \to \{0,1\}$. \\[1mm] 2. Select $h \in \mathcal{H}$ at random. \\[1mm] 3. \RETURN the vertex set $S = \{v\in V: h(v) = 0\}$. \end{verse} \end{minipage} \end{boxedminipage} \end{center} Prove the following: \begin{itemize} \item[]In expectation, the set $S$ returned by \textsc{SimpleCut} cuts at least $|E|/2$ edges. \end{itemize} {\em (In this problem you are asked to prove the above statement. Recall that you are allowed to refer to material covered in the lecture notes.)} | As a result, the statistical distance to a uniform family is O ( m / p ) {\displaystyle O(m/p)} , which becomes negligible when p ≫ m {\displaystyle p\gg m} . The family of simpler hash functions h a ( x ) = ( a x mod p ) mod m {\displaystyle h_{a}(x)=(ax~{\bmod {~}}p)~{\bmod {~}}m} is only approximately universal: Pr { h a ( x ) = h a ( y ) } ≤ 2 / m {\displaystyle \Pr\{h_{a}(x)=h_{a}(y)\}\leq 2/m} for all x ≠ y {\displaystyle x\neq y} . Moreover, this analysis is nearly tight; Carter and Wegman show that Pr { h a ( 1 ) = h a ( m + 1 ) } ≥ 2 / ( m − 1 ) {\displaystyle \Pr\{h_{a}(1)=h_{a}(m+1)\}\geq 2/(m-1)} whenever ( p − 1 ) mod m = 1 {\displaystyle (p-1)~{\bmod {~}}m=1} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Church booleans are a representation of booleans in the lambda calculus. The Church encoding of true and false are functions of two parameters: Church encoding of tru: t => f => t Church encoding of fls: t => f => f What does the following function implement? b => c => b (not c) c | Church Booleans are the Church encoding of the Boolean values true and false. Some programming languages use these as an implementation model for Boolean arithmetic; examples are Smalltalk and Pico. Boolean logic may be considered as a choice. The Church encoding of true and false are functions of two parameters: true chooses the first parameter. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Church booleans are a representation of booleans in the lambda calculus. The Church encoding of true and false are functions of two parameters: Church encoding of tru: t => f => t Church encoding of fls: t => f => f What does the following function implement? b => c => b (not c) c | false chooses the second parameter.The two definitions are known as Church Booleans: true ≡ λ a . λ b . a false ≡ λ a . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
A leftist min heap is a tree that satisfies the following properties:
P.1 Min heap: For any given node C, if P is a parent node of C, then the value of P is less than or equal
to the value of C.
P.2 Leftist heap: For any given node C, if L is a left child of C and R is a right child of C, then the rank
of R is less than or equal to the rank of L. Here, rank of C is the number of edges on the shortest path
from node C to a leaf node.
Consider the following implementation of a leftist min heap:
1 sealed abstract class Heap
2 case class Empty() extends Heap
3 case class Node(rank: Int, value: Int, h1: Heap, h2: Heap) extends Heap
4 def rank(h: Heap): Int = h match
5 case Empty() => -1
6 case Node(r, v, h1, h2) => r
7 def insert(x: Int, h: Heap) = merge(h, Node(0, x, Empty(), Empty()))
8 def findMin(h: Heap): Int = h match
9 case Empty() => 0
10 case Node(_, x, _, _) => x
11 def deleteMin(h: Heap): Heap = h match
12 case Empty() => h
13 case Node(_, x, lh, rh) => merge(lh, rh)
14
15 // Merge two leftist min heaps h1 and h2
16 def merge(h1: Heap, h2: Heap): Heap =
17 def shake(x: Int, lh: Heap, rh: Heap) =
18 // Ensure the leftist property
19 (lh, rh) match
20 SSS
21 case _ => Node(rank(lh) + 1, x, rh, lh)
22 // Ensure the min property
23 (h1, h2) match
24 case (Empty(), h) => h
25 case (h, Empty()) => h
26 MMM
27 case (Node(_, x1, lh1, rh1), _: Node) => shake(x1, lh1, merge(rh1, h2))
Figure 1 shows two example leftist min heaps, with values inside each node and ranks next to each node.
To merge the two heaps, we first obtain the min heap from Figure 2, which satisfies the property P.1 but
not the property P.2, and finally the leftist min heap from Figure 3, which satisfies both properties.
Complete the implementation of the merge function by replacing SSS and MMM
lines:
A. case _ => if (rank(lh) >= rank(rh)) Node(rank(rh) + 1, x, lh, rh)
B. case _ if (rank(lh) >= rank(rh)) => Node(rank(rh) + 1, x, lh, rh)
C. case (Node(r1, x1, _, _), Node(r2, x2, _, _)) => if (r1 >= r2) Node(rank(rh)
+ 1, x, lh, rh)
D. case (Node(r1, x1, lh1, rh1), Node(r2, x2, lh2, rh2)) => if (x1 > x2) shake(
x2, lh2, merge(h1, rh2))
E. case (Node(_, x1, lh1, rh1), Node(_, x2, lh2, rh2)) if (x1 > x2) => shake(x2
, lh2, merge(h1, rh2))
F. case _ if (x1 > x2) => shake(x2, lh2, merge(h1, rh2)) | In computer science, a leftist tree or leftist heap is a priority queue implemented with a variant of a binary heap. Every node x has an s-value which is the distance to the nearest leaf in subtree rooted at x. In contrast to a binary heap, a leftist tree attempts to be very unbalanced. In addition to the heap property, leftist trees are maintained so the right descendant of each node has the lower s-value. The height-biased leftist tree was invented by Clark Allan Crane. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
A leftist min heap is a tree that satisfies the following properties:
P.1 Min heap: For any given node C, if P is a parent node of C, then the value of P is less than or equal
to the value of C.
P.2 Leftist heap: For any given node C, if L is a left child of C and R is a right child of C, then the rank
of R is less than or equal to the rank of L. Here, rank of C is the number of edges on the shortest path
from node C to a leaf node.
Consider the following implementation of a leftist min heap:
1 sealed abstract class Heap
2 case class Empty() extends Heap
3 case class Node(rank: Int, value: Int, h1: Heap, h2: Heap) extends Heap
4 def rank(h: Heap): Int = h match
5 case Empty() => -1
6 case Node(r, v, h1, h2) => r
7 def insert(x: Int, h: Heap) = merge(h, Node(0, x, Empty(), Empty()))
8 def findMin(h: Heap): Int = h match
9 case Empty() => 0
10 case Node(_, x, _, _) => x
11 def deleteMin(h: Heap): Heap = h match
12 case Empty() => h
13 case Node(_, x, lh, rh) => merge(lh, rh)
14
15 // Merge two leftist min heaps h1 and h2
16 def merge(h1: Heap, h2: Heap): Heap =
17 def shake(x: Int, lh: Heap, rh: Heap) =
18 // Ensure the leftist property
19 (lh, rh) match
20 SSS
21 case _ => Node(rank(lh) + 1, x, rh, lh)
22 // Ensure the min property
23 (h1, h2) match
24 case (Empty(), h) => h
25 case (h, Empty()) => h
26 MMM
27 case (Node(_, x1, lh1, rh1), _: Node) => shake(x1, lh1, merge(rh1, h2))
Figure 1 shows two example leftist min heaps, with values inside each node and ranks next to each node.
To merge the two heaps, we first obtain the min heap from Figure 2, which satisfies the property P.1 but
not the property P.2, and finally the leftist min heap from Figure 3, which satisfies both properties.
Complete the implementation of the merge function by replacing SSS and MMM
lines:
A. case _ => if (rank(lh) >= rank(rh)) Node(rank(rh) + 1, x, lh, rh)
B. case _ if (rank(lh) >= rank(rh)) => Node(rank(rh) + 1, x, lh, rh)
C. case (Node(r1, x1, _, _), Node(r2, x2, _, _)) => if (r1 >= r2) Node(rank(rh)
+ 1, x, lh, rh)
D. case (Node(r1, x1, lh1, rh1), Node(r2, x2, lh2, rh2)) => if (x1 > x2) shake(
x2, lh2, merge(h1, rh2))
E. case (Node(_, x1, lh1, rh1), Node(_, x2, lh2, rh2)) if (x1 > x2) => shake(x2
, lh2, merge(h1, rh2))
F. case _ if (x1 > x2) => shake(x2, lh2, merge(h1, rh2)) | A weak heap is most easily understood as a heap-ordered multi-way tree stored as a binary tree using the "right-child left-sibling" convention. (This is equivalent to, but reversed from, the usual left-child right-sibling binary tree.) In the multi-way tree, and assuming a max-heap, each parent's key is greater than or equal to (≥) all the child keys (and thus, by induction, all members of the subtree). Expressed as a binary tree, this translates to the following invariants: The root node has no left child For every node, the value associated with that node is greater than or equal to the values associated with all nodes in its right subtree. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Remember that monoids can be represented by the following type class:
1 trait SemiGroup[T]:
2 extension (x: T) def combine (y: T): T
3
4 trait Monoid[T] extends SemiGroup[T]:
5 def unit: T
Additionally the three following laws should hold for all Monoid[M] and all a, b, c: M:
(Associativity) a.combine(b).combine(c) === a.combine(b.combine(c))
(Left unit) unit.combine(a) === a
(Right unit) a.combine(unit) === a
Consider the following implementation of Monoid for Boolean:
1 given Or: Monoid[Boolean] with
2 extension (x: Boolean) def combine (y: Boolean): Boolean = x || y
3 def unit: Boolean = true
Which of the three monoid laws does it fullfil?
None of them
Only Associativity
Only Left unit
Only Right unit
Only Associativity and Left unit
Only Associativity and Right unit
Only Left unit and Right unit
All of them | In particular, when an identity element is required by the type of structure, the identity element of the first structure must be mapped to the corresponding identity element of the second structure. For example: A semigroup homomorphism is a map between semigroups that preserves the semigroup operation. A monoid homomorphism is a map between monoids that preserves the monoid operation and maps the identity element of the first monoid to that of the second monoid (the identity element is a 0-ary operation). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Remember that monoids can be represented by the following type class:
1 trait SemiGroup[T]:
2 extension (x: T) def combine (y: T): T
3
4 trait Monoid[T] extends SemiGroup[T]:
5 def unit: T
Additionally the three following laws should hold for all Monoid[M] and all a, b, c: M:
(Associativity) a.combine(b).combine(c) === a.combine(b.combine(c))
(Left unit) unit.combine(a) === a
(Right unit) a.combine(unit) === a
Consider the following implementation of Monoid for Boolean:
1 given Or: Monoid[Boolean] with
2 extension (x: Boolean) def combine (y: Boolean): Boolean = x || y
3 def unit: Boolean = true
Which of the three monoid laws does it fullfil?
None of them
Only Associativity
Only Left unit
Only Right unit
Only Associativity and Left unit
Only Associativity and Right unit
Only Left unit and Right unit
All of them | Some authors regard "semigroup" and "monoid" as synonyms. Here a semigroup need not have an identity element; a monoid is a semigroup with an identity element (also called "unit"). Since the notion of functions acting on a set always includes the notion of an identity function, which when applied to the set does nothing, a transformation semigroup can be made into a monoid by adding the identity function. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The little Fermat theorem states that for a prime $n$ and any $b\in \mathbb{Z}_n ^\star$ we have\dots | An analogue of Fermat's little theorem is true in Z {\displaystyle \mathbb {Z} }: if α {\displaystyle \alpha } is not divisible by a prime π {\displaystyle \pi } , α N ( π ) − 1 ≡ 1 mod π . {\displaystyle \alpha ^{N(\pi )-1}\equiv 1{\bmod {\pi }}.} Now assume that N ( π ) ≠ 3 {\displaystyle N(\pi )\neq 3} so that N ( π ) ≡ 1 mod 3 . {\displaystyle N(\pi )\equiv 1{\bmod {3}}.} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The little Fermat theorem states that for a prime $n$ and any $b\in \mathbb{Z}_n ^\star$ we have\dots | This article collects together a variety of proofs of Fermat's little theorem, which states that a p ≡ a ( mod p ) {\displaystyle a^{p}\equiv a{\pmod {p}}} for every prime number p and every integer a (see modular arithmetic). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The number of permutations on a set of $n$ elements | A k-element combination of an n-set S is a k element subset of S, the elements of which are not ordered. By taking all the k element subsets of S and ordering each of them in all possible ways, we obtain all the k-permutations of S. The number of k-combinations of an n-set, C(n,k), is therefore related to the number of k-permutations of n by: C ( n , k ) = P ( n , k ) P ( k , k ) = n ! ( n − k ) ! | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The number of permutations on a set of $n$ elements | (n − k)! permutations, and in each of them the image of the first k elements of U is exactly S. Each permutation may only be associated with a single set in A, for if two prefixes of a permutation both formed sets in A then one would be a subset of the other. Therefore, the number of permutations that can be generated by this procedure is ∑ S ∈ A | S | ! | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select \emph{incorrect} statement. Complexity analysis of an attack consideres | (The overall complexity is additionally quadratic to the number of characters left to match.) Git/Rsync's wildmatch ABORT also covers invalid inputs. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select \emph{incorrect} statement. Complexity analysis of an attack consideres | On 24 April 2019 a paper by Gaëtan Leurent and Thomas Peyrin presented at Eurocrypt 2019 described an enhancement to the previously best chosen-prefix attack in Merkle–Damgård–like digest functions based on Davies–Meyer block ciphers. With these improvements, this method is capable of finding chosen-prefix collisions in approximately 268 SHA-1 evaluations. This is approximately 1 billion times faster (and now usable for many targeted attacks, thanks to the possibility of choosing a prefix, for example malicious code or faked identities in signed certificates) than the previous attack's 277.1 evaluations (but without chosen prefix, which was impractical for most targeted attacks because the found collisions were almost random) and is fast enough to be practical for resourceful attackers, requiring approximately $100,000 of cloud processing. This method is also capable of finding chosen-prefix collisions in the MD5 function, but at a complexity of 246.3 does not surpass the prior best available method at a theoretical level (239), though potentially at a practical level (≤249). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which one of these is \emph{not} a stream cipher? | The keystream is now pseudorandom and so is not truly random. The proof of security associated with the one-time pad no longer holds. It is quite possible for a stream cipher to be completely insecure. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which one of these is \emph{not} a stream cipher? | A stream cipher is a symmetric key cipher where plaintext digits are combined with a pseudorandom cipher digit stream (keystream). In a stream cipher, each plaintext digit is encrypted one at a time with the corresponding digit of the keystream, to give a digit of the ciphertext stream. Since encryption of each digit is dependent on the current state of the cipher, it is also known as state cipher. In practice, a digit is typically a bit and the combining operation is an exclusive-or (XOR). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{correct} assertion regarding GSM. | WS-ReliableMessaging WS-Reliability WS-RM Policy Assertion | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{correct} assertion regarding GSM. | doi:10.1090/gsm/077. ISBN 978-0-8218-4231-7. Morgan, John W.; Fong, Frederick Tsz-Ho (2010). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{wrong} assertion concerning 3G. | EST, but the message's codeword, "HATEFULNESS" again, was incorrect. A cancellation message with the correct codeword, "IMPISH", was not sent until 10:13 a.m. EST. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{wrong} assertion concerning 3G. | 3GPP TS 23.060 V13.4.0 (2015-09) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | Suppose we are given a Boolean expressions: B 1 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) {\displaystyle B_{1}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})} B 2 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) ∧ ( ¬ v 1 ∨ v 2 ) . {\displaystyle B_{2}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})\wedge (\neg v_{1}\lor v_{2}).} With B 1 {\displaystyle B_{1}} , the algorithm can select v 1 = true {\displaystyle v_{1}={\text{true}}} , so to satisfy the second clause, the algorithm will need to set v 3 = false {\displaystyle v_{3}={\text{false}}} , and resultantly to satisfy the first clause, the algorithm will set v 2 = false {\displaystyle v_{2}={\text{false}}} . If the algorithm tries to satisfy B 2 {\displaystyle B_{2}} in the same way it tried to solve B 1 {\displaystyle B_{1}} , then the third clause will remain unsatisfied. This will cause the algorithm to backtrack and set v 1 = false {\displaystyle v_{1}={\text{false}}} and continue assigning variables further. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | . In particular, if v i = ∑ j = 1 d i v i j e i j {\displaystyle {\textbf {v}}_{i}=\sum _{j=1}^{d_{i}}v_{ij}{\textbf {e}}_{ij}\!} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Why do block ciphers use modes of operation? | In cryptography, a block cipher mode of operation is an algorithm that uses a block cipher to provide information security such as confidentiality or authenticity. A block cipher by itself is only suitable for the secure cryptographic transformation (encryption or decryption) of one fixed-length group of bits called a block. A mode of operation describes how to repeatedly apply a cipher's single-block operation to securely transform amounts of data larger than a block.Most modes require a unique binary sequence, often called an initialization vector (IV), for each encryption operation. The IV has to be non-repeating and, for some modes, random as well. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Why do block ciphers use modes of operation? | They are generally used in modes of operation similar to the block modes described here. As with all protocols, to be cryptographically secure, care must be taken to design these modes of operation correctly. There are several schemes which use a block cipher to build a cryptographic hash function. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
If we pick independent random numbers in $\{1, 2, \dots, N\}$ with uniform distribution, $\theta \sqrt{N}$ times, we get at least one number twice with probability\dots | Generalizing this idea for the other phases we have for each 1 ≤ i ≤ n if f ~ i − 1 ( r 1 , … , r i − 1 ) ≠ f i − 1 ( r 1 , … , r i − 1 ) , {\displaystyle {\tilde {f}}_{i-1}(r_{1},\dots ,r_{i-1})\neq f_{i-1}(r_{1},\dots ,r_{i-1}),} then for ri chosen randomly from F, Pr ≤ 1 n 2 . {\displaystyle \Pr \left\leq {\tfrac {1}{n^{2}}}.} There are n phases, so the probability that P ~ {\displaystyle {\tilde {P}}} is lucky because V selects at some stage a convenient ri is at most 1/n. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
If we pick independent random numbers in $\{1, 2, \dots, N\}$ with uniform distribution, $\theta \sqrt{N}$ times, we get at least one number twice with probability\dots | More precisely, consider equidistribution in n-dimensional ball. Choose N independent random vectors from a ball (they are independent and identically distributed). Let θ be a small positive number. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In practice, what is the typical size of an RSA modulus? | In the U.S., the recommended RSA may extend to 500 feet (150 m) in width, and 1,000 feet (300 m) beyond each runway end (according to U.S. Federal Aviation Administration recommendations; 1000 feet is equivalent to the international ICAO-RESA of 240m plus 60m strip). The standard dimensions have increased over time to accommodate larger and faster aircraft, and to improve safety. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In practice, what is the typical size of an RSA modulus? | As of 2020, the largest publicly known factored RSA number had 829 bits (250 decimal digits, RSA-250). Its factorization, by a state-of-the-art distributed implementation, took about 2,700 CPU-years. In practice, RSA keys are typically 1024 to 4096 bits long. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The one-time pad is\dots | The poem code was ultimately replaced with the one-time pad, specifically the letter one-time pad (LOP). In LOP, the agent was provided with a string of letters and a substitution square. The plaintext was written under the string on the pad. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The one-time pad is\dots | The one-time pad is, in most cases, impractical as it requires that the key material be as long as the plaintext, actually random, used once and only once, and kept entirely secret from all except the sender and intended receiver. When these conditions are violated, even marginally, the one-time pad is no longer unbreakable. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | Suppose we are given a Boolean expressions: B 1 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) {\displaystyle B_{1}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})} B 2 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) ∧ ( ¬ v 1 ∨ v 2 ) . {\displaystyle B_{2}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})\wedge (\neg v_{1}\lor v_{2}).} With B 1 {\displaystyle B_{1}} , the algorithm can select v 1 = true {\displaystyle v_{1}={\text{true}}} , so to satisfy the second clause, the algorithm will need to set v 3 = false {\displaystyle v_{3}={\text{false}}} , and resultantly to satisfy the first clause, the algorithm will set v 2 = false {\displaystyle v_{2}={\text{false}}} . If the algorithm tries to satisfy B 2 {\displaystyle B_{2}} in the same way it tried to solve B 1 {\displaystyle B_{1}} , then the third clause will remain unsatisfied. This will cause the algorithm to backtrack and set v 1 = false {\displaystyle v_{1}={\text{false}}} and continue assigning variables further. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | . In particular, if v i = ∑ j = 1 d i v i j e i j {\displaystyle {\textbf {v}}_{i}=\sum _{j=1}^{d_{i}}v_{ij}{\textbf {e}}_{ij}\!} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Diffie-Hellman refers to \ldots | Diffie–Hellman (RFC 3526) ECDH (RFC 4753) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Diffie-Hellman refers to \ldots | Elliptic-curve Diffie–Hellman (ECDH) is a key agreement protocol that allows two parties, each having an elliptic-curve public–private key pair, to establish a shared secret over an insecure channel. This shared secret may be directly used as a key, or to derive another key. The key, or the derived key, can then be used to encrypt subsequent communications using a symmetric-key cipher. It is a variant of the Diffie–Hellman protocol using elliptic-curve cryptography. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the Rabin cryptosystem using a modulus $N=pq$ where $p$ and $q$ are both $\ell$-bit primes. What is the tightest complexity of the encryption algorithm? | This problem is believed to be computationally difficult. Several cryptographic methods rely on its hardness, see § Applications. An efficient algorithm for the quadratic residuosity problem immediately implies efficient algorithms for other number theoretic problems, such as deciding whether a composite N {\displaystyle N} of unknown factorization is the product of 2 or 3 primes. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the Rabin cryptosystem using a modulus $N=pq$ where $p$ and $q$ are both $\ell$-bit primes. What is the tightest complexity of the encryption algorithm? | Regev proposed a public-key cryptosystem based on the hardness of the LWE problem. The cryptosystem as well as the proof of security and correctness are completely classical. The system is characterized by m , q {\displaystyle m,q} and a probability distribution χ {\displaystyle \chi } on T {\displaystyle \mathbb {T} } . The setting of the parameters used in proofs of correctness and security is q ≥ 2 {\displaystyle q\geq 2} , usually a prime number between n 2 {\displaystyle n^{2}} and 2 n 2 {\displaystyle 2n^{2}} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. | Select y ~ ∈ { 1 , . . . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. | . . VERIFY-SELECTION . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which mode of operation is similar to a stream cipher? | Stream ciphers represent a different approach to symmetric encryption from block ciphers. Block ciphers operate on large blocks of digits with a fixed, unvarying transformation. This distinction is not always clear-cut: in some modes of operation, a block cipher primitive is used in such a way that it acts effectively as a stream cipher. Stream ciphers typically execute at a higher speed than block ciphers and have lower hardware complexity. However, stream ciphers can be susceptible to security breaches (see stream cipher attacks); for example, when the same starting state (seed) is used twice. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which mode of operation is similar to a stream cipher? | A stream cipher is a symmetric key cipher where plaintext digits are combined with a pseudorandom cipher digit stream (keystream). In a stream cipher, each plaintext digit is encrypted one at a time with the corresponding digit of the keystream, to give a digit of the ciphertext stream. Since encryption of each digit is dependent on the current state of the cipher, it is also known as state cipher. In practice, a digit is typically a bit and the combining operation is an exclusive-or (XOR). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. | Select y ~ ∈ { 1 , . . . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. | . . VERIFY-SELECTION . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In Bluetooth, the link key $K_{link}$ is ... | Users can delete link keys from either device, which removes the bond between the devices—so it is possible for one device to have a stored link key for a device it is no longer paired with. Bluetooth services generally require either encryption or authentication and as such require pairing before they let a remote device connect. Some services, such as the Object Push Profile, elect not to explicitly require authentication or encryption so that pairing does not interfere with the user experience associated with the service use-cases. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In Bluetooth, the link key $K_{link}$ is ... | Bluetooth implements confidentiality, authentication and key derivation with custom algorithms based on the SAFER+ block cipher. Bluetooth key generation is generally based on a Bluetooth PIN, which must be entered into both devices. This procedure might be modified if one of the devices has a fixed PIN (e.g., for headsets or similar devices with a restricted user interface). During pairing, an initialization key or master key is generated, using the E22 algorithm. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $n=pq$ where $p$ and $q$ are prime numbers. We have: | Let p and q be two adjacent prime numbers. Given any n ∈ N {\displaystyle n\in \mathbb {N} } , where p ≤ n < q {\displaystyle p\leq n | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $n=pq$ where $p$ and $q$ are prime numbers. We have: | Let p be a prime number. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following elements belongs to $\mathbb{Z}_{78}^*$? | The elements of Z {\displaystyle \mathbb {Z} } ×15 are the congruence classes {1, 2, 4, 7, 8, 11, 13, 14}; there are φ(15) = 8 of them. x x, x2, x3, ... (mod 15) 1: 1 2: 2, 4, 8, 1 4: 4, 1 7: 7, 4, 13, 1 8: 8, 4, 2, 1 11: 11, 1 13: 13, 4, 7, 1 14: 14, 1 Since there is no number whose order is 8, there are no primitive roots modulo 15. Indeed, λ(15) = 4, where λ is the Carmichael function. (sequence A002322 in the OEIS) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following elements belongs to $\mathbb{Z}_{78}^*$? | For integer values of l {\displaystyle l} , the D-matrix elements with second index equal to zero are proportional to spherical harmonics and associated Legendre polynomials, normalized to unity and with Condon and Shortley phase convention: D m 0 ℓ ( α , β , γ ) = 4 π 2 ℓ + 1 Y ℓ m ∗ ( β , α ) = ( ℓ − m ) ! ( ℓ + m ) ! P ℓ m ( cos β ) e − i m α . {\displaystyle D_{m0}^{\ell }(\alpha ,\beta ,\gamma )={\sqrt {\frac {4\pi }{2\ell +1}}}Y_{\ell }^{m*}(\beta ,\alpha )={\sqrt {\frac {(\ell -m)! | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. Moore's Law ... | Recent Intel processors include a constant rate TSC (identified by the kern.timecounter.invariant_tsc sysctl on FreeBSD or by the "constant_tsc" flag in Linux's /proc/cpuinfo). With these processors, the TSC ticks at the processor's nominal frequency, regardless of the actual CPU clock frequency due to turbo or power saving states. Hence TSC ticks are counting the passage of time, not the number of CPU clock cycles elapsed. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. Moore's Law ... | is (still) false but one more performance of a {\displaystyle a\,\!} could bring about p {\displaystyle p\,\!} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The elements of $\mathbf{Z}_{14}^*$ are | The elements of Z {\displaystyle \mathbb {Z} } ×15 are the congruence classes {1, 2, 4, 7, 8, 11, 13, 14}; there are φ(15) = 8 of them. x x, x2, x3, ... (mod 15) 1: 1 2: 2, 4, 8, 1 4: 4, 1 7: 7, 4, 13, 1 8: 8, 4, 2, 1 11: 11, 1 13: 13, 4, 7, 1 14: 14, 1 Since there is no number whose order is 8, there are no primitive roots modulo 15. Indeed, λ(15) = 4, where λ is the Carmichael function. (sequence A002322 in the OEIS) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The elements of $\mathbf{Z}_{14}^*$ are | For example, if n = 14 then the elements of Z {\displaystyle \mathbb {Z} } ×n are the congruence classes {1, 3, 5, 9, 11, 13}; there are φ(14) = 6 of them. Here is a table of their powers modulo 14: x x, x2, x3, ... (mod 14) 1: 1 3: 3, 9, 13, 11, 5, 1 5: 5, 11, 13, 9, 3, 1 9: 9, 11, 1 11: 11, 9, 1 13: 13, 1 The order of 1 is 1, the orders of 3 and 5 are 6, the orders of 9 and 11 are 3, and the order of 13 is 2. Thus, 3 and 5 are the primitive roots modulo 14. For a second example let n = 15 . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | Suppose we are given a Boolean expressions: B 1 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) {\displaystyle B_{1}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})} B 2 = ( v 3 ∨ ¬ v 2 ) ∧ ( ¬ v 1 ∨ ¬ v 3 ) ∧ ( ¬ v 1 ∨ v 2 ) . {\displaystyle B_{2}=(v_{3}\lor \neg v_{2})\wedge (\neg v_{1}\lor \neg v_{3})\wedge (\neg v_{1}\lor v_{2}).} With B 1 {\displaystyle B_{1}} , the algorithm can select v 1 = true {\displaystyle v_{1}={\text{true}}} , so to satisfy the second clause, the algorithm will need to set v 3 = false {\displaystyle v_{3}={\text{false}}} , and resultantly to satisfy the first clause, the algorithm will set v 2 = false {\displaystyle v_{2}={\text{false}}} . If the algorithm tries to satisfy B 2 {\displaystyle B_{2}} in the same way it tried to solve B 1 {\displaystyle B_{1}} , then the third clause will remain unsatisfied. This will cause the algorithm to backtrack and set v 1 = false {\displaystyle v_{1}={\text{false}}} and continue assigning variables further. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textbf{false} statement. | . In particular, if v i = ∑ j = 1 d i v i j e i j {\displaystyle {\textbf {v}}_{i}=\sum _{j=1}^{d_{i}}v_{ij}{\textbf {e}}_{ij}\!} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the advantage of using a salt in a password authentication protocol? | However, they remain relevant in multi-server installations which use centralized password management systems to push passwords or password hashes to multiple systems. In such installations, the root account on each individual system may be treated as less trusted than the administrators of the centralized password system, so it remains worthwhile to ensure that the security of the password hashing algorithm, including the generation of unique salt values, is adequate.Another (lesser) benefit of a salt is as follows: two users might choose the same string as their password. Without a salt, this password would be stored as the same hash string in the password file. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the advantage of using a salt in a password authentication protocol? | Using the same salt for all passwords is dangerous because a precomputed table which simply accounts for the salt will render the salt useless. Generation of precomputed tables for databases with unique salts for every password is not viable because of the computational cost of doing so. But, if a common salt is used for all the entries, creating such a table (that accounts for the salt) then becomes a viable and possibly successful attack.Because salt re-use can cause users with the same password to have the same hash, cracking a single hash can result in other passwords being compromised too. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select \emph{incorrect} statement. The birthday paradox | Birthday paradox Birthday problem Index of coincidence Bible code Spurious relationship Monty Hall problem | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select \emph{incorrect} statement. The birthday paradox | Select y ~ ∈ { 1 , . . . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which scheme is the most secure? | The most secure scheme is the global centralized authentication and web application (portal). It is ideal for E-Government use because it allows a wide range of services. It uses a single authentication mechanism involving a minimum of two factors to allow access to required services and the ability to sign documents. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which scheme is the most secure? | Assuming that a deterministic encryption scheme is going to be used, it is important to understand what is the maximum level of security that can be guaranteed. A number of works have focused on this exact problem. The first work to rigorously define security for a deterministic scheme was in CRYPTO 2007. This work provided fairly strong security definitions (although weaker than semantic security), and gave constructions in the random oracle model. Two follow-up works appeared the next year in CRYPTO 2008, giving definitional equivalences and constructions without random oracles. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{false} assertion concerning WPA-TKIP. | WEP WPA (TKIP in hardware) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{false} assertion concerning WPA-TKIP. | Second, WPA implements a sequence counter to protect against replay attacks. Packets received out of order will be rejected by the access point. Finally, TKIP implements a 64-bit Message Integrity Check (MIC) and re-initializes the sequence number each time when a new key (Temporal Key) is used.To be able to run on legacy WEP hardware with minor upgrades, TKIP uses RC4 as its cipher. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{correct} assertion. In ElGamal $\ldots$ | A sequent A 1 , … , A m ⊢ B 1 , … , B n {\displaystyle A_{1},\,\dots ,A_{m}\,\vdash \,B_{1},\,\dots ,B_{n}} asserts that, if all the antecedents A 1 , … , A m {\displaystyle A_{1},\,\dots ,A_{m}} are true, then at least one of the consequents B 1 , … , B n {\displaystyle B_{1},\,\dots ,B_{n}} must be true. In the typed lambda calculus, the turnstile is used to separate typing assumptions from the typing judgment. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{correct} assertion. In ElGamal $\ldots$ | asserts that if p {\displaystyle p\,\!} is valid then so is q {\displaystyle q\,\!} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
One-time pad ... | The one-time-pad is the optimum cryptosystem with theoretically perfect secrecy. The one-time-pad is one of the most practical methods of encryption where one or both parties must do all work by hand, without the aid of a computer. This made it important in the pre-computer era, and it could conceivably still be useful in situations where possession of a computer is illegal or incriminating or where trustworthy computers are not available. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
One-time pad ... | One-time pads One-time pads are a popular cryptographic method to invoke in advertising, because it is well known that one-time pads, when implemented correctly, are genuinely unbreakable. The problem comes in implementing one-time pads, which is rarely done correctly. Cryptographic systems that claim to be based on one-time pads are considered suspect, particularly if they do not describe how the one-time pad is implemented, or they describe a flawed implementation. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The Merkle-D{\aa}mgard construction is | The last block processed should also be unambiguously length padded; this is crucial to the security of this construction. This construction is called the Merkle–Damgård construction. Most common classical hash functions, including SHA-1 and MD5, take this form. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The Merkle-D{\aa}mgard construction is | We will later use the Merkle–Damgård construction to extend the domain to inputs of arbitrary lengths. The basis of this function consists of a (randomly chosen) binary r × n {\displaystyle r\times n} matrix H {\displaystyle H} which acts on a message of n {\displaystyle n} bits by matrix multiplication. Here we encode the w log ( n / w ) {\displaystyle w\log(n/w)} -bit message as a vector in ( F 2 ) n {\displaystyle (\mathbf {F} _{2})^{n}} , the n {\displaystyle n} -dimensional vector space over the field of two elements, so the output will be a message of r {\displaystyle r} bits. For security purposes as well as to get a faster hash speed we want to use only “regular words of weight w {\displaystyle w} ” as input for our matrix. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The Fermat Test outputs `maybe prime' with probability which may be high given though $n$ is composite when ... | The simplest probabilistic primality test is the Fermat primality test (actually a compositeness test). It works as follows: Given an integer n, choose some integer a coprime to n and calculate an − 1 modulo n. If the result is different from 1, then n is composite. If it is 1, then n may be prime.If an−1 (modulo n) is 1 but n is not prime, then n is called a pseudoprime to base a. In practice, we observe that, if an−1 (modulo n) is 1, then n is usually prime. But here is a counterexample: if n = 341 and a = 2, then 2 340 ≡ 1 ( mod 341 ) {\displaystyle 2^{340}\equiv 1{\pmod {341}}} even though 341 = 11·31 is composite. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
The Fermat Test outputs `maybe prime' with probability which may be high given though $n$ is composite when ... | The error made by the primality test is measured by the probability that a composite number is declared probably prime. The more bases a are tried, the better the accuracy of the test. It can be shown that if n is composite, then at most 1/4 of the bases a are strong liars for n. As a consequence, if n is composite then running k iterations of the Miller–Rabin test will declare n probably prime with a probability at most 4−k. This is an improvement over the Solovay–Strassen test, whose worst‐case error bound is 2−k. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What should the minimal length of the output of a hash function be to provide security against \emph{collision attacks} of $2^{256}?$ | A straightforward application of the Merkle–Damgård construction, where the size of hash output is equal to the internal state size (between each compression step), results in a narrow-pipe hash design. This design causes many inherent flaws, including length-extension, multicollisions, long message attacks, generate-and-paste attacks, and also cannot be parallelized. As a result, modern hash functions are built on wide-pipe constructions that have a larger internal state size – which range from tweaks of the Merkle–Damgård construction to new constructions such as the sponge construction and HAIFA construction. None of the entrants in the NIST hash function competition use a classical Merkle–Damgård construction.Meanwhile, truncating the output of a longer hash, such as used in SHA-512/256, also defeats many of these attacks. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What should the minimal length of the output of a hash function be to provide security against \emph{collision attacks} of $2^{256}?$ | The aforementioned process achieves a t-bit security level with 4t-bit signatures. For example, a 128-bit security level would require 512-bit (64-byte) signatures. The security is limited by discrete logarithm attacks on the group, which have a complexity of the square-root of the group size. In Schnorr's original 1991 paper, it was suggested that since collision resistance in the hash is not required, then therefore shorter hash functions may be just as secure, and indeed recent developments suggest that a t-bit security level can be achieved with 3t-bit signatures. Then, a 128-bit security level would require only 384-bit (48-byte) signatures, and this could be achieved by truncating the size of e until it is half the length of the s bitfield. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $G$ be a group generated by $g$. What is the discrete logarithm problem? | Given a group G {\displaystyle G} with order p {\displaystyle p} and generator g ∈ G {\displaystyle g\in G} , suppose we know that x = g r ∈ G {\displaystyle x=g^{r}\in G} , for some r ∈ Z p {\displaystyle r\in \mathbb {Z} _{p}} , and we wish to compute r {\displaystyle r} , which is the discrete logarithm: r = log g ( x ) {\displaystyle r={\log _{g}}(x)} . Consider the abelian group Z p × Z p {\displaystyle \mathbb {Z} _{p}\times \mathbb {Z} _{p}} , where each factor corresponds to modular addition of values. Now, consider the function f: Z p × Z p → G ; f ( a , b ) = g a x − b . {\displaystyle f\colon \mathbb {Z} _{p}\times \mathbb {Z} _{p}\to G\;;\;f(a,b)=g^{a}x^{-b}.} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $G$ be a group generated by $g$. What is the discrete logarithm problem? | In the special case where b is the identity element 1 of the group G, the discrete logarithm logb a is undefined for a other than 1, and every integer k is a discrete logarithm for a = 1. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Bluetooth is \dots | updated Bluetooth stack that opens up even more tethered connectivity options | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Bluetooth is \dots | Bluetooth is a standard wire-replacement communications protocol primarily designed for low power consumption, with a short range based on low-cost transceiver microchips in each device. Because the devices use a radio (broadcast) communications system, they do not have to be in visual line of sight of each other; however, a quasi optical wireless path must be viable. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{false} answer. In a group, the operation\dots | {\displaystyle (g!)} , players within each group ( s ! ) {\displaystyle (s!)} | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \emph{false} answer. In a group, the operation\dots | Note that one can also overcome the problem with containing dots using the \yahnodots command. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider a public-key cryptosystem. Let $K_p$, $K_s$, $X$, and $Y$ be respectively the public key, private key, plaintext and ciphertext. Which assertion is \emph{always true}? | Regev proposed a public-key cryptosystem based on the hardness of the LWE problem. The cryptosystem as well as the proof of security and correctness are completely classical. The system is characterized by m , q {\displaystyle m,q} and a probability distribution χ {\displaystyle \chi } on T {\displaystyle \mathbb {T} } . The setting of the parameters used in proofs of correctness and security is q ≥ 2 {\displaystyle q\geq 2} , usually a prime number between n 2 {\displaystyle n^{2}} and 2 n 2 {\displaystyle 2n^{2}} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider a public-key cryptosystem. Let $K_p$, $K_s$, $X$, and $Y$ be respectively the public key, private key, plaintext and ciphertext. Which assertion is \emph{always true}? | Limited research on plaintext-aware encryption has been done since Bellare and Rogaway's paper. Although several papers have applied the plaintext-aware technique in proving encryption schemes are chosen-ciphertext secure, only three papers revisit the concept of plaintext-aware encryption itself, both focussed on the definition given by Bellare and Rogaway that inherently require random oracles. Plaintext-aware encryption is known to exist when a public-key infrastructure is assumed. Also, it has been shown that weaker forms of plaintext-awareness exist under the knowledge of exponent assumption, a non-standard assumption about Diffie-Hellman triples. Finally a variant of the Cramer Shoup encryption scheme was shown to be fully plaintext aware in the standard model under the knowledge of exponent assumption. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. Euler Theorem | This second solution is presumably more accurate. Since we have to apply Euler's method twice, the local error is (in the worst case) twice the original error. y n + 1 2 = y n + h 2 f ( t n , y n ) {\displaystyle y_{n+{\frac {1}{2}}}=y_{n}+{\frac {h}{2}}f(t_{n},y_{n})} y n + 1 ( 1 ) = y n + 1 2 + h 2 f ( t n + 1 2 , y n + 1 2 ) {\displaystyle y_{n+1}^{(1)}=y_{n+{\frac {1}{2}}}+{\frac {h}{2}}f(t_{n+{\frac {1}{2}}},y_{n+{\frac {1}{2}}})} τ n + 1 ( 1 ) = c ( h 2 ) 2 + c ( h 2 ) 2 = 2 c ( h 2 ) 2 = 1 2 c h 2 = 1 2 τ n + 1 ( 0 ) {\displaystyle \tau _{n+1}^{(1)}=c\left({\frac {h}{2}}\right)^{2}+c\left({\frac {h}{2}}\right)^{2}=2c\left({\frac {h}{2}}\right)^{2}={\frac {1}{2}}ch^{2}={\frac {1}{2}}\tau _{n+1}^{(0)}} y n + 1 ( 1 ) + τ n + 1 ( 1 ) = y ( t + h ) {\displaystyle y_{n+1}^{(1)}+\tau _{n+1}^{(1)}=y(t+h)} Here, we assume error factor c {\displaystyle c} is constant over the interval {\displaystyle } . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select the \emph{incorrect} statement. Euler Theorem | Select y ~ ∈ { 1 , . . . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textit{correct} assertion. | (/ indicates line break; some word breaks are uncertain) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Tick the \textit{correct} assertion. | If so, attempt to position cursor at that line. If it exists, begin interpretation there; if not, report an error. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $p$ be a prime number and $n$ be an integer. What is the order of $\mathrm{GF}(p^n)$? | Given a prime power q = pn with p prime and n > 1, the field GF(q) may be explicitly constructed in the following way. One first chooses an irreducible polynomial P in GF(p) of degree n (such an irreducible polynomial always exists). Then the quotient ring of the polynomial ring GF(p) by the ideal generated by P is a field of order q. More explicitly, the elements of GF(q) are the polynomials over GF(p) whose degree is strictly less than n. The addition and the subtraction are those of polynomials over GF(p). The product of two elements is the remainder of the Euclidean division by P of the product in GF(p). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Let $p$ be a prime number and $n$ be an integer. What is the order of $\mathrm{GF}(p^n)$? | The finite field with pn elements is denoted GF(pn) and is also called the Galois field of order pn, in honor of the founder of finite field theory, Évariste Galois. GF(p), where p is a prime number, is simply the ring of integers modulo p. That is, one can perform operations (addition, subtraction, multiplication) using the usual operation on integers, followed by reduction modulo p. For instance, in GF(5), 4 + 3 = 7 is reduced to 2 modulo 5. Division is multiplication by the inverse modulo p, which may be computed using the extended Euclidean algorithm. A particular case is GF(2), where addition is exclusive OR (XOR) and multiplication is AND. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Under which condition is an element $x\in \mathbb{Z}_n$ invertible? | Indeed, we assume that every nonzero element of the ring Z / n Z {\displaystyle \mathbb {Z} /n\mathbb {Z} } is invertible, so that Z / n Z {\displaystyle \mathbb {Z} /n\mathbb {Z} } must be a field. It implies that n {\displaystyle n} must be prime (cf. Bézout's identity). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Under which condition is an element $x\in \mathbb{Z}_n$ invertible? | An element a is invertible if Q(a) is invertible and there exists b such that Q(b) is the inverse of Q(a) and Q(a)b = a: such b is unique and we say that b is the inverse of a. A Jordan division algebra is one in which every non-zero element is invertible. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.