instruction stringlengths 0 29.8k ⌀ |
|---|
|logic|concurrency|process-algebras| |
|logic|concurrency|process-algebras| |
|algorithms|landau-notation|education|runtime-analysis| |
[Parallelism](http://en.wikipedia.org/wiki/Parallel_computing) consists of running computations simultaneously on multiple processors, in order to reduce the total running time of a program.
Contrast with [tag:concurrency], which studies multiple programs running in the same time frame.
|
null |
Parallelism studies programs that execute simultaneously on multiple processors |
null |
Here are a few papers that talk about the cache implications of generational garbage collectors:
* [Caching Considerations for Generational Garbage Collection][1]
* [The Effect of Garbage Collection on Cache Performance][2]
From what I can gather, the primary issue is that garbage collected systems trade off spa... |
I'm trying to understand what is wrong with the following proof of the following recurrence
$$
T(n) = 2\,T\!\left(\left\lfloor\frac{n}{2}\right\rfloor\right)+n
$$
$$
T(n) \leq 2\left(c\left\lfloor\frac{n}{2}\right\rfloor\right)+n \leq cn+n = n(c+1) =O(n)
$$
The documentation says it's wrong because of the ... |
|landau-notation|recurrence-relation|asymptotics| |
null |
Let's say the final goal is to prove $T(n) = \mathcal{O}(n)$. You start with the induction hypothesis:
$T(i) \leq ci$ for all $i < n$.
And to complete the proof, you have to show that $T(n) \leq cn$ as well.
However, what you're able to deduce is $T(n) \leq (c+1)n$, which is not helpful to complete the proof.... |
Let's say the final goal is to prove $T(n) = \mathcal{O}(n)$. You start with the induction hypothesis:
$T(i) \leq ci$ for all $i < n$.
And to complete the proof, you have to show that $T(n) \leq cn$ as well.
However, what you're able to deduce is $T(n) \leq (c+1)n$, which is not helpful to complete the proof;... |
I'm extending the answer already given, perhaps only by explaining my comment in more detail.
As guessing can clearly be difficult and tedious, sometimes better methods exist. One such method is the [Master Theorem](http://en.wikipedia.org/wiki/Master_theorem). Our recurrence is now of the form $T(n) = a T(n/b) + f(... |
null |
Garbage collection was invented by John McCarthy around 1959 to solve problems in Lisp.
Garbage collection is often portrayed as the opposite of manual memory management, which requires the programmer to specify which objects to deallocate and return to the memory system. However, many systems use a combination of t... |
null |
A recurrence relation is an equation that recursively defines a sequence, once one or more initial terms are given: each further term of the sequence is defined as a function of the preceding terms.
In computer science, recurrence usually emerges when we analyze complexity of divide-and-conquer algorithms. Some well... |
null |
Reduction is a transformation of one problem to another. |
null |
The conversion between SQL access control policies and XML-specific access control models has been studied in:
"[Preserving SQL Access Control Policies Over Published XML Data][1]" by G. Leighton (2009)
According to the author:
*... To the best of our knowledge, our work represents the first attempt to formula... |
Stack inspection is a mechanism for ensuring security in the context of the JVM and CLR virtual machines, where externally downloaded code modules of different levels of trust may be running together. Code is associated with the principal corresponding to its origin. Access permissions are recorded on the stack. Whenev... |
Limitations of Stack Inspection |
|security|stack-inspection| |
Stack inspection is a mechanism for ensuring security in the context of the JVM and CLR virtual machines when externally downloaded code modules of different levels of trust may be running together. Code is associated with the principal corresponding to its origin and access permissions are recorded on the stack. Whene... |
Cryptanalysis is the study of cryptographic algorithms (ciphers, hashes, etc.) aiming to find weaknesses (i.e. "break" them). |
null |
In general, the field of formal languages studies mathematical and logical properties of and relationships between languages (or sets) of strings (or sequences of symbols) over alphabets (or sets of symbols). Commonly encountered varieties of formal languages are regular languages, context-free languages, context-sensi... |
null |
Formal languages are sets of strings, i.e. sequences over symbols from some alphabet. |
null |
A method of solving recurrences of a specific form up to asymptotic bounds. |
null |
Mathematical function that maps arbitrarily-sized data to fixed-size integers, often used as keys in hash tables or to help ensure data integrity |
null |
Popular examples include:
* Proving [tag:undecidability] of $P$ by reducing the halting (or any undecidable) problem $\mathrm{HP}$ to $P$. This entails finding a computable function $f$ with $\mathrm{HP}(I) = \mathrm{true} \Longleftrightarrow P(f(I)) = \mathrm{true}$ to use in a proof by contradiction.
* Proving th... |
null |
Reduction is the process of solving one problem using a solution of another one. |
null |
Stack inspection is a mechanism for ensuring security in the context of the JVM and CLR virtual machines when externally downloaded code modules of different levels of trust may be running together. Code is associated with the principal corresponding to its origin and access permissions are recorded on the stack. Whene... |
[Stack inspection][1] is a mechanism for ensuring security in the context of the JVM and CLR virtual machines when externally downloaded code modules of different levels of trust may be running together. Code is associated with the principal corresponding to its origin and access permissions are recorded on the stack. ... |
[Stack inspection][1] is a mechanism for ensuring security in the context of the JVM and CLR virtual machines when externally downloaded code modules of different levels of trust may be running together. That system libraries need some way of distinguishing between calls originating in untrusted code and calls originat... |
_This is precursor to my other, more advanced [question][1] about Stack Inspection._
Stack Inspection is a security mechanism introduced in the JVM to deal with running code originating from locations having different levels of trust. This is question aims at finding a simple description of its functionality. So:
... |
How does Stack Inspection work? |
|security|stack-inspection| |
_This is a follow up to the http://cs.stackexchange.com/q/796/31 that explores the notion in more detail_
[Stack inspection][1] is a mechanism for ensuring security in the context of the JVM and CLR virtual machines when externally downloaded code modules of different levels of trust may be running together. That sy... |
See
"[Understanding Java Stack Inspection][1]" by D. S. Wallach and E. W. Felten (1998)
From the paper:
... The stack inspection algorithm used in current Java systems
can be thought of as a generalization of the following **simple
stack inspection** model:
In this model, the only principals are “system”... |
See
"[Understanding Java Stack Inspection][1]" by D. S. Wallach and E. W. Felten (1998)
From the paper:
... The stack inspection algorithm used in current Java systems
can be thought of as a generalization of the following **simple
stack inspection** model:
In this model, the only principals are “system”... |
See
- "[Understanding Java Stack Inspection][1]" by D. S. Wallach and E. W. Felten (1998)
From the paper:
... The stack inspection algorithm used in current Java systems
can be thought of as a generalization of the following **simple
stack inspection** model:
In this model, the only principals are “syste... |
null |
Stack inspection is necessary because programs on the JVM and CLR have default access to dangerous operations, so something must be done to prevent disasters. For example an untrusted program can reference an I/O library and call it:
using IO;
...
IO.DeleteFile("/home/foo/bla");
So on each dangerous... |
Stack inspection is necessary because programs on the JVM and CLR have default access to dangerous operations, so something must be done to prevent disasters. For example an untrusted program can reference an I/O library and call it:
using IO;
...
IO.DeleteFile("/home/foo/bla");
So on each dangerous... |
There have been attempts to analyse energy consumption of algorithms in theory (using real-life costs per operation, of course); see e.g. [1]. While the results are surprising enough---the fastest algorithm is not always the one using the least energy---some obstacles remain.
In particular, modern platforms switch o... |
3-Partition problem asks whether a set of $3n$ integers can be partitioned into $n$ sets of three integers such that each set sums up to some given integer $B$. Balanced Partition problem asks whether $2n$ integers can be partitioned into two equal cardinality sets such that both sets have the same sum. Both of them ar... |
Reduction from 3-Partition problem to Balanced Partition problem |
null |
*Answering (at least) the part of your question regarding why research has diverged instead of converged.*
Being no expert on process algebras, I was once wondering the exact same thing: why are there so many theories? I was pointed to a survey by [Parrow: Expressiveness of Process Algebras, 2008](http://www.google.... |
The 3-Partition problem asks whether a set of $3n$ integers can be partitioned into $n$ sets of three integers such that each set sums up to some given integer $B$. The Balanced Partition problem asks whether $2n$ integers can be partitioned into two equal cardinality sets such that both sets have the same sum. Both pr... |
Automata, or state machines, are mathematical devices often used to define formal languages by way of accepting, or recognizing, or deciding strings belonging to the target language. Commonly encountered varieties of automata are finite automata, pushdown automata, linear-bounded automata, and Turing machines.
Relat... |
null |
Automata are mathematical devices that read an input stream symbol by symbol and use a state transition map to produce an output stream. They may use secondary storage. |
null |
null |
Machine learning provides computer algorithms that automatically discover patterns in data and make good decisions based on them. |
null |
Garbage collection was invented by John McCarthy around 1959 to solve problems in Lisp. Its purpose is to deallocate memory that was dynamically allocated but is no longer used. It is particularly useful in the context of object-oriented languages where huge object structure may become obsolete quickly. The memory part... |
null |
A recurrence relation is an equation that recursively defines a sequence, once one or more initial terms are given: each further term of the sequence is defined as a function of the preceding terms.
In computer science, recurrences usually emerge when we analyze runtime and complexity of recursive algorithms. Some w... |
null |
Garbage colletion is the process of deallocating dynamically allocated, now unused parts of memory. |
null |
Garbage collection is a form of memory management in which unused memory is automatically reclaimed |
null |
[Garbage collection](http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29) is any method to automatically reclaim blocks of memory that are not used by a program anymore. In an environment with full garbage collection, programs allocate memory and never explicitly free memory.
Beyond manual memory ... |
null |
One limitation of stack inspection as traditionally implemented is that it breaks proper tail calls. In particular, typical implementations need to keep the entire "stack" around at all times. Clements and Felleisen show how this problem can be remedied using a technique called "continuation marks" in their paper [*A ... |
|concurrency|process-algebras| |
|concurrency|shared-memory|imperative-programming| |
a definition of a sequence where later terms are expressed as a function of earlier terms |
null |
Let $G$ be a context-free grammar. A string of terminals and nonterminals of $G$ is said to be a *sentential form* of $G$ if you can obtain it by applying productions of $G$ zero or more times to the start symbol of $S$. Let $SF(G)$ be the set of sentential forms of $G$.
Let $\alpha \in SF(G)$ and let $\beta$ be a s... |
Are the Before and After sets for context-free grammars always context-free? |
|context-free| |
|formal-languages|context-free| |
|algorithms|landau-notation|asymptotics|recurrence-relation| |
Let $G$ be a context-free grammar. A string of terminals and nonterminals of $G$ is said to be a *sentential form* of $G$ if you can obtain it by applying productions of $G$ zero or more times to the start symbol of $S$. Let $\operatorname{SF}(G)$ be the set of sentential forms of $G$.
Let $\alpha \in \operatorname{... |
A [recurrence relation](http://en.wikipedia.org/wiki/Recurrence_relation) is a way to define a sequence in which later terms are computed from earlier terms. More generally, recurrence relations may be given not only for sequences (functions over the nonnegative integers), but on any domain with a [well-founded](http:/... |
null |
Let $G$ be a context-free grammar. A string of terminals and nonterminals of $G$ is said to be a *sentential form* of $G$ if you can obtain it by applying productions of $G$ zero or more times to the start symbol of $S$. Let $\operatorname{SF}(G)$ be the set of sentential forms of $G$.
Let $\alpha \in \operatorname{... |
null |
Yes, $\mbox{Before}(\beta)$ and $\mbox{After}(\beta)$ are context-free languages. Here's how I would prove it. First, a lemma (which is the crux). If $L$ is CF then:
$\mbox{Before}(L,\beta) = \{ \gamma \ |\ \exists \delta . \gamma \beta \delta \in L \}$
and
$\mbox{After}(L,\beta) = \{ \gamma \ |\ \exists... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.