Do relativized relations between complexity classes tell us anything about the nonrelativized relation?

The existence of relativized relations between complexity classes seems to often be treated as “circumstantial” evidence about the “true” or “real-world” (i.e. nonrelativized) relation between the classes. However, as far as I understand (please correct me if I am wrong), for complexity classes $$A$$ and $$B$$ and an oracle for a language $$L$$, all four of these cases are logically possible:

1. $$A = B$$ and $$A^L = B^L$$
2. $$A = B$$ and $$A^L \neq B^L$$
3. $$A \neq B$$ and $$A^L = B^L$$
4. $$A \neq B$$ and $$A^L \neq B^L$$

So presuming that at the end of the day the unrelativized result is what we really care about, what are relativized results “good for”?

I can see one application: if we happen to be able to find oracles for two languages $$L$$ and $$L’$$ such that $$A^L = B^L$$ and $$A^{L’} \neq B^{L’}$$, then that tells us that any proof that either $$A = B$$ or $$A \neq B$$ cannot relativize, and this fact saves us a lot of time by allowing us to immediately skip many potential proofs.

But do oracle results give us any evidence about the actual relation? In particular, why are oracle separations treated as “evidence” (though not a proof) that the complexity classes are unequal? How strong does the complexity-theory community consider such evidence to be? (I know that last question is subjective and hard to answer precisely.)

Solving recurrence relation with square root (need explanation)

Actually this question has been answered in this

But I am not able to understand in one place, and I could not comment over there. That’s why here I want to know the explanation.

$$T(n) = T(\sqrt n) + n$$ to solve this recurrence relation, $$n = 2^m$$ then it can rewritten as $$S(m) = S(m/2) + 2^m$$. This rewrite part I can’t understand.

How to get super attribute dependent relation on custom page

I need to get list of all super attribute on my custom phtml page.

Like I have 3 attributes Color, Size, Height.

So I need three drop-down on my custom page where after selecting color, dependent size value should be populate in size drop-down and after selecting size, dependent height attribute value should be populated in height drop-down.

I tried with $product->getTypeInstance(true)->getConfigurableAttributesAsArray($ product)

It gives attributes used for particular product but I am not able to make it dependent does any one has solution for this.

Does relation in DBMS corresponds to the programming-language notion of a variable?

Thanks for taking time to read my question. I am fairly new to DBMS and I am following below stated book for clearing my concepts. As far as, I know, the attributes in DBMS corresponds to instance variables in programming-languages (I guess, I have read it in Ullman). I am bit confuse by the analogy provided in the first statement in below paragraph in the book i.e. comparing relation (table) with variable. If I am not wrong then relation means table in DBMS.

Excerpt from Database System Concepts 6th Edition by Abraham Silberschatz, Henry F. Korth, and S.Sudarshan

The concept of a relation corresponds to the programming-language notion of a variable, while the concept of a relation schema corresponds to the programming-language notion of type definition.

Using UNIQUE (col1, col2) or using a composite primary key for a relation table in SQLite/SQL?

i’m working on a project where i’m using SQLite and where i have a few relation tables looking similar to this one:

CREATE TABLE tag_entry_relation ( id INTEGER PRIMARY KEY, tag_id INTEGER REFERENCES tag(id), entry_id INTEGER REFERENCES entry(id) ); 

I know that the two “referencing” columns will together be unique (so there will be no duplicates).

I’m considering whether to use the UNIQUE constraint or if it’s better to use a composite primary key

The reason i see for using a composite primary key is simply that it requires one column less than the other option

I don’t see a reason for using a UNIQUE constraint except that i’m more used to this than using a composite primary key, so i’m worried i might be missing something

What would you recommend? Grateful for help!

PS: As far as i can tell there’s no difference between SQL and SQLite in regards to this question

Converting a Recurrence Relation to its Closed Form

I have a recurrence relation of the form given below (taken from Analysis of Algorithms – An Active Learning Approach by Jeffrey J. McConnell):

$$T(n) = 2T(n – 2) – 15$$

$$T(2) = T(1) = 40$$

I am asked to find a closed-form for the recurrence relation i.e. to remove the recursive nature of the equations.

Working: My professor said it would be easier if you could see the patterns taking form if you expand the equations up to a few steps. So,

$$T(n) = 2T(n – 2) – 15$$

$$= 2(2T(n – 4) – 15) – 15$$

$$= 4T(n – 4) – 2\times 15 – 15$$

$$= 4(2T(n – 6) – 15) – 2\times15 – 15$$

$$= 8T(n – 6) – 4 \times 15 – 2\times15 – 15$$

I observe that the coefficient of $$T$$ in each step is a power of 2. The size of the problem during each recursive call decreases by 2. Also, there is a -15 term multiplied by the next power of 2.

But I am stuck here and do not know how to proceed further i.e. to obtain a closed-form. The book says to consider cases when $$n$$ is odd and even. But I do not get it at all. Any help would be appreciated.

Note: The material hasn’t covered advanced topics like solving recurrence relations yet.

How do we guess the recurrence relation from the given equation

In clrs , i have been reading about a method named substitution method to solve the recurrence, here the author guessed the solution is T(n) = O(n log n), but i am confused why not O(n^2)? is there any method to properly guess the solution? is there any thing i have missed in this method?

Characterization of the relation between algebraic numbers

Suppose we are given a polynomial $$P(x)$$ with integer coefficients and $$deg(P)\leq n$$, then we have its roots $$\lambda_i$$ for $$1\leq i\leq n$$.

We are interested in the following set $$S=\{(m_1,m_2,\cdots,m_n):\Pi_{i=1}^n \lambda_i^{m_i}=1\}\subset\mathbb{N}^n.$$ $$S$$ is closed under integer scaling, and vector addition. Is there an efficeint algorithm which provides a basis of $$S$$?

Prove that $T(n) \leq 8n^2$ or find value of $n$ when statement is not true (reccurence relation)

We have a function $$T: \mathbb{N}\to\mathbb{N}$$ defined recurrently:

$$T(n)=\begin{cases} 0 &\text{ if } n=0,\ 3T(\lfloor{n/2}\rfloor) + 2n^2 &\text{otherwise.} \end{cases}$$

Prove that for each $$n\in\mathbb{N}_0$$: $$T(n) \leq 8n^2$$

How can I prove such statement? I was thinking of using the Master Theorem to get asymptotically tight bounds of the recurrence but I think that is not a right approach. Any help appreciated

relation between lvm, vg, and pv?

As I’m an absolute noob at Linux, I don’t quite understand the deep relationship between lvm, vg and pv even though I know the structure. I wonder if I store some documents at /dev/vg/dirx, is it possible to access those files somewhere from /dev/lvm/dirx or /dev/pv/dirx?