bipartite d regular expender explicit construction

I am looking for an explicit (and simple) construction of a d regular bi bipartite graph which is an expander. I searched the web and didn’t find any sufficient answer. The only explicit graph I did managed to find(and understand) was the margolis graph, but as far as I can understand this graph is not a bipartite (for example (0,0) has a self edge).

Please help me.

Aspect-oriented vs explicit style in Python

Readability counts, but is very subjective. The following snippets are equivalent in functionality and turn a generator iterator into a chunked HTTP response in Flask. Which code snippet do you find more readable and easier to understand?

A) Aspect style with function decorators that change the return value:

@app.route('/') @flask_response_decorator @optional_streaming_decorator @progress_log_decorator def index() -> Iterator:     """Index page, optionally HTTP chunk-streamed and formatted."""     return Foo.get_instance().are_changes_locked() 

or

B) explicit decorators within the function body

@app.route('/') def index() -> flask.Response:     """Index page, optionally HTTP chunk-streamed and formatted."""     response = Foo.get_instance().are_changes_locked()     return flask.Response(optional_iterator_to_stream(iterator_to_progress_log(response))) 

Explicit evaluation of the derivatives of $p$-adic Gamma function at 0

The definition of the $ p$ -adic Gamma function $ \Gamma_p(x)$ for an odd prime number $ p$ can be found in the book “A Course in $ p$ -adic analysis” by A. M. Robert. While the construction of $ \log \Gamma_p(x)$ is also included in the book. The function $ \log \Gamma_p(x)$ is odd, and has a series expansion in the variable $ x$ . For more details, see Chapter 7 of the book. \begin{equation} \log \Gamma_p(x)=(\log \Gamma_p)^{(1)}(0)x+\frac{1}{3!}(\log \Gamma_p)^{(3)}(0)x^3+\frac{1}{5!}(\log \Gamma_p)^{(5)}(0)x^5+\cdots. \end{equation} Since $ \log \Gamma_p(x)$ is an odd function, we have \begin{equation} (\log \Gamma_p)^{(2n)}(0)=0. \end{equation} I am wondering whether there is an explicit method to evaluate the coefficient $ (\log \Gamma_p)^{(s)}(0)$ , at least the first several terms $ (\log \Gamma_p)^{(3)}(0)$ , $ (\log \Gamma_p)^{(5)}(0)$ , and $ (\log \Gamma_p)^{(7)}(0)$ ?

One helpful observations is that since we have \begin{equation} \Gamma_p(0)=1, \end{equation} so $ (\log \Gamma_p)^{(s)}(0)$ can be computed by \begin{equation} \Gamma_p^{‘}(0),\Gamma^{”}_p(0),\Gamma^{”’}_p(0), \cdots,\Gamma^{(s)}_p(0). \end{equation} So this question is equivalent to evaluate $ \Gamma_p^{‘}(0),\Gamma^{”}_p(0),\Gamma^{”’}_p(0),\cdots$ . Does anyone know an explicit formula to compute them?

Explicit bivariate quadratic polynomials where Coppersmith is better than standard solver?

http://www.numbertheory.org/pdfs/general_quadratic_solution.pdf gives a general method to solve quadratic bivariate diophantine equation while Coppersmith introduced a method to solve bivariate polynomials which work provably and have been shown to break $ RSA$ system if half of low significant bits of either $ P$ or $ Q$ are known.

The equation that comes out is $ $ (2^ku+v)(2^ku’+v’)=PQ$ $ where if we assume $ v$ is known. Then $ vv’\equiv PQ\bmod 2^k$ gives $ v’$ .

So we have a quadratic diophantine equation $ $ 2^kuu’+(uv’+u’v)=\frac{PQ-vv’}{2^k}.$ $

Why do I need Coppersmith’s method to solve this? Can’t a regular diophantine solver work here and so are there explicit polynomials where Coppersmith is better than standard solver in bivariate quadratic case?

An explicit formula for characteristic polynomial of matrix tensor product

Consider two polynomials P and Q and their companion matrices. It seems that char polynomial of tensor product of said matrices would be a polynomial with roots that are all possible pairs product of roots of P,Q.

I guess its coefficients could be expressed through coefficients of P and Q. But I don’t know the explicit formula and I cannot find it. I also failed to find it out myself — I tried different approaches. Maybe it should be that characteristic polynomial, maybe resultant of some form, but..

I hope this is done by someone already.

Explicit Song Checker

