paper stringlengths 9 16 | proof stringlengths 0 131k |
|---|---|
math/0101263 | We shall just prove the continuity of MATH, as the continuity of MATH is proven similarly. Define MATH to be the space of functions with norm MATH . Since MATH, we see from NAME embedding that the nonlinear map MATH continuously maps MATH to MATH. It therefore suffices to show the product estimate MATH . But this estimate follows immediately from the NAME rule and NAME when MATH or MATH, and the intermediate cases then follow by interpolation. |
math/0101263 | These conservation laws are proven in CITE, however we give a proof based on the identity REF, as the proof here will be needed later on. We of course have MATH . In the rest of this proof we shall drop the MATH from the MATH notation. Differentiating the previous and applying REF, we obtain MATH . The first term vanishes since MATH. The second term can be symmetrized to MATH which vanishes. The third term clearly vanishes. This proves the MATH conservation. Now we prove energy conservation. From REF we have MATH and from REF MATH . The MATH term vanishes since MATH. To simplify the MATH term we write MATH, MATH and then symmetrize. To simplify the MATH term we write MATH, MATH and then symmetrize, to obtain MATH . We may simplify the MATH term further, using the identity MATH to obtain MATH . We now consider the second component of the energy. From REF we have MATH . The MATH term symmetrizes to MATH which vanishes. The MATH term can be rewritten as MATH which we rewrite as MATH . The first term symmetrizes to MATH which vanishes. The second term symmetrizes to MATH . Finally, consider the MATH term. We may factorize MATH . Since MATH and MATH, we may simplify this as MATH . Combining all these identities we thus have MATH . Combining this with REF we obtain MATH and the claim follows. |
math/0101263 | Define the function MATH . A routine computation shows that MATH and MATH . From the sharp NAME inequality CITE MATH we therefore have MATH . From the definition of MATH we have MATH and so we have MATH . By another application of REF we thus obtain REF. |
math/0101263 | From REF we have MATH . Henceforth we omit the MATH from the MATH notation. By REF we have MATH . The MATH term vanishes since MATH. To simplify the MATH term, we use MATH and MATH and then symmetrize to obtain the second term of MATH. To simplify the MATH term, we use MATH and MATH and then symmetrize to get the first term of MATH. In a similar vein we have MATH . The MATH term is of the form of the first term of MATH, by the argument used to prove REF. To simplify the MATH term, we use MATH and similarly for the other four terms, then symmetrize to obtain the second term of MATH. Finally if we symmetrize the MATH term we obtain MATH. The first part of the Proposition then follows from the Fundamental Theorem of Calculus applied to the function MATH. If all the frequencies are MATH, then all the MATH, MATH, etc. terms are equal to REF. In this case our calculations are identical to those in REF and so our symbols MATH, MATH, MATH will vanish by the computations given in that Lemma. |
math/0101263 | By NAME and duality it suffices to show MATH and MATH for all functions MATH, where MATH, MATH denotes integration over the measure MATH and MATH respectively. We may assume that the MATH are all real and non-negative. We now observe the pointwise estimate MATH for MATH and all MATH such that MATH. To see this, we use symmetry to assume that MATH, so that MATH. Since MATH is essentially increasing in MATH, we thus see that MATH . Since MATH for all MATH, the claim follows. Because of this estimate, we only need to show the estimates MATH and MATH . The estimate REF is equivalent to the first estimate of REF after undoing the duality and NAME, so it suffices to prove REF. By undoing the duality we can write this as MATH . We may assume that the NAME transforms MATH are all real and non-negative. By using MATH, it suffices to prove estimates of the form MATH plus similar estimates when MATH falls on one of the other functions. We shall only prove the displayed estimate, as the others are similar. We may estimate the MATH norm by the MATH norm. But then the claim follows from three applications of REF and two applications of REF, and NAME (ensuring that the term with the MATH is estimated using REF). |
math/0101263 | This is an improved NAME estimate of the type considered in CITE. It is enough to show that if MATH and MATH are solutions of the free NAME equation, that is MATH and MATH, then MATH where MATH is the operator such that MATH. If we use duality and the change of variable MATH and MATH, the left hand side of REF becomes MATH where MATH denotes the product of MATH and MATH in the new variables. Notice that the change of variables introduced above has a Jacobian of size MATH. Now if we use NAME and we change the variables back to MATH and MATH, we obtain REF . |
math/0101263 | Fix MATH. If MATH then MATH vanishes by the second part of REF , so we will assume that MATH. We split MATH, where MATH and MATH . In the MATH case we will not need to exploit cancellation between MATH and MATH (although such cancellation certainly exists), and shall estimate them separately. Let us first prove REF. We begin with estimating MATH. We have MATH as desired. It remains to estimate MATH. We divide into two cases: MATH and MATH. CASE: MATH. In this case all the frequencies are comparable to each other. By symmetry we may assume that MATH, in which case it suffices to show MATH . We can rewrite MATH, where MATH and MATH. A routine calculation shows that MATH for all MATH, so by the mean value theorem and the assumption MATH we have MATH as desired (in fact we gain an additional power of MATH). CASE: MATH. By symmetry we may assume that MATH, thus MATH. In this case MATH, MATH and MATH, so it suffices to show MATH . But we may crudely estimate the left-hand side by MATH which suffices since MATH. This proves REF. Now we show REF. Observe that MATH and hence MATH . Thus it only remains to estimate MATH. Since MATH and MATH are both MATH, it suffices to show MATH . By symmetry we may reduce to one of two cases. CASE: MATH and MATH. We crudely estimate MATH as desired. CASE: MATH and MATH. In this case we estimate MATH . The function MATH has a derivative of MATH whenever MATH, thus by the mean value theorem we thus have MATH as desired. |
math/0101263 | By applying NAME, restricting to a single frequency MATH, and then undoing NAME, we see that it suffices to show that MATH for all functions MATH. But this follows from the routine calculation MATH and the fact that MATH is closed under multiplication. |
math/0101263 | Since MATH, we have MATH. We may also assume that MATH since MATH vanishes otherwise. We have the very crude estimate MATH . If MATH, we then have MATH (using the hypothesis MATH), and REF follows. Now suppose that MATH. Then MATH (since MATH), and REF follows. |
math/0101263 | As usual we may assume that MATH. We crudely estimate MATH and the claim follows. |
quant-ph/0101028 | Since the accessibility relation is symmetric, the left to right implication is trivial. Let us prove MATH, which is equivalent to MATH. Suppose MATH. Since MATH is a proposition, by REF there holds for a certain MATH: MATH and MATH. Let MATH, and suppose, by contradiction, MATH. Since MATH, there follows MATH, against MATH. Consequently, MATH. |
quant-ph/0101028 | In order to prove the left to right implication, suppose by contradiction: MATH and MATH. Hence there exists a NAME realization MATH and a world MATH of MATH such that MATH and MATH. One can easily see that MATH can be transformed into MATH where MATH is the smallest subset of the power-set of MATH, that includes MATH and is closed under infinitary intersection. Owing to REF , MATH is a ``good" NAME realization for OL and for any MATH, MATH turns out to be the same proposition in MATH and in MATH. Consequently, also in MATH, there holds: MATH and MATH. Let us now consider MATH. The algebra MATH of MATH is complete, because MATH is closed under infinitary intersection. Hence, MATH is an element of MATH. Since MATH for any MATH, we will have MATH. Thus there is an element of MATH, which is less or equal than MATH for any MATH, but is not less or equal than MATH, because MATH. This contradicts the hypothesis MATH. The right to left implication is trivial. |
quant-ph/0101028 | CASE: We have to prove MATH for any propositions MATH of MATH. Suppose MATH. By definition of proposition in MATH: MATH . Consequently, MATH, and by REF : MATH, because MATH is orthomodular. Hence, MATH is a world in MATH. In order to prove MATH, it is sufficient to prove MATH. There holds trivially MATH. Further, MATH, because MATH is the generator of the quasi-ideal MATH. Consequently, MATH. CASE: Let MATH be orthomodular. Then for any MATH: MATH . One can trivially prove: MATH . Hence, by REF , the algebra MATH of MATH is orthomodular. |
quant-ph/0101028 | Since MATH represent the same connective in both semantics, it will be sufficient to refer to the algebraic semantics. As an example, let us prove the theorem for MATH (the other cases are similar). First we have to prove MATH iff MATH, which is equivalent to MATH iff MATH. From REF , we know that the latter condition holds for any pair of elements of MATH iff MATH is orthomodular. This proves at the same time that MATH is an implication-connective in OQL, but cannot be an implication-connective in OL. |
quant-ph/0101028 | Suppose MATH. Take MATH. There holds trivially: MATH. Let us prove the compatibility between MATH and MATH . Suppose, by contradiction, MATH and MATH incompatible. Then, for a certain MATH, MATH and MATH. Hence (by definition of MATH), MATH and by contraposition, MATH. Consequently, because MATH, one obtains by transitivity: MATH, against our hypothesis. |
quant-ph/0101028 | Straightforward. |
quant-ph/0101028 | It is sufficient to construct a canonical model MATH such that: MATH . As a consequence we will immediately obtain: MATH . Definition of the canonical model CASE: MATH is the set of all consistent and deductively closed sets of formulas; CASE: MATH is the compatibility relation between sets of formulas; CASE: MATH is the set of all propositions in the frame MATH; CASE: MATH. In order to recognize that MATH is a ``good" NAME, it is sufficient to prove that: CASE: MATH is reflexive and symmetric; CASE: MATH is a proposition in the frame MATH. The proof of REF is immediate (reflexivity depends on the consistency of any MATH, and symmetry can be shown using the weak double negation rule). In order to prove REF , it is sufficient to show (by REF ): MATH. Let MATH. Then (by definition of MATH): MATH; and, since MATH is deductively closed, MATH. Consequently, by the weak NAME theorem (and by the strong double negation rule), for a certain MATH: MATH and MATH. Hence, MATH. Lemma of the canonical model. For any MATH and any MATH, MATH. By induction on the length of MATH. The case MATH holds by definition of MATH. The case MATH can be proved by using REF and the weak NAME theorem. The case MATH can be proved using the MATH-introduction and the MATH-elimination rules. Finally we can show that MATH. Since the left to right implication is a consequence of the soundness-theorem, it is sufficient to prove: MATH. Let MATH; then, by Duns NAME, MATH is consistent. Take MATH. There holds: MATH and MATH. As a consequence, by the Lemma of the canonical model, MATH. At the same time MATH. For, should MATH be the case, we would obtain MATH and by definition of MATH, MATH, against our hypothesis. |
quant-ph/0101028 | Let MATH be any metrically incomplete pre-Hilbert space. Let MATH be its metric completion. Thus MATH is an infinite-dimensional subspace of the NAME space MATH. By REF and by REF , MATH is an elementary substructure of MATH. At the same time, by NAME 's Theorem, MATH cannot be orthomodular, because MATH is metrically incomplete. However, MATH is orthomodular. As a consequence, orthomodularity cannot be expressed as an elementary property. |
quant-ph/0101028 | There holds: MATH and MATH. Thus, MATH . |
quant-ph/0101028 | Straightforward. |
quant-ph/0101028 | REF implies REF : trivial. Suppose REF ; we want to show that REF holds. Now, MATH. Therefore, by REF , MATH. By NAME law: MATH. |
quant-ph/0101028 | Suppose REF . It is sufficient to prove that MATH: MATH. Now, MATH. Moreover, MATH. Therefore, by REF , MATH. Thus, MATH: MATH. |
quant-ph/0101028 | By routine techniques. |
quant-ph/0101028 | Following the usual procedure, it is sufficient to construct a canonical model MATH such that for any formulas MATH: MATH . Definition of the canonical model. CASE: The algebra MATH is determined as follows: CASE: MATH is the class of all equivalence classes of logically equivalent formulas: MATH. (In the following, we will write MATH instead of MATH). CASE: MATH is defined iff MATH. If defined, MATH. CASE: MATH; MATH. CASE: The valuation function MATH is defined as follows: MATH. One can easily check that MATH is a ``good" model for our logic. The operation MATH is well defined (by the transitivity, contraposition and weak substitutivity rules). Further, MATH is an effect algebra: MATH is weakly commutative and weakly associative, because of the corresponding rules of our calculus. The strong excluded middle axiom holds by definition of MATH and in virtue of the following rules: excluded middle, unicity of negation, double negation. Finally, the weak consistency axiom holds by weak Duns NAME REF and by definition of MATH. Lemma of the canonical model MATH . Sketch of the proof. By definition of MATH (in any effect algebra) one has to prove: MATH . This equivalence holds by REF and by definition of MATH. Finally, let us check that MATH is a ``good" valuation function. In other words: CASE: MATH CASE: MATH, if MATH is defined. CASE: By definition of MATH, we have to show that MATH is the unique MATH such that MATH. In other words, CASE: MATH. CASE: MATH. This holds by definition of the canonical model, by definition of MATH and by the following rules: double negation, excluded middle, unicity of negation. CASE: Suppose MATH is defined. Then MATH. Hence, by definition of MATH and of MATH: MATH. As a consequence, we obtain: MATH . |
quant-ph/0101040 | Utilizing REF tridiagonal property of MATH, REF definining relation of MATH for MATH can be written as MATH which we can rewrite in the form MATH . The inverse of a symmetric tridiagonal matrix possesses the following property CITE: MATH . Therefore MATH and follows the statement of the theorem: MATH . |
quant-ph/0101061 | CASE: We may expand MATH as MATH, with suitable vectors MATH. The reduced density matrix is determined by MATH . Since MATH is arbitrary (for example, MATH), we may compare coefficients and get MATH. Hence MATH is the desired orthonormal system. CASE: Existence of the purification is evident by defining MATH as above, with the orthonormal system MATH chosen in an arbitrary way. Then MATH, and the above computation shows that choosing the basis MATH is the only freedom in this construction. But any two bases are linked by a unitary transformation. |
quant-ph/0101119 | We have, for all MATH, MATH where MATH is the indicator function that is REF if its argument is true and is REF otherwise. Since the expectation of a sum is the sum of the expectations CITE , we have MATH . |
quant-ph/0101119 | The first inequality follows by the non-negativity of MATH. In fact, MATH is usually a function of MATH so that MATH and MATH. The second inequality follows by MATH . The third inequality follows by viewing the sum over the MATH as MATH times MATH, where MATH takes on the value MATH with probability MATH for MATH. The bound REF then gives the desired result. |
quant-ph/0101119 | A simple upper bound on MATH is the logarithm of the number of possible values MATH takes on with nonzero probability CITE, that is, the logarithm of the number of code words. We thus have MATH where the second inequality follows by REF , and the third inequality because of the minimization. Next, we have MATH where MATH. The inequality follows by the convexity of MATH and the equality by REF . Thus, the condition MATH implies that MATH, and we have MATH . This is the same as REF because the minimization over MATH is the same as the minimization over MATH . |
quant-ph/0101119 | We give only a very brief sketch of the proof for this preliminary version of the paper. The code is generated by choosing some MATH and then randomly choosing each symbol of the MATH code words independently using the resulting MATH. Let the MATH-th code word be MATH and choose some MATH. For each MATH satisfying MATH for all MATH, one looks for a code word MATH such that MATH for all MATH and MATH. Let MATH be the event that the MATH-th code word MATH, now regarded as a random variable, is such a code word. REF assures us that MATH where MATH as MATH and MATH. Continuing as in CITE, one will need MATH code words to ensure that MATH occurs for at least one MATH for all the ``typical" MATH. One can also use the approach in CITE to show that the distortion criterion is met for each such MATH pair with high probability. The code construction we have just described can be done for any MATH, so we choose that MATH which minimizes the rate MATH. |
quant-ph/0101120 | Let MATH be an arbitrary element of the NAME algebra MATH, and let MATH be an arbitrary element of the NAME algebra MATH. By definition, MATH is the tangent vector at MATH to the curve MATH in MATH given by MATH . Hence, MATH . |
quant-ph/0101133 | Every invocation of the bridge procedure takes time MATH. That is, every configuration has at most MATH predecessor configurations where it can have come from (constant number of states, constant alphabet size and choice of direction). Hence there are MATH configurations to be searched and about as many potential start configurations leading in MATH moves to the goal configuration, and every tape section comparison takes time MATH. The pebbling game over MATH nodes takes MATH (un)pebbling steps each of which is an invocation of bridge . Filling in MATH gives the claimed time bound. Each of the MATH pebbles takes space MATH, as does the simulation tape and the counter, giving the claimed total space. MATH . |
quant-ph/0101133 | There are MATH possible inputs to the irreversible computation, the computation on every input using on average MATH steps. A general simulation of this machine cannot use the semantics of the function being simulated but must simulate every step of the simulated machine. Hence MATH. The simulator being reversible requires different configurations for every step of everyone of the simulated computations that is, at least MATH configurations. The simulating machine has not more than MATH distinct configurations - MATH distinct values on the work tape, MATH states, and MATH head positions for the combination of input tape and work tape. Therefore, MATH. That is, MATH which shows that MATH. MATH . |
cond-mat/0102118 | A simple computation, using partial integration and the fact that MATH. |
cond-mat/0102118 | With the aid of REF we can write MATH . Denote MATH . Since MATH is convex by assumption, we get, for each positive function MATH, MATH where we used the fact that MATH and MATH by REF . The definition of the maximal function REF implies MATH, so we arrive at REF . |
cond-mat/0102118 | From REF one easily verifies the estimates MATH . Using this and REF we get MATH and MATH where MATH. Choosing MATH . REF implies that MATH . Next we use that for MATH . Using REF and the fact that MATH for MATH this implies MATH where we have used that, for MATH, MATH by NAME 's inequality. Now MATH which, inserted into REF , proves the Theorem. |
cond-mat/0102328 | Let MATH. The convergence of MATH and MATH implies the existence of numbers MATH such that for all MATH and for all MATH. Let MATH. For all MATH we then have MATH . The definition of the convolution of two measures implies MATH and MATH. Inserting MATH we obtain MATH . As the condition MATH is translationally invariant we further obtain MATH . In the same way MATH . We thus arrive at MATH in which MATH and MATH denote the total mass of MATH and MATH respectively. |
cond-mat/0102328 | The pointwise dimension of MATH at MATH is defined as MATH in which MATH is given by MATH . The symbol MATH denotes the characteristic function of a set MATH, that is, MATH if MATH and MATH otherwise. The area in which MATH is non-zero is shown in REF . Neglecting the regions in which either MATH or MATH (or both), the relevant region is the dark gray triangle. As MATH and MATH are positive measures, integration over the small square gives a lower and integration over the larger square an upper bound: MATH . Taking into account that MATH on MATH and MATH on MATH we can write MATH to finally obtain MATH which completes the proof as both sides of the inequality converge to MATH as MATH. The proof for the right boundaries is obtained by applying the same arguments to MATH and MATH. |
cond-mat/0102328 | As MATH is bi-Lipschitz so is MATH and therefore MATH for some constant MATH. Then MATH and MATH . This implies MATH. In the same way one obtains MATH such that MATH . The left and the right hand side of the inequality converge to MATH such that the middle part which converges to MATH also converges to this limit. |
cond-mat/0102328 | We need to distinguish three cases, MATH, MATH and MATH. For the first two cases the improved multifractal formalism with enlarged boxes coincides with the usual one and for simplicity we will use the later in these cases. Throughout the proof sums of the form MATH extend over all MATH with MATH, that is, boxes with zero measure are not taken into account (which is important for MATH). Let MATH. We denote MATH, MATH. Let MATH. For any MATH is the integral over the diagonal strip in the MATH-plane shown in REF . Integration over the dark gray squares provides a lower bound on this integral. MATH . Taking the MATH-th power of both sides and using MATH for MATH and any positive numbers MATH we obtain MATH . For MATH we have in the same way MATH . We denote MATH and MATH. Summing REF and over all MATH we get on the right hand side MATH. It is straightforward to show that MATH (compare REF) such that the left hand side of the sum of REF summed over all MATH is less than or equal to MATH. Taking the logarithm, dividing by MATH and multiplying with MATH we obtain MATH which completes the proof for MATH as the left hand side converges to MATH and the right hand side to MATH as MATH. Let MATH and MATH. We again write MATH, MATH and MATH. The solid and dashed squares in REF and by MATH diagonally translated disjoint copies cover the diagonal strip over which we need to integrate to obtain MATH. We therefore have the upper bound MATH . Taking the MATH-th power and using MATH for MATH and arbitrary positive numbers MATH yields MATH . When summing over all MATH each combination MATH appears at most twice in the sum on the right hand side such that MATH . Taking the logarithm of both sides, dividing by MATH and multiplying with MATH results in MATH . The limit MATH yields MATH. Let MATH. In this case we need the improved multifractal formalism with enlarged intervals. We use the notation MATH . By this choice we enlarge the MATH-intervals by MATH on both sides corresponding to MATH in NAME 's notation CITE. Furthermore we denote MATH that is, the MATH-intervals of MATH and MATH are enlarged by MATH corresponding to MATH. This choice facilitates the proof and has no influence on the resulting MATH as NAME has shown (compare CITE). Let MATH with MATH, that is, the integral over the MATH-th interior interval is non-zero. When calculating MATH we integrate over the wide diagonal strip in REF . The large squares MATH, MATH, are disjoint and are all contained in the strip. Therefore, MATH . This applies analogously to the other shown five squares and their by MATH diagonally translated disjoint copies such that MATH . The integral over the narrow diagonal strip determines that MATH is greater than zero. In the same way the integral over the small squares determines whether the terms on the right hand side are greater than zero. As the narrow strip is contained in the union of the small squares, the right hand side is greater than zero as MATH is. We therefore can take the MATH-th power on both sides and (omitting all terms being zero) use MATH for MATH and arbitrary positive numbers MATH to obtain MATH . When summing over all MATH with MATH, each combination MATH appears at most twice. Furthermore, adding terms which do not already appear only enlarges the right hand side. Therefore, MATH . From this we immediately obtain MATH which implies MATH in the limit MATH. |
cs/0102003 | We apply NAME 's Inequality to the random variable MATH. Let MATH be two paths that differ in a single component, say on day MATH. Assume without loss of generality that MATH has an uptick on day MATH while MATH has a downtick. Then MATH and MATH. Applying NAME 's Inequality with MATH and MATH, we have MATH . The claimed result follows from the fact that MATH . |
cs/0102003 | Let MATH denote the probability density function of MATH. CASE: Note first that MATH . Then MATH where the second-last inequality follows from the assumption that MATH and the last inequality follows from REF and our choice of MATH. CASE: Since MATH, MATH . |
cs/0102003 | This follows from the NAME bound CITE. |
cs/0102003 | The statements are proved as follows. CASE: With probability MATH, we have MATH where the first inequality follows from the proof of REF and the second inequality follows from REF . Since the price of the call is just MATH, the error in our estimate for the price is at most MATH. We give a closed-form formula for MATH in REF below. CASE: If MATH, then by REF , with probability MATH, MATH. This implies MATH. Otherwise, if MATH, we would have MATH which contradicts our choice of MATH above. Since MATH, we can apply REF . The variance of our estimate MATH for MATH is MATH. Since MATH the variance of our estimate is at most MATH for MATH and its standard deviation is MATH. Since the price of the call is just MATH, the expected error in our estimate for the payoff is at most MATH. |
cs/0102003 | Recall that MATH is the stock price at node MATH, MATH and MATH are the uptick/downtick factors, and MATH and MATH are the risk neutral probabilities. We have MATH as claimed. |
cs/0102003 | This theorem is analogous to REF and can be proven using similar techniques. |
cs/0102003 | Consider first the core buckets. Bucket MATH covers running totals in the range MATH and MATH covers running totals in the range MATH. The concatenation of paths in these buckets covers running totals in the range MATH. Assuming MATH, we put these paths in bucket MATH, and the running totals are underestimated by the original error of MATH, plus an additional MATH, since some partial paths that fall in the range of bucket MATH are actually put in MATH. If MATH, then these paths are put in the overflow bucket. In this case, no additional error is introduced. The original error of MATH is carried over. Similar arguments can be made when we are merging overflow buckets. |
cs/0102003 | In the implementation of REF , Merge runs in MATH time. However, the core buckets can be merged with a faster technique. Let MATH and MATH be polynomial representations of the bucket masses at nodes MATH and MATH. Let MATH. This product can be computed in MATH time with the Fast NAME Transform (FFT) CITE. For MATH, the coefficient of the MATH term of MATH is the probability mass that should be added to bucket MATH. For MATH, this coefficient should be added to the overflow bucket MATH. So the core buckets can be merged in MATH time per node. Merging the overflow buckets takes MATH time, so the total runtime per node is MATH. |
cs/0102003 | Take any path MATH and let MATH be the estimate for MATH made by the bucketing scheme. By assumption, MATH. Let MATH be isomorphic to MATH. Using MATH as an estimate for MATH, we underestimate MATH by at most MATH. This accounts for the first error term. Now, consider core bucket MATH of some leaf MATH of MATH. The range of running totals covered by this bucket is MATH. When we map this bucket to MATH, it covers path sums in the range MATH, which falls into at most three buckets in the corresponding node MATH of MATH, since MATH. Call these buckets MATH, MATH, and MATH (assume these are all core buckets). Putting the entire mass into MATH causes the portion of partial sums that fall into bucket MATH to be underestimated by additional MATH, which accounts for the second error term. Similar errors occur if the range MATH spills into the overflow bucket MATH and when mapping the overflow bucket MATH in MATH to MATH. |
cs/0102003 | We begin by recursively solving the problem on the subtree MATH. Notice that MATH. By REF , as long as MATH, we can use Estimate to compute the leaf bucket weights of MATH, without introducing significant error. Recalling that we take MATH, where MATH is the volatility of the stock, we see that we can use Estimate-MATH for MATH as large as MATH while keeping the error bounded. This proves the lemma. |
cs/0102003 | Consider the error in the MATH-th subproblem, MATH. Each recursive call has an error of MATH. When the MATH smaller granularity buckets in the MATH-st problem are grouped into the MATH buckets of the MATH-th problem, an error of one bucket size, MATH, is introduced. A call to Estimate underestimates the price sums by at most MATH, by REF . This error is made at most MATH times, once at each of levels MATH. At each of these levels, an additional error of MATH is introduced by the Merge procedure, as described in REF . The total error in the MATH-th subproblem is MATH . Unraveling MATH levels of the recursion on the original problem yields the result. |
cs/0102003 | Consider the runtime of the MATH-th subproblem, MATH. Each recursive call takes time MATH and at most MATH recursive calls are made at each of levels MATH. The leaf bucket weights of the other at most MATH subtrees rooted at the nodes at each of these levels can be determined using Estimate, which takes MATH time. For the Merge procedure, at each of MATH levels MATH, each of the at most MATH nodes at level MATH must be merged with MATH leaves from the subtrees MATH to get the bucket weights at level MATH. The merging of each node takes MATH time. The total runtime of the MATH-th subproblem is MATH . Unraveling MATH levels of the recursion on the original problem yields the lemma. |
cs/0102003 | After MATH levels of recursion, we have MATH. The problem consists of a single node and can be solved in constant time MATH with an error of MATH. From REF , the error is MATH . For the runtime analysis, by REF , note that MATH. For MATH, since MATH, MATH. Combining this fact with REF yields the runtime MATH . |
cs/0102003 | This follows from REF and the fact that MATH . |
cs/0102003 | Computing the leaf bucket weights for each stock MATH (using NAME) takes MATH time. The runtime of the rest of the computation is dominated by the time to compute MATH. We now describe an efficient way to do this. Assume that MATH, for some MATH. The general case is handled similarly. We conduct the multiplication by successively multiplying consecutive polynomials together MATH times until we are left with a single polynomial. For MATH, let MATH. For MATH and MATH, let MATH. The answer that we are looking for is just MATH. At stage MATH, we multiply together MATH pairs of polynomials, each of degree MATH. Using FFT, this takes MATH time. The total runtime to compute the product, over all stages, is MATH, from which the claimed result follows. |
cs/0102003 | For MATH, let MATH be any path down the binomial tree corresponding to stock MATH and let MATH be the total price down MATH. When we run NAME on MATH, each MATH is underestimated by at most MATH. Hence for any MATH, MATH is underestimated by at most MATH, as claimed. |
cs/0102003 | This follows directly from REF . |
cs/0102003 | This follows from REF , which gives the amount by which the total prices of the stocks may be underestimated. The amount by which the sum of their daily averages is underestimated is smaller by a factor of MATH. |
cs/0102005 | The case of MATH and MATH is a straightforward generalization of REF . The case of MATH is proved as follows. Let MATH be the position of the first MATH after MATH. Then, MATH where MATH and MATH are the open and close parentheses of the MATH-th type in MATH, respectively. The case of MATH can be shown similarly. To prove the case of MATH and MATH, we first generalize REF for an unbalanced binary MATH. Let MATH be the shortest balanced superstring of MATH. Let MATH. MATH is either MATH appended by MATH close parentheses or MATH open parentheses appended by MATH. Let MATH be MATH appended to MATH bits which record MATH and whether MATH is a prefix or a suffix of MATH. Then, a query for MATH can be answered from MATH in MATH time. Now suppose that MATH is of MATH types of parentheses. Let MATH with MATH be the string obtained from MATH as follows. CASE: Every open (respectively, close) parenthesis of the MATH-th type is replaced by two consecutive open (respectively, close) parentheses of the MATH-th type. CASE: Every parenthesis of any other type is replaced by a matching parenthesis pair of the MATH-th type. Each MATH is a string of length MATH using one type of parentheses. Each symbol MATH can be determined from MATH in MATH time. For example, A query for MATH can be answered by answering the queries for some MATH as follows. CASE: MATH, where MATH is a parenthesis of the MATH-th type. CASE: Let MATH and MATH be two positions. Let MATH . Let MATH, MATH, and MATH. Then, MATH. Each query above on MATH can be answered in MATH time from MATH. Since each symbol MATH can be determined from MATH in MATH time, the theorem holds by letting MATH. |
cs/0102005 | Let the parentheses, denoted by MATH and MATH, in MATH used by MATH be the MATH-th type. Let MATH be the preordering of MATH. Let MATH and MATH; that is, MATH and MATH are the matching parenthesis pair corresponding to MATH by REF . By REF , each MATH and MATH are obtainable from MATH in MATH time. Moreover, the index MATH is obtainable from MATH or MATH in MATH time by MATH. The queries for MATH are supported as follows. REF adjacency queries. Suppose MATH. Then, MATH if and only if MATH is adjacent to MATH in MATH, that is, MATH is the parent of MATH in MATH. REF neighbor queries. Suppose that MATH has degree MATH in MATH. The neighbors of MATH in MATH can be listed in MATH time as follows. First, if MATH, output MATH, where MATH. Then, let MATH. As long as MATH, we repeatedly output MATH and update MATH by MATH. REF degree queries. Since MATH is simple, the degree MATH of MATH in MATH is the number of neighbors in MATH, which is obtainable in MATH time. |
cs/0102005 | Let MATH be the preordering of MATH. Let MATH be the degree of MATH in MATH. We show how to use MATH to store the information required to obtain MATH in MATH time. CASE: Let MATH. Since MATH is a weakly convenient encoding for MATH, each MATH is obtainable in MATH time from MATH. Initially, MATH is MATH copies of MATH. Let MATH. We add MATH copies of MATH right after the MATH-REF in MATH for each MATH. Since the number of internal nodes in MATH is MATH, the bit count of MATH is MATH. MATH is obtainable from MATH in MATH time. The number MATH of REF's right after the MATH-REF in MATH is MATH. Since MATH, the degree of MATH in MATH can be computed in MATH time from MATH. CASE: Let MATH be the number of nodes of degree two in MATH. Initially, MATH is MATH copies of MATH, one for each node of degree at least three in MATH. Suppose that MATH is the MATH-th node in MATH of degree at least three. We put MATH copies of MATH right after the MATH-REF in MATH. The bit count of MATH is MATH. Since MATH is a weakly convenient encoding for MATH, it takes MATH time to determine whether MATH from MATH. If MATH, MATH can also be computed in MATH time from MATH. To compute MATH when MATH, note that since MATH, it suffices to compute MATH in MATH time. Let MATH be a MATH-bit string such that MATH if and only if MATH. Then, MATH, obtainable in MATH time from MATH. Each symbol MATH can be determined from MATH in MATH time, and we do not need to store MATH in our encoding. |
cs/0102005 | CASE: Suppose that MATH is added at step MATH of the construction algorithm for MATH. Either MATH or MATH is on the path MATH and the other is to the right of MATH on MATH. Hence MATH is neither an ancestor nor a descendant of MATH in MATH. CASE: Suppose that MATH is added at step MATH. The tree edge from MATH to its parent, that is, MATH or MATH, and all the nontree edges between MATH and its lower-numbered neighbors are added during this step; if MATH, no such nontree edge exists. All such nontree edges precede other edges incident to MATH in the counterclockwise order. Any edge MATH with MATH is added during step MATH with MATH. Let MATH. Thus, MATH is a tree edge only if MATH and MATH is the leftmost neighbor of MATH in MATH for otherwise MATH would be a nontree edge. The tree edges between MATH and its children, which are higher numbered, precede the nontree edges between MATH and its higher-numbered neighbors in the counterclockwise order. |
cs/0102005 | Straightforward. |
cs/0102005 | Suppose MATH and MATH, where MATH and MATH. Assume for a contradiction that MATH. Since MATH and MATH have no common endpoint, MATH. There are four possible cases: CASE: MATH; see REF . CASE: MATH; see REF . CASE: MATH; see REF . CASE: MATH; see REF . In REF , the dark lines are paths in MATH and the dashed ones are edges in MATH. The relation among these lines follows from REF . In all the cases, MATH crosses MATH, contradicting the fact that MATH is a plane graph. |
cs/0102005 | Since MATH is simple, by REF MATH is a weakly convenient encoding for MATH. We next show that MATH is also a weakly convenient encoding for MATH. Let MATH and MATH be the positions of MATH and MATH in MATH, respectively. REF adjacency queries. Suppose MATH. Then, MATH and MATH are adjacent in MATH if and only if MATH, where MATH as shown below. MATH REF neighbor and degree queries. The neighbors and thus the degree of a degree-MATH node MATH in MATH are obtainable in MATH time as follows. For each position MATH such that MATH, we output MATH, where MATH as shown below. Note that MATH is an edge in MATH with MATH. MATH . For each position MATH such that MATH, we output MATH, where MATH as shown below. Note that MATH is an edge in MATH with MATH. MATH . |
cs/0102005 | Let MATH and MATH be two binary strings defined as follows, both obtainable in MATH time: CASE: MATH if and only if MATH is a parenthesis for MATH; CASE: MATH if and only if the MATH-th parenthesis in MATH is open for MATH. Each MATH can be determined from MATH in MATH time as follows. Let MATH. If MATH, MATH is a parenthesis. Whether it is open or close can be determined from MATH. If MATH, MATH is a bracket. Whether it is open or close can be determined from MATH by REF . |
cs/0102005 | This lemma follows from REF , and REF and the fact that MATH contains MATH parentheses and MATH brackets. |
cs/0102005 | Note that the parentheses in MATH form MATH. Thus, by REF , it suffices to show that MATH is a convenient encoding for MATH as follows. REF adjacency queries. Given MATH, let MATH; the MATH in the last parameter accounts for the possibility that MATH is a bracket. Note that MATH is adjacent to MATH if and only if MATH as shown below. Here, the first inequality accounts for the possibility of MATH being a bracket. MATH REF neighbor queries. The neighbors of MATH can be listed as follows. For every position MATH with MATH, we output MATH, where MATH as shown below. Note that the MATH in the last parameter accounts for the possibility of MATH being a parenthesis. Also, MATH is an edge in MATH with MATH. MATH . For every position MATH with MATH, we output MATH, where MATH as shown below. Note that the MATH in the last parameter accounts for the possibility of MATH being a parenthesis. Note that MATH is an edge in MATH with MATH. MATH REF degree queries. The degree of MATH in MATH is MATH, obtainable from MATH in MATH time. |
cs/0102005 | Since each MATH is obtainable from MATH in MATH time, by REF , MATH is also a weakly convenient encoding for MATH. Since MATH satisfies REF and MATH is obtained from MATH by removing some brackets, MATH also satisfies REF . Since MATH has MATH parentheses and MATH brackets, by REF , MATH has a weakly convenient encoding of MATH bits. To augment this weakly convenient encoding into a convenient one, note that the degree of MATH in MATH is obtainable in MATH time from MATH. By REF , MATH additional bits suffice for supporting a degree query for MATH in MATH time. Thus, MATH has a convenient encoding of MATH bits. |
cs/0102005 | The statement for MATH follows immediately from REF with MATH. To prove the statement for MATH, let MATH be the graph obtained from MATH by adding the multiple edges of MATH between adjacent nodes in MATH. By REF , if MATH has MATH edges, then MATH has a weakly convenient encoding of MATH bits, from which a degree query for MATH takes MATH time. Next, let MATH. To support degree queries for MATH, note that MATH is a multiple tree of MATH nodes and MATH edges. By REF , MATH additional bits suffice for supporting a degree query of MATH in MATH time. Thus, MATH has a convenient encoding of MATH bits. |
cs/0102005 | By the definition of a canonical ordering, every MATH with MATH is adjacent to a higher-numbered and a lower-numbered node in MATH. Thus when computing the MATH of REF from MATH, we can also remove the MATH right after MATH even if MATH is internal in MATH. Then, the string MATH of length MATH is redefined as follows: MATH . The proof of REF works identically. Since the count of brackets decreases by MATH, each encoding in REF has MATH fewer bits. |
cs/0102005 | CASE: Let MATH be the number of unreal edges of MATH. Clearly MATH. Since MATH, it suffices to prove the claim that MATH for every MATH. For MATH, the claim holds trivially. Now suppose MATH. For MATH, let MATH and MATH be the numbers of real and unreal edges in MATH, respectively. Since the three trees in a realizer of MATH are edge disjoint, MATH. Since MATH and MATH, the claim holds. CASE: MATH . CASE: Let MATH be the number of nodes of degree MATH in MATH. Since MATH is a tree of MATH nodes, we have MATH . MATH follows immediately. |
cs/0102005 | CASE: Since each MATH is a spanning tree of MATH that satisfies REF , MATH is also a spanning tree of MATH that satisfies REF . Then, by REF , MATH has a weakly convenient encoding of MATH bits, from which the degree of a node in MATH is obtainable in MATH time. We next extend this encoding to a desired weakly convenient encoding MATH for MATH. Since MATH, it suffices to add a MATH-bit binary string MATH such that MATH if and only if MATH is real. Since MATH, the statement follows. CASE: To augment the above encoding MATH into a convenient one for MATH, it suffices to support in MATH time a query on the number MATH of real children of MATH in MATH. Fix an integer MATH. Let MATH be a binary string that contains MATH copies of MATH. If MATH is the MATH-th node in MATH of degree more than MATH in MATH, we put MATH copies of MATH right after the MATH-th MATH in MATH. The length of MATH is at most MATH. Since MATH, by the definition of a weakly convenient encoding, it takes MATH time to determine whether MATH from MATH. If MATH, MATH and thus the number of real neighbors of MATH in MATH can be computed in MATH time from MATH. If MATH, the number of real neighbors of MATH in MATH is MATH. To compute MATH in MATH time, let MATH be a MATH-bit binary string such that MATH if and only if MATH. Clearly if MATH, then MATH, computable in MATH time from MATH. Since each MATH can be determined in MATH time from MATH, MATH need not be stored in our encoding. In summary, MATH is a convenient encoding for MATH, which can be coded in MATH bits. The statement follows immediately from REF . |
cs/0102005 | The statements for MATH follow immediately from REF with MATH. To prove the statements for MATH, we first choose MATH to be the set of multiple edges such that MATH is composed of the multiple edges of MATH between adjacent nodes in MATH. Also, let MATH; let MATH be the number of edges in MATH. CASE: Continuing the proof of REF , we augment the weakly convenient encoding MATH for MATH into one for MATH. We support in MATH time a query for the number MATH of multiple edges of MATH between MATH and its parent in MATH as follows. Initially, MATH is MATH copies of MATH, one for each node that is not in the first two levels of MATH; recall that all nodes in the first two levels of MATH are unreal. For MATH, suppose that MATH is the MATH-th node in MATH that is not in the first two levels of MATH. We put MATH copies of MATH right after the MATH-th MATH in MATH. Since MATH has MATH edges between adjacent nodes in MATH, MATH has MATH bits. Let MATH be a MATH-bit binary string such that for MATH, MATH if and only if MATH is not in the first two levels of MATH. Clearly if MATH, then MATH. Since MATH is obtainable from MATH in MATH time, MATH is obtainable in MATH time from MATH. Moreover, since MATH if and only MATH, MATH can be removed from MATH. Thus, MATH has a weakly convenient encoding MATH of MATH bits. The statement follows from REF and the fact that MATH. CASE: We now augment the above encoding MATH into a convenient one for MATH. It suffices to support in MATH time a query on the number MATH of the real multiple edges MATH between MATH and its children in MATH. Initially, MATH is MATH copies of MATH. Suppose that MATH is the MATH-th node in MATH of degree more than MATH in MATH. We put MATH copies of MATH right after the MATH-th MATH in MATH. As in the proof of REF , MATH is obtainable from MATH in MATH time, where MATH is not stored in the encoding. If MATH, MATH is computable as MATH in MATH time. If MATH, MATH is computable in MATH time from MATH. MATH has at most MATH bits. Hence MATH has a convenient encoding MATH of MATH bits. Then, this statement follows from REF and the fact MATH. |
cs/0102005 | We first draw MATH and then perform the following MATH steps. REF processes MATH. Before this step, MATH and MATH have been built. Let MATH be the nodes on MATH from left to right. We know the numbers of remaining tree and external edges at each MATH, that is, those in MATH not yet added to MATH. We next find the leftmost neighbor MATH and the rightmost neighbor MATH of the nodes added during this step. Note that MATH is in MATH. Since MATH is the counterclockwise preordering of MATH, MATH is the rightmost node with a remaining tree edge; MATH is the leftmost node to the right of MATH with a remaining external edge. There are two cases: If MATH is type a, then this is a REF step and MATH is the single node added during this step. We add MATH and MATH. For each MATH with MATH, if MATH contains an internal edge, we also add MATH. If MATH is type b, then this is a REF step. Let MATH be the integer such that MATH are type b and MATH is type a. The chain MATH is added between MATH and MATH. Finally, the number of remaining tree (respectively, external) edges at MATH (respectively, MATH) decreases by REF. The numbers of tree, internal, and external edges remaining at each MATH for MATH are set to those of all tree, internal, and external edges in MATH. This finishes the MATH-th step. When the MATH-th step ends, we have MATH. |
cs/0102005 | We can look up the type of MATH in MATH. To recover MATH, we perform the following MATH steps. Before step MATH, we know the start index of MATH in MATH. With the cases below, REF finds the numbers of tree, external, and internal edges in MATH as well as the length of MATH, which tells us the start index of MATH in MATH. CASE: MATH is type aREF. There are three subcases. CASE: MATH starts with REF. Then MATH is type MATH and contains only one internal edge. Also, MATH has length REF. CASE: MATH starts with MATH. Then MATH is type MATH with MATH external edge. Also, MATH has length REF. CASE: MATH starts with REF. Let MATH be the maximal block of REF's in MATH at the start of MATH. Then, MATH has length MATH. Let MATH be the symbol after MATH in MATH. There are two further subcases. If MATH, MATH is type MATH and has MATH external edges. If MATH, MATH is type MATH and has MATH external edges and one internal edge. CASE: MATH is type aREF or b. Then MATH contains at least one tree edge. There are three subcases. CASE: MATH starts with MATH. Then MATH is type MATH and contains MATH tree edge. Also, MATH has length REF. CASE: MATH starts with REF. Let MATH be the maximal block of REF's in MATH at the start of MATH. Then MATH has length MATH. Let MATH be the symbol after MATH in MATH. There are two further subcases: If MATH, then MATH is type MATH and has MATH tree edges. If MATH, then MATH is type MATH and has REF tree edge and MATH external edges. CASE: MATH starts with REF. Let MATH be the maximal block of REF's in MATH at the start of MATH. There are three further subcases: If MATH follows MATH in MATH, then MATH is type MATH and has MATH tree edges and one internal edge. Also, MATH has length MATH. If MATH follows MATH in MATH, then MATH is type MATH and has MATH tree edges, MATH external edges, and one internal edge. Also, MATH has length MATH. If MATH follows MATH in MATH, then MATH is type MATH and has MATH tree edges and MATH external edges. Also, MATH has length MATH. This completes the description of the MATH-th step. In any case above, we can determine the length of MATH and recover MATH. |
cs/0102005 | CASE: In the above discussion, MATH has length MATH, and MATH has length MATH. The encoding MATH of MATH is the concatenation of MATH and MATH. Treated as an integer of base REF, MATH uses at most MATH bits. CASE: Let MATH be the dual of MATH. MATH has MATH nodes, MATH edges and MATH faces. Since MATH is triconnected, MATH is also triconnected. Furthermore, since MATH, MATH and MATH has no self-loop or multiple edge. Thus, we can use REF to encode MATH with at most MATH bits. Since MATH can be uniquely determined from MATH, to encode MATH, it suffices to encode MATH. To shorten MATH, if MATH, we encode MATH using at most MATH bits; otherwise, we encode MATH using at most MATH bits. This new encoding uses at most MATH bits. Since MATH, the bit count is at most MATH. For the sake of decoding, we use one extra bit to denote whether we encode MATH or MATH. |
cs/0102006 | Let MATH be the output of MATH. We prove the following statements with respect to MATH, MATH, MATH, MATH, and MATH by induction on the number of edges in MATH: CASE: Each external node of MATH remains external in MATH. Moreover, MATH is a subsequence of MATH. CASE: For each neighbor MATH of MATH in MATH other than MATH, if MATH and MATH (respectively, MATH) are on the same side of MATH in MATH, then MATH is on the first (respectively, last) internal face of MATH containing MATH and MATH in counterclockwise order around MATH starting from the one containing MATH. CASE: MATH rooted at MATH is a spanning tree of MATH such that exactly one of the following conditions holds for each node MATH in MATH (respectively, MATH): CASE: MATH is a leaf of MATH; and REF MATH (respectively, MATH) is the lowest-indexed (respectively, highest-indexed) child of MATH in MATH. CASE: MATH is a plane graph of MATH. CASE: MATH rooted at MATH is an orderly spanning tree of MATH. REF clearly suffice, but we need the other statements to enable the induction step. When MATH consists of a single edge MATH, by REF we have MATH. It is not difficult to see the inductive basis of each statement holds. For brevity, let Statement MATH REF stand for Statement MATH with respect to MATH, MATH, MATH, MATH, and MATH. Suppose MATH consists of MATH REF-connected components. By REF , we have MATH for each MATH. It follows from the inductive hypothesis that REF holds for each MATH and MATH. The rest of the proof shows the induction step. CASE: Observe that throughout the execution of MATH, without accounting for its subsequent subroutine calls to MATH, the embedding of MATH changes only by flipping edges into the interior of internal faces of MATH in REF . Thus, based on how MATH is obtained from MATH in REF , it follows from REF for all MATH that the statement holds. CASE: Let REF ' stand for the statement obtained from REF by replacing each MATH with a MATH. By REF , one can easily verify that the MATH at the completion REF satisfies REF '. From REF and how MATH is obtained from MATH in REF , we know that the relative order among the incident edges of MATH and the faces containing MATH remains the same in MATH and MATH. Therefore the statement follows from REF '. CASE: For each MATH, REF implies that MATH is a spanning tree of MATH. Since MATH are edge disjoint, and each node of MATH belongs to some MATH, we know that MATH, the union of all MATH, is a spanning tree of MATH. Since MATH is a leaf of MATH, clearly the required property holds for MATH. Let MATH be an external node of MATH other than MATH. If MATH is not an external edge of MATH belonging to MATH, then the required property for MATH follows from the property of MATH guaranteed by REF for each index MATH with MATH. Otherwise, by REF , MATH is either MATH or MATH. Let MATH be REF-connected component of MATH containing MATH. We have MATH. By REF (MATH), MATH is a leaf of MATH. Clearly, MATH is also a leaf of MATH, so the required property holds for MATH. CASE: Observe that REF flip an edge MATH into the interior of MATH only if MATH contains both MATH and MATH. Therefore, the equipped embedding of MATH at the completion of REF is still planar. According to how MATH is obtained from MATH in REF , the statement follows from REF for all indices MATH. CASE: Clearly, each neighbor of MATH in MATH is a child of MATH in MATH, hence MATH is orderly in MATH with respect to MATH. The rest of the proof shows that each node MATH other than MATH is orderly in MATH with respect to MATH. Let MATH be the graph obtained from MATH by deleting each incident edge of MATH in MATH. Clearly, MATH is a plane graph of MATH, and each MATH is a REF-connected component of MATH. Let MATH consist of the indices MATH with MATH. By MATH, one can verify that there is an index MATH in MATH such that MATH and MATH for each index MATH. We first show that if MATH is an edge of MATH, then MATH is unrelated with respect to MATH. If the index of MATH is higher than that of MATH, then by the fact that MATH is a leaf in MATH, we know that MATH is unrelated. As for the case with the index of MATH lower than than that of MATH, let us assume for a contradiction that MATH is an ancestor of MATH in MATH. By MATH and the fact that MATH is the parent of MATH in MATH, we know that MATH is also an ancestor of MATH in MATH. Let MATH be the path of MATH between MATH and MATH. Clearly, MATH. Let MATH be the node of MATH closest to MATH in MATH. It is not difficult to see MATH and MATH. By MATH, MATH, and MATH, we know MATH. Otherwise, MATH would have been a neighbor of MATH in MATH closer to MATH than MATH in MATH, thereby, contradicting the choice of MATH by REF . By MATH, MATH is not a leaf of MATH. Let MATH. By REF (MATH), we know that MATH is a child of MATH in MATH. By MATH, we have MATH. By MATH and MATH, we know that MATH and MATH are on different sides of the path of MATH between MATH and MATH in MATH, thereby, contradicting the fact that MATH is the highest-indexed child of MATH in MATH. We then show that MATH is orderly in MATH with respect to MATH. If MATH, then the orderly pattern of MATH in MATH with respect to MATH follows immediately from that in MATH with respect to MATH, which is ensured by REF (MATH). When MATH, by REF for all MATH, each neighbor of MATH in MATH is a child of MATH in MATH. It follows from REF that all children of MATH in MATH are consecutive in MATH around MATH. Since MATH is orderly in MATH with respect to MATH, one can see that MATH is orderly in MATH with respect to MATH. Since MATH is a leaf of MATH, we know that MATH is orderly in MATH with respect to MATH. It remains to show that each neighbor MATH of MATH in MATH is orderly in MATH with respect to MATH. Let MATH (respectively, MATH) be the neighbor of MATH that precedes (respectively, succeeds) MATH in counterclockwise order around MATH. It suffices to show that if the index of MATH is lower (respectively, higher) than that of MATH, then MATH (respectively, MATH) belongs to MATH or MATH (respectively, MATH or MATH) of MATH with respect to MATH as follows: If the index of MATH is lower than that of MATH, then we know MATH by REF . By REF , one can verify that MATH belongs to MATH. By REF , we have that MATH belongs to either MATH or MATH of MATH with respect to MATH. If the index of MATH is higher than that of MATH, then we know MATH from REF . By REF , one can verify that MATH belongs to MATH. From REF , we have that MATH belongs to either MATH or MATH of MATH with respect to MATH. |
cs/0102006 | The execution of MATH consists of a sequence of subroutine calls to MATH. One can see that each node of MATH can be the parameter MATH for no more than two subroutine calls to MATH - one with MATH and the other with MATH. Clearly, if MATH, then the subroutine call MATH runs in MATH time. Let MATH be the number of subroutine calls to MATH with MATH. For each MATH, let MATH be the MATH-th subroutine call to MATH with MATH throughout the execution of MATH, where MATH, MATH, and MATH. Clearly, MATH for any two distinct indices MATH and MATH, thereby, implying MATH. Let MATH consist of the edges of MATH belonging to the boundary of some internal face of MATH which contains MATH. Let MATH be the time required by MATH, without accounting for that required by its subsequent subroutine calls to MATH. Clearly, MATH holds for each MATH. It is not difficult to implement the algorithm MATH such that the running time of MATH is dominated by MATH. Since MATH has MATH edges, it suffices to show as follows that any edge MATH of MATH belongs to no more than two of the sets MATH: Let MATH be the smallest index MATH with MATH. If MATH, then MATH is also the largest index MATH with MATH. It remains to consider the case MATH. Let MATH be the smallest index MATH with MATH and MATH. By definition of MATH, it can be verified that MATH has to be on the contour of MATH, implying MATH. Therefore, MATH is the largest index MATH with MATH. |
cs/0102006 | Let MATH be a plane graph of the input MATH-node planar graph. Let MATH be REF-connected of MATH. Let MATH be an external node of MATH. For each MATH, let MATH be the node of MATH closest to MATH in MATH. Clearly, MATH. Also, for each MATH, it is not difficult to see that MATH is an external node of MATH, and that MATH is disconnected. For each MATH, let MATH. Let MATH be the union of MATH rooted at MATH. Let MATH be the union of MATH such that, for each MATH, the children of MATH in MATH are consecutive in the counterclockwise neighbor sequence of MATH in MATH. By REF , one can verify that MATH is a well-defined plane graph of MATH, and that MATH is an orderly spanning tree of MATH. By REF , it is not difficult to see that both MATH and MATH are derivable in MATH time. |
cs/0102006 | Let MATH be the given orderly spanning tree of MATH. Let MATH be the counterclockwise preordering of MATH, where MATH, MATH, and MATH are the external nodes of MATH in counterclockwise order. Clearly, MATH and MATH must be in MATH. Since MATH is a plane triangulation, and the edge of MATH is unrelated with respect to MATH, we know that both MATH and MATH are nonempty for each MATH. Let MATH (respectively, MATH) be the index of the last (respectively, first) node in MATH (respectively, MATH) in counterclockwise order around MATH. Let MATH be obtained from MATH by deleting MATH and MATH. Let MATH and MATH. An example is shown in REF . Clearly, MATH holds for each MATH, implying that both MATH and MATH are acyclic. Since MATH is a plane triangulation, exactly one of the equalities MATH and MATH holds for each edge MATH with MATH. It follows that each internal edge of MATH belongs to exactly one of MATH, MATH, and MATH. By definitions of MATH and MATH, one can verify that the neighbors of each internal node MATH of MATH indeed form the required pattern for MATH as a realizer of MATH. Since it takes MATH time to determine each MATH and MATH, the lemma is proved. |
cs/0102006 | Straightforward by REF . |
cs/0102006 | Since MATH is an orderly spanning tree of MATH, it is clear that MATH is well defined, and that the output of MATH is indeed a REF-visibility drawing of MATH with width equal to the number of leaves in MATH. The rest of the proof shows that the height of the output of MATH is at most MATH. For any two distinct edges MATH and MATH in MATH, we say that MATH encloses MATH if MATH is enclosed by the cycle consisting of MATH and the path of MATH between the endpoints of MATH. Let MATH. Clearly, MATH encloses all the other edges in MATH. For each edge MATH in MATH, if MATH does not enclose any other edge in MATH, then let MATH; otherwise, let MATH be one plus the maximum of MATH over all the edges MATH in MATH that are enclosed by MATH. One can easily verify that the height of the output of MATH is at most MATH. It remains to show MATH as follows: Assume for a contradiction that MATH is a sequence of edges in MATH such that MATH encloses MATH for each MATH. For each MATH, let MATH consist of the endpoints of MATH. Clearly, for each MATH, there must be an endpoint of MATH that is not in MATH. Therefore, MATH contains at least MATH distinct nodes. Since MATH is an orderly spanning tree of MATH, MATH is not incident to any edges of MATH. Therefore, MATH, and thereby, contradicting that MATH has MATH nodes. |
cs/0102006 | Let MATH, MATH, and MATH be the external nodes of MATH in counterclockwise order around the contour of MATH. By REF , a realizer MATH of MATH, where each MATH is rooted at MATH, can be obtained in MATH time. Let MATH. For each MATH, let MATH, where MATH. Clearly, MATH, MATH, and MATH are three spanning trees of MATH with MATH. We first show that each MATH is an orderly spanning tree of MATH. Since the relation among MATH, MATH, and MATH is rotationally symmetric, it suffices to verify that each node is orderly with respect to MATH. Let MATH be the counterclockwise preordering of MATH. For each MATH and MATH, let MATH be the path of MATH between MATH and MATH. Note that MATH, MATH, and MATH are three edge-disjoint paths of MATH that intersect only at MATH. Clearly, if MATH is not a leaf of MATH, then the children of MATH in MATH are consecutive in MATH in counterclockwise order around MATH. Therefore, to ensure that each node is orderly with respect to MATH, is suffices to prove that each edge of MATH is unrelated with respect to MATH: If MATH were an ancestor of MATH that is also a neighbor of MATH in MATH, then MATH and MATH would be on different sides of MATH in MATH, where MATH is the parent of MATH in MATH, thereby, contradicting the planarity of MATH. It remains to show that MATH, MATH, or MATH has at most MATH leaves. For each MATH, let MATH consist of the leaves of MATH. Since the number of leaves in MATH is precisely MATH, it suffices to show MATH as follows. Let MATH be a node in MATH. Clearly, MATH is internal in MATH. For each MATH, let MATH denote the parent of MATH in MATH. Let MATH and MATH be the indices in MATH. Since MATH is a realizer of MATH, there is a unique internal face MATH of MATH containing MATH, MATH, and MATH. Clearly, MATH and MATH. It follows that MATH for any node MATH in MATH, and that MATH for any node MATH in MATH. Therefore, MATH is no more than the number of internal faces of MATH, which is precisely MATH by NAME 's formula. |
cs/0102006 | It is not difficult to see that the algorithm MATH can be implemented to run in linear time, so the theorem follows immediately from REF . |
cs/0102006 | Let MATH. Let MATH be the number of distinct types of parentheses in MATH. Let MATH be the smallest integer with MATH. Clearly, each symbol of MATH can be encoded in MATH bits. By MATH, we have MATH. Let MATH. Clearly, any substring MATH with MATH has MATH possible distinct values. Define tables MATH and MATH for MATH by letting MATH and MATH, for any MATH with MATH. Clearly, MATH and MATH. For each MATH, define tables MATH and MATH as follows. For each MATH, let MATH, where MATH is the largest index satisfying MATH, MATH, and that MATH is a close parenthesis of type MATH. Let MATH, where MATH is the smallest index satisfying MATH, MATH, and that MATH is an open parenthesis of type MATH. Clearly, MATH and MATH. An open MATH is special if REF MATH, REF MATH, and REF for each MATH with MATH and MATH, we have MATH or MATH. A close MATH is special if MATH is special. For each MATH, define tables MATH and MATH as follows. For each MATH, let MATH, where MATH is the largest index with MATH such that MATH is a special close parenthesis of type MATH. Let MATH, where MATH is the smallest index with MATH such that MATH is a special open parenthesis of type MATH. Clearly, MATH and MATH. Let MATH. It follows from MATH that MATH. Clearly, MATH can be derived from MATH in MATH time. It remains to show that MATH can be determined from MATH and MATH by the algorithm shown in REF , which clearly runs in MATH time. By definitions of MATH, if a value MATH is returned from REF - REF , then MATH. The rest of the proof assumes that REF is executed. We first show that MATH is not special and that MATH holds. Assume for a contradiction that MATH is special. By definitions of MATH and MATH, there exists an index MATH such that REF MATH; CASE: MATH and MATH encloses MATH and MATH; CASE: MATH is special; CASE: MATH; and REF MATH. By definition of special parentheses, REF contradicts REF . Assume MATH for contradictory purpose. By definitions of MATH and MATH, there exists an index MATH such that REF MATH; CASE: MATH and MATH encloses MATH and MATH; CASE: MATH; CASE: MATH; and REF MATH. By REF , we know MATH, thereby, contradicting REF . Now we are ready to argue that the algorithm correctly returns MATH in REF . By REF , MATH is open and MATH is closed. By REF , we know MATH. If MATH, then MATH . Now we assume MATH. Since MATH is not special and MATH, by definition of special parentheses, there exists an index MATH with MATH, MATH, and MATH, where MATH. Therefore, it is not difficult to see MATH, thereby, proving the lemma. |
cs/0102006 | The techniques in the proof are mostly adapted from CITE. We focus on the case that MATH is connected. It is not difficult to remove this restriction. By REF , an orderly pair MATH of MATH can be derived in MATH time. Let MATH be the MATH-code of MATH. We prove that there exists a MATH-bit string MATH, obtainable in MATH time, such that MATH is a convenient encoding of MATH. Clearly, if MATH has no multiple edges, then MATH consists of MATH copies of MATH, and thus, MATH will suffice. If MATH and MATH, then MATH and MATH. Clearly, we have MATH. From definition of MATH, we know MATH. Let MATH. From MATH, REF , and REF , we determine that MATH is computable from MATH in MATH time. Let MATH be the string of two types of parentheses derived from MATH and MATH as follows. Let MATH and MATH be of type REF with MATH and MATH of type REF. Initially, for each MATH, replace the MATH-th MATH of MATH with MATH. Then, replace each MATH of MATH with a bracket such that the bracket is open if and only if the last parenthesis in MATH preceding this MATH is closed. More precisely, for each MATH, let MATH where MATH. For example, if MATH and MATH are as given in REF , then MATH is as in REF . It is easily determined that there exists an auxiliary string MATH such that any MATH consecutive symbols of MATH is obtainable from MATH in MATH time: Let MATH. Clearly, the content of MATH can be uniquely determined by the concatenation MATH of MATH and MATH with MATH. Clearly, MATH is obtainable from MATH in MATH time. Since MATH has MATH distinct values, we can precompute in MATH time a table MATH with MATH such that the content of MATH is obtainable from MATH and MATH in MATH time. Hence, it suffices to let MATH. For each MATH, let MATH be the interval MATH and MATH be the interval MATH, where MATH and MATH. Let MATH and MATH, with MATH and MATH, be two unrelated edges of MATH with respect to MATH. Since MATH is an orderly spanning tree of MATH, one can see that if MATH is enclosed by the cycle of MATH determined by MATH and MATH, then MATH. It follows that MATH and MATH, with MATH, are adjacent in MATH if and only if there exists an index MATH with MATH. Therefore, one can determine whether MATH is an unrelated edge of MATH with respect to MATH, by checking whether MATH and MATH hold, where MATH. Therefore, the adjacency query is derivable from MATH in MATH time. It is not difficult to see that the neighbors of a degree-MATH node MATH can be listed from MATH in MATH time: If MATH is not the root of MATH, then the parent of MATH is MATH, where MATH is computable by MATH and MATH. If MATH is not a leaf of MATH, then MATH is the first child of MATH in MATH. If MATH is the MATH-th child of MATH in MATH, then the MATH-st child of MATH in MATH is MATH, where MATH. If MATH, then the MATH-th neighbor of MATH in MATH with respect to MATH is MATH, where MATH is computable by MATH, MATH, MATH. If MATH, then the MATH-th neighbor of MATH in MATH with respect to MATH is MATH where MATH is computable by MATH and MATH. It is not difficult to verify that MATH can be reconstructed from MATH and MATH in MATH time. Therefore, the theorem is proved by letting MATH. |
cs/0102007 | We reduce the SATISFIABILITY problem CITE to the CFE problem. Let MATH be a CNF formula over variables MATH with MATH. Let MATH be the clauses of MATH, each regarded as the set of literals in it. We construct a simple biconnected planar graph MATH as follows. MATH. MATH. For each MATH, MATH contains edges MATH, MATH, MATH, MATH. The only other edges of MATH are MATH, MATH, MATH, , MATH, MATH, MATH. Let MATH be the sequence MATH. Observe that in every plane embedding MATH of MATH, REF the cycle MATH forms the boundary of some face MATH and REF for MATH, exactly one of MATH and MATH is on the boundary of the face other than MATH whose boundary contains the path MATH. Also, for every set MATH with MATH for all MATH, MATH has a plane embedding where the boundary of some face contains the path MATH and the vertices in MATH. Therefore, MATH is satisfiable if and only if MATH satisfies MATH. |
cs/0102007 | We consider three special cases: CASE: MATH is connected. CASE: MATH is biconnected. CASE: MATH is triconnected. In REF solves REF of the CFE problem faster than the desired time bound. In REF reduces this theorem to Case MREF. In REF reduces REF to Case MREF. In REF uses REF to solve REF of the CFE problem within the desired running time. This theorem follows from REF , and REF. |
cs/0102007 | We prove the statements separately as follows. CASE: This statement immediately follows from the condition that MATH is triconnected with no multiple edges. CASE: Since MATH has no multiple edges, MATH contains MATH edges between distinct vertices in MATH. Then, this statement follows from REF and the fact that an edge in a simple plane graph can be a boundary edge of at most two faces. CASE: If MATH has at most three vertices, the statement holds trivially. Otherwise, the statement follows from REF and the fact that the dual of MATH is also a simple triconnected plane graph CITE. |
cs/0102007 | This corollary follows from REF . |
cs/0102007 | REF are straightforward. To prove REF , it suffices to prove MATH since by REF , MATH. To bound the number of vertices in MATH, let MATH and MATH be as specified in the definition of MATH. Let MATH be the set of vertices MATH in MATH such that MATH appears on the boundary of exactly one face in MATH. Then, MATH consists of all the vertices in MATH. Note that MATH. Also, by REF , MATH. Consequently, since by REF MATH, MATH as desired. To bound the number of edges in MATH, we first examine the multiple edges. Let MATH and MATH be adjacent vertices in MATH. Let MATH be the set of faces in MATH whose boundaries contain both MATH and MATH. Then, MATH. By REF , MATH. If MATH, then the two boundary paths of MATH between MATH and MATH may degenerate into at most two multiple edges between MATH and MATH in MATH. If MATH, then by the triconnectivity of MATH, MATH and MATH share exactly one common boundary edge MATH, which is also an edge in MATH. Let MATH be the boundary of MATH without MATH. MATH and MATH may degenerate into at most two multiple edges between MATH and MATH in MATH. In summary, there are at most three multiple edges between two vertices in MATH. Similarly, only the boundary of a face in MATH can degenerate into a self-loop in MATH; so, MATH has only MATH self-loops. By NAME 's formula, MATH has MATH edges as desired. |
cs/0102007 | The three statements follow from those of REF , respectively. |
cs/0102007 | We prove the statements separately as follows. CASE: The proof is straightforward. Note that a positive face in MATH is also a positive face in MATH and that a negative face in MATH combines one or more faces not in MATH. CASE: The proof follows from REF . The graphs MATH can be computed by applying REF recursively with MATH iterations. By REF , the first iteration takes MATH time. By REF , each subsequent iteration takes MATH time. By REF , the constant coefficient in the MATH term does not accumulate over recursions. |
cs/0102007 | The statements are proved separately as follows. CASE: Note that MATH by a straightforward case analysis. Then, as REF , MATH and MATH. CASE: We compute MATH recursively via REF . If MATH, then MATH. If MATH, then MATH can be computed in MATH time in a straightforward manner. For MATH, there are three stages: CASE: Compute MATH and MATH in MATH time in a straightforward manner. CASE: Recursively compute MATH and MATH. CASE: Compute MATH in MATH time in a straightforward manner, which is MATH by REF . This recursive computation has MATH iterations. The recursion at the top level takes MATH time. Every subsequent level takes MATH time since by REF MATH and MATH. Note that by REF , the constant coefficient in the MATH term does not accumulate over recursions. |
cs/0102007 | REF follows from REF follows from REF , and the fact that MATH has a unique combinatorial embedding computable in linear time CITE. |
cs/0102007 | The two directions are proved as follows. MATH . Let MATH be an embedding of MATH satisfying MATH. Let MATH be the restriction of MATH to MATH. For each MATH, our goal is to prove that MATH satisfies MATH. First, MATH satisfies each MATH-local family in MATH. Let MATH be a block of MATH with MATH. We next prove that MATH satisfies MATH. Let MATH be the vertices of MATH. We claim that MATH has no cycle MATH such that at least one but not all of MATH, MATH are inside MATH in MATH. To prove by contradiction, assume that such MATH exists. Then, some MATH with MATH contains MATH. However, by the construction of MATH, no connected component of MATH contains all of MATH, MATH, contradicting the fact that MATH is a block of MATH. Thus, the claim holds. Therefore, the boundary of some face MATH in MATH intersects each of MATH. Since MATH must be unique, the boundary of MATH intersects every set in MATH for every MATH in MATH such that the sets in MATH fall into two or more of MATH, MATH, MATH, MATH. Hence, the boundary of MATH intersects every set in MATH. Consequently, MATH satisfies MATH. MATH . Let MATH be an embedding of MATH satisfying MATH. We construct an embedding of MATH satisfying MATH as follows. First, consider a block MATH of MATH. Let MATH be the vertices of MATH. Let MATH be the subgraph of MATH formed by MATH, , MATH. Let MATH be the sequence consisting of MATH and the MATH-local families in MATH for MATH. We can assume that the boundary of the exterior face of MATH intersects every set in MATH. By identifying the exterior faces of MATH, , MATH, we can combine the embeddings into an embedding MATH of MATH satisfying MATH. Next, we utilize MATH to combine MATH, , MATH into a single embedding of MATH. First, root MATH at a block of MATH. For a leaf MATH in MATH, let MATH and MATH be the parent and grandparent of MATH in MATH, respectively. Let MATH (respectively, MATH) be the restriction of MATH (respectively, MATH) to MATH. Note that MATH, MATH, and MATH are topologically equivalent up to the choice of their exterior face. Thus, MATH (respectively, MATH) can be obtained as follows: For every vertex MATH of MATH (respectively, MATH), put a suitable embedding MATH of MATH that is topologically equivalent to MATH into a suitable face MATH of MATH. This gives an embedding of those MATH with MATH. We replace MATH with this embedding, replace MATH with the union of MATH and MATH, and delete MATH from MATH. Afterwards, if MATH becomes a leaf of MATH, then we further delete it from MATH. We repeat this process until MATH is a single vertex, at which time we obtain an embedding of MATH satisfying MATH. |
cs/0102007 | The proof follows from REF and the fact that MATH and the sequences MATH above can be constructed from MATH and MATH in MATH time. |
cs/0102007 | The two directions are proved as follows. MATH . The proof is the same as that of REF except that the claim therein now implies that the boundary of some face MATH in MATH intersects each of MATH. MATH . The proof is the same as that of REF except that MATH (respectively, MATH) now can be obtained as follows: For each vertex MATH of MATH (respectively, MATH), put a suitable embedding MATH of MATH that is topologically equivalent to MATH into a suitable face MATH of MATH, and then identify the two occurrences of MATH. |
cs/0102007 | It suffices to construct a sequence MATH for each block MATH of MATH, with a total size of MATH in MATH total time over all the blocks of MATH, such that MATH satisfies MATH if and only if every MATH satisfies MATH. To construct MATH based on REF , we process MATH, , MATH one at a time. During the processing of MATH, we construct MATH for all MATH. Then, we delete MATH, MATH, , MATH from MATH. After processing MATH, we are left with the root MATH for which we then construct MATH. We use the following data structures. See REF for an example of some of the data structures before processing the first cut vertex of MATH. CASE: During the construction, some families in MATH may be united, and we use a union-find data structure to maintain a collection of disjoint dynamic subsets of MATH. (Recall that MATH is the number of families in MATH.) Each subset of MATH in the data structure is identified by a representative member of the subset. For each MATH, let MATH be the representative of the subset containing MATH. Initially, each MATH forms a singleton subset, and thus, MATH. CASE: Each set MATH in a family in MATH is implemented as a pair MATH, where MATH is a linked list, and MATH is a splay tree CITE. Initially, MATH consists of the vertices in MATH in the increasing order of their post-order numbers. MATH is initialized by inserting the ranks of the vertices in MATH into an empty splay tree. A splay tree supports the following operations in amortized logarithmic time per operation: REF insert a rank and REF delete the ranks in a given range. CASE: A linked list MATH, for each block MATH of MATH. Initially, each MATH consists of all pairs MATH such that MATH, MATH, MATH is MATH-local, and MATH. CASE: A linked list MATH, for each MATH. Initially, each MATH consists of all pairs MATH such that MATH, MATH, MATH, and MATH. CASE: An array MATH of integers. Initially, for each MATH, MATH where MATH ranges over all vertices of MATH such that MATH contains a pair MATH with MATH = ``don't care". CASE: An array MATH of integers. Initially, for each MATH, MATH. CASE: An array MATH of linked lists of integers. Initially, for each MATH, MATH is empty. CASE: A temporary array MATH of integers. We maintain the following invariants immediately before processing each MATH. In particular, we initialize the above data structures so that the invariants hold before MATH is processed. It takes MATH total time to initialize the data structures except the splay trees. CASE: For each vertex MATH of MATH and each pair MATH, REF MATH consists of the vertices in MATH in the increasing order of their post-order numbers, REF the rank of each vertex of MATH is stored in MATH, and REF for every MATH, MATH and MATH have been updated as MATH and MATH, respectively. CASE: For each block vertex MATH of MATH and each MATH, it holds that MATH, MATH is MATH-local, and MATH. CASE: For each MATH and each MATH, it holds that MATH, MATH, and MATH and MATH. CASE: For each MATH with MATH, let MATH there is a vertex MATH of MATH such that MATH contains a pair MATH with MATH. Let MATH be the sequence of all families MATH such that MATH and MATH. Let MATH be the subgraph of MATH induced by MATH, where MATH ranges over all the block vertices of MATH. Then, MATH satisfies MATH if and only if REF MATH satisfies MATH and REF for each block MATH of MATH that has been deleted from MATH, MATH satisfies MATH. CASE: For each MATH with MATH, MATH where MATH ranges over all vertices of MATH such that MATH contains a pair MATH with MATH. CASE: For each MATH, MATH and MATH is empty. We process MATH in the following stages WREF through WREF. See REF for an example of some of the data structures after processing the first cut vertex of MATH. MATH hecks whether each related family is MATH-global as follows. CASE: Compute MATH, and for some MATH, MATH contains a pair MATH with MATH. ( Remark. For each MATH with MATH, the family MATH is MATH-local, where MATH is the augmented component of MATH induced by MATH that is not among MATH, , MATH. See the fourth invariant for MATH and MATH.) CASE: For each MATH, set MATH to be the number of integers MATH such that MATH contains a pair MATH with MATH. (Remark. For MATH, MATH.) CASE: For each MATH, perform the following: CASE: If MATH and MATH, then set MATH where MATH is the unique integer in MATH such that MATH contains a pair MATH with MATH. (Remark. MATH is MATH-local.) CASE: Otherwise set MATH. (Remark. MATH is MATH-global.) MATH odifies each MATH with MATH in each MATH-local family based on REF as follows. CASE: For each MATH with MATH, let MATH, delete all vertices outside MATH from MATH, and then insert MATH to MATH. Here, deleting all vertices outside MATH from MATH is done as follows: Delete MATH from MATH, delete all the ranks in the range MATH and all the ranks in the range MATH from MATH, and insert MATH to MATH. CASE: For each MATH with MATH, perform the following: (Remark. MATH is MATH-local. See the remark in REF of or MATH.) CASE: Delete all vertices MATH with MATH from MATH as follows: Delete MATH from MATH, delete all the ranks in the range MATH from MATH, and insert MATH to MATH. CASE: If MATH, that is, MATH has no cut vertex, then insert MATH to MATH and set MATH. CASE: If MATH, then find the first vertex MATH in MATH, insert MATH to MATH, and set MATH. (Remark. MATH.) MATH odifies each MATH-global family based on REF as follows. CASE: For each MATH with MATH, set MATH contains a pair MATH with MATH. CASE: For each MATH with MATH and MATH, insert REF to MATH. CASE: Set MATH and MATH. CASE: Construct an edge-labeled graph MATH as follows. The vertices of MATH are MATH, MATH, , MATH. For each MATH with MATH, MATH has a cycle possibly of length REF whose vertices are the integers in MATH and whose edges are all labeled MATH. CASE: For each block MATH of MATH, find the labels MATH on the edges in MATH and unite those subsets in the union-find data structure that have MATH as their representative, respectively; afterwards, for the representative MATH of the resulting subset, further perform the following: CASE: Insert MATH to all lists MATH such that MATH. CASE: If MATH, then set MATH, MATH, , MATH. MATH onstructs the sequences MATH for MATH and updates the data structures as follows. CASE: For each MATH and each MATH in MATH, replace MATH by MATH. CASE: For each MATH, set MATH to be the sequence of the families MATH, where MATH ranges over those integers that are in a pair in MATH. CASE: Delete MATH and its children from MATH. CASE: For each MATH, set MATH and MATH. By REF , after the processing of MATH, the invariants hold for MATH. After processing MATH, we construct MATH as follows: Replace each pair MATH in MATH by MATH, and then set MATH to be the sequence of the families MATH, where MATH ranges over those integers that are in a pair in MATH. By the invariants, REF , and REF , MATH satisfies MATH if and only if every block MATH of MATH satisfies MATH. As for the time complexity, we make the following observations: CASE: When processing MATH, we create at most MATH new sets all equal to MATH, where MATH is the maximum number of blocks in a simple graph with MATH vertices. Since MATH and MATH does not exceed the degree of MATH in MATH, the total number of newly created sets is MATH. CASE: If a set MATH does not intersect MATH immediately before the processing of MATH, then there is at most one MATH such that some vertices of MATH are touched during the processing of MATH. CASE: If MATH is in MATH immediately before the processing of MATH, then we either REF touch at most MATH vertices of MATH during the processing of MATH, or REF touch no vertex of MATH during the processing of each MATH. There are at most MATH unions and MATH finds, and at most MATH insertions into each splay tree. By the above observations, the total time spent on the union-find data structure is MATH , that on the splay trees is MATH, and that on the remaining computation is MATH, all within the desired time. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.