Gauge structure of teleparallel gravity

I am interested in references that treat teleparallel gravity in a mathematically rigorous manner, especially in regards to it being a “gauge theory of the translation group”.

The standard reference is the book by Aldrovandi and Pereira, however this book uses extremely sloppy mathematics at times, and is extremely confusing.

The paper “Einstein Lagrangian as the translational Yang-Mills Lagrangian ” by Cho edges closer to what I am looking for, but it still seems to suffer from issues (it considers a principal translation bundle, which seems to be problematic). Some of these issues are outlined here (without reference to the Cho paper).

Probably the closest I’ve seen to what I am looking for is the paper “Geometric meaning of the Poincaré group gauge theory” by Pilch, however this is rather short, not very detailed and somewhat unclear to me.

Basically, I am looking for a mathematically precise, principal bundle-based treatment of teleparallel gravity as a gauge theory. Based on the “naive gauging” done by phyicists I expect the connection would be an affine connection whose translational part is dynamical, and its linear $ O(3,1)$ part is flat (Weitzenböck connection) and is somehow determined by the translational part (we have $ W^\kappa_{\mu\nu}=B^\kappa_a\partial_\mu B^a_\nu$ in the local formulation, where $ W$ is the Weitzenböck connection in a holonomic frame, and $ B_\mu^a$ is the parallel covielbein).

The specifics of this however elude me, especially that while in ordinary GR a solder form $ \theta$ on the principal Lorentz bundle is essentially the same “globally” as an orthonormal covielbein, a solder form cannot simply correspond to the parallel Weitzenböck tetrad, as the latter is not invariant under arbitrary point-dependent Lorentz transformations.

The coupling to matter fields is also unclear to me, especially if we wish to keep the concept of “Lagrangian not invariant under gauge transformations is made invariant by the introduction of a connection”, which actually makes sense even for nontrivial principal bundles, as evidenced by the formulation present (for “ordinary”) gauge theories by David Bleecker in “Gauge theory and variational principles”.

I kinda wish the references (if they exist) should be fairly detailed and didactic, as I feel that teleparallel gravity is relatively well defined albeit somewhat artificial and ad-hoc when the gauge theory interpretation is not shoehorned into it, however in the usual physicists’ formulations it becomes rather confused if the gauge theory interpretation is forced. It is clarity I seek.

Although the question is primarily about teleparallel gravity, I am interested in any formulation of gravity equivalent to GR which can be described as a gauge theory on a principal fibre bundle, so references to mathematically precise formulations of “Poincaré gauge theory gravity” or “Lorentz group gauge theory gravity” are also very much welcome on my part, although I am much more ignorant about these approaches than I am about teleparallelism.

Cache-conscious data structure that does not require hashing

I am looking for a cache conscious data structure that does not require hashing. This is to avoid HashDoS without needing to use cryptographic PRFs such as SipHash, which are slow (~1 cycle/byte) – I think that one can do better.

So far, I have found HAT-tries, radix tries, and Judy arrays.

  • HAT-tries still require hashing, so the problem arises again.
  • Radix tries are still slower than hash tables due to poor utilization of CPU caches.
  • Judy arrays are fast, but are enormously complex (20k SLOC in C), and the only implementation that I know only accepts strings, byte arrays, and machine words as keys. Furthermore, their performance characteristics are non-portable: the same library that performs excellently on systems with 64-byte cache lines may have much worse performance on systems with 32-byte cache lines.

None of these solve the problem. Simplicity is important, as I will be most likely to use this data structure in languages other than C or Java and so need to be able to implement it in a new language in a reasonable amount of time.

You can assume that a source of cryptographically secure random numbers with reasonable performance is available.

Only data structures that are unencumbered by patents are of interest.

The keys and values need to be able to be treated as opaque (except perhaps for size): all access needs to be (or be able to be) through user-defined accessors.

which data structure is best for income and expense entry and sorting according to the parameters like(date, amount, priority) in c#

i am making a budget tracker application where user will input their income and expense and will keep track of them on daily basis, and user can also sort their income and expense according to the parameter like (date, priority and amount, and categories) which is the best data structures to implement these things in c# windows form.

I am a second year student of cs and have studied in my ds course(arrays, queue, list, linked list, tree, binary tree, heap, binary search tree, graph,bfs,dfs).

Building complex sentences based on a data structure

I really do not like how bad this looks. It is not readable and I am not sure if I need the stacked map’s. There are a lot of iterations going on here (map, join, replace) and performance is really important, please help 🙁


const alternatives = [   "flex",   "float",   [     "background-size",     "background-image"   ] ] 

Expected Output:

'Consider using 'flex', 'float' or 'background-size' with 'background-image' instead.' 

Working Code:

const result = `Consider using $  {alternatives                  .map((alternative) => {                    return Array.isArray(alternative)                      ? => `'$  {a}'`).join(' with ')                      : `'$  {alternative}'`;                  })                  .join(', ')                  .replace(/, ([^,]*)$  /, ' or $  1')} instead.` 

Redirection Plugin: Change permalink structure to remove date, want to retain and pass query strings (?utm_)

I have changed the permalink structure from /%year%/%monthnum%/%postname%.html to /%postname%/

I have added the following regex rule to the Redirection plugin:

Source URL: ^/([0-9]{4})/([0-9]{2})/([^/]+).html(.*)$   Target URL:$  3/ 

This works and redirects links from social media appended with ?utm_medium=social&utm_source=pinterest etc., but strips that parameter from the target.

How may I edit my regex to have it pass the query string and append it to the new URL format?

Thank you.

Problem to structure code permissions (ACL) [migrated]

I have a problem here to structure the code to validate the permissions.

Let’s suppose I have three actions: read:own_users, read:my_users, read:all_users.

And I have a route get/users.

I want this route returning all users if the guy which is doing the request have read:all_users. But if he only have read:my_users permission, this route should return just the users that this guy inserted. And the last possibility, if the user just have read:own_users permission, I wants this route returning just your own object.

So, what I want to solve is: How to do that without doing a switch case in my code for every route putting a where in my SQL.

Or maybe I’m doing this by the wrong way and I need to plan all the stuff trying a new strategy.

Correct Python script structure

I’ve been programming in Python for some time now and I’ve always used the below structure to organize my code. Lately, I’ve been wondering if this structure is an ideal and correct one to use generally in Python, both in terms of it being Pythonic but also performance wise?

The structure I follow in my scripts is as below:

def main(argv):          """         Main entry for execution of the program         """         try:             call_func1()             call_func2()             call_func3()         except some_specific_exception_type1 as e:             do_something             raise         except some_specific_exception_type2 as e:             do_something             raise         except Exception as e: # catch all other exceptions that might occur             do_something             raise  def call_func1():         try:             do_something_in_here         except some_specific_exception_type1 as e:             do_something             raise         except some_specific_exception_type2 as e:             do_something             raise         except Exception as e: # catch all other exceptions that might occur             do_something             raise  def call_func2():         try:             do_something_else_in_here         except some_specific_exception_type1 as e:             do_something             raise         except some_specific_exception_type2 as e:             do_something             raise         except Exception as e: # catch all other exceptions that might occur             do_something             raise    if __name__ == '__main__':         main(sys.argv[1:]) 

As you can see, I have a central point in the script where the execution of the program starts(in this case is the main() method) and from there I call other methods that perform some type of actions.

Then each of the methods(whether it is the central starting point or the other methods that do a specific work) handle exceptions that might be thrown by the actions they perform and raise those.

This way, I have a central point where the execution of the program starts but also a central point where the execution will finish since all methods will return back to main() whether they succeed or throw an exception(since they will raise it).

I was wondering if implementing this kind of structure is a correct thing to do both in terms of it being Pythonic, or whether if it affects the performance of the program or if it is the right away to handle errors?

Thank you in advance!

Recover data with file structure HFS+ on Mojave

I’m desperate and trying almost everything. That’s what happened. I was having problem with Time Machine. One file was not letting time machine finish the backup. But to discover this took me a while. Then I was just formatting the backup HDs to see if would fix it. But then I formatted my 8tb external HD with work photos and videos totalling around 4,5tb.

Usually I do things on my own, I don’t know why I didn’t searched beforehand an answer around google and recovery softwares. But since it was a simple formatting by disk utility I thought it would be simple. But anyway I went to a recovery specialist. Let the HD for 4 days for an estimate. It was too expensive so I denied and the next day got the drive back and tried another technician. This second guy got all my raw data back using PhotoRec. Then tried some softwares and could not get the file structure. After a while he quit and then I went to a third one. After a week he also could not recover with the file structure.

I tried Stellar data Recovery, R-Studio, Disk Drill and some others. None can see the last formatting. And getting many files corrupted specially video.

Is this normal? Is it so hard to recover 100% a Mac formatting? Because I can even see the original factory formatting with the bundled software. Why I can’t see my file structure. Am I doing something wrong? Is there something I could try? Anything? I have a little suspicion that the first technician did something to the file structure so others could not repair it in full. Please help.

functional programming using nodejs, project folder structure [on hold]

I am a nodejs/express developer and am looking to move to a functional development approach. I have reviewed alot of information on the concepts of functional programming; monads, currying, functors, partial application, etc. but I am struggling to find examples explaining an ideal way a node.js express app folder structure should be organized when functional programming is utilized? How would functional programming change how business rules are organized and grouped? I am looking for online links, etc. that would walk through how organization changes in a move to fp. Most things I have seen so far cover the concepts like currying, functor, etc. but not applying within the concept of an application.