To stay in practice with my python I’ve decided to write an explicit song checker. It checks each word in the song against an array of explicit words contained in the file. I’ve decided not to include the words that are to be checked against, for I am not sure about the rule of having explicit words in a programs code. Feedback on efficiency and structure is what I’m going for mostly. Style and other critiques are invited as well.

explicit_song_checker.py

explicit_words = [     #explicit words not shown  ]  def isClean(song_path):     with open(song_path) as song:         for line in song:             words = line.split(" ")             for word in words:                 for explicit_word in explicit_words:                     if word == explicit_word:                         return False          return True  def main():     song = raw_input("Enter path to song: \n")     if isClean(song):         print("CLEAN")     else:         print("EXPLICIT")  if __name__ == '__main__':     main() 

Explicit vs Implicit save. Differences between Android and iOS expectations

Our app makes use of a ‘Shopping Cart’ type metaphor, in which users can select from a variety of items, and then confirm or remove all these items at once. We’ll call this explicit save.

The trouble is when we tested on an Android user, this pattern seemed off to him, and the behavior of removing all items when pressing the ‘X‘ was jarring. His assumption was that when selecting an item, it would be saved implicitly, and that the ‘X‘ button would effectively have the same behavior of the ‘Done‘ button.

Is this a commonly expected behavior on Android? (I’m an iOS user). And if so, is it horribly jarring to keep this behavior?

EDIT: The question focuses more on the behavior of the top-left nav button. When a user presses this button, they navigate back to the app’s home screen. The question is: when this button is pressed, is the expectation to commit the changes made to the card, or discard them?

mockup

download bmml source – Wireframes created with Balsamiq Mockups

Some notes about this mock:

1) The search bar and auto-complete suggestions appear as an expanded section over top of the cart screen.

2) Since search bar expands and shrinks to show the Cart, the ‘X‘ button is the same UI element the whole time (to try and eliminate confusion about where it will navigate to)

3) Users have the ability to remove items from the cart directly from the list.

4) This is not actually a Shopping app. There is no money exchanged when I press ‘Done‘. Think of it as putting together a list of things I did today, and ‘Done‘ gives me feedback on the things that I did.

Explicit description of the conjugation action of $a_p = [[1,0],[0,p]]$ on the amalgam $SL(2,\mathbb{Z})*_{\Gamma_0(p)} a_pSL(2,\mathbb{Z})a_p^{-1}$

Let $ a_p$ denote the matrix $ [[1,0],[0,p]]$ , where $ p$ is prime.

Then $ SL_2(\mathbb{Z}[1/p])$ can be presented as the amalgamated product

$ $ SL_2(\mathbb{Z})*_{\Gamma_0(p)} a_pSL_2(\mathbb{Z})a_p^{-1}$ $ where $ \Gamma_0(p)$ are the matrices which are upper-triangular mod $ p$ , and the inclusions into the two factors are the natural ones.

I would like to construct the group $ GL_2(\mathbb{Z}[1/p])$ (in the software package GAP) as a semidirect product of $ SL_2(\mathbb{Z}[1/p])$ and $ p^\mathbb{Z}$ .

For this, I need to tell GAP the action of conjugation of $ a_p$ on $ SL_2(\mathbb{Z}[1/p])$ in terms of the generators of the amalgamated product (ideally algorithmically easy ones, e.g. the 4 generators coming from the two copies of $ SL_2(\mathbb{Z})$ ).

I’m sure this must have been done somewhere. Does anyone have a reference? (Or perhaps can someone give an explicit presentation of this conjugation action?)

(Also posted here)

How can I find explicit examples of maximal orders of quaternion algebras that are not isomorphic?

I know that there exist algorithms that will construct maximal orders of a quaternion algebra over, say, $ \mathbb{Q}$ . However, the implemented algorithms that I know of require that you input an order that is not necessarily maximal, which the algorithm then completes. Unfortunately, this does not help if you want examples of orders that are not isomorphic to one another.

The more examples (at least over $ \mathbb{Q}$ , but preferably over other number fields) that I can get, the better, but I would be happy even with a table of some known examples.

How do I block a package’s dependencies from explicit apt-get remove?

I need to use

sudo apt-get -y --purge remove $  manypackages 

where $ manypackages includes dependencies of a package that I don’t want removed.

Is it possible to prevent apt-get from removing those dependencies instead of me having to determine them and remove them from the $ manypackages list beforehand?