Elementary physics

To get the right answers, you have to ask the right questions.

Good question:  How does general relativity work?
Better question:  How does motion work?

Elementary, as in the very basic heart, physics involves answering this question.  It's odd that physicists don't seem to be interested in asking it, much less answering it.  Eh, that's what a university indoctrination will get you these days, I guess.  I blame the Copenhagen interpretation and Bell's straw man inequality.

Everything comes down to basic principles.  Complexity arises from the interactions of very simple laws.  There are no infinities (∞).  There are no singularities (1/∞).  There are no contradictions.

1)  There is no such thing as negative energy.

2)  At every point, total energy is a constant (plus or minus a tiny uncertainty).

3)  Spacetime is a field of potential energy which governs motion.

4)  Space time is smooth and contiguous.

5)  Waves, consisting of a wavelength (space), frequency (time) and amplitude (energy), are discrete.

Each of these three  propositions is observably true.  Negative energy is a phantasm.  The Schwarzschild radius of a black hole proves there is such a thing as maximal energy density.  (Plus the fact that the entire energy content of a black hole can be [and is] contained in its shell.)  Gravity and general relativity prove that spacetime governs motion, with a special nod to the equivalence principle.  For waves to be discrete, which they observably are, and for motion to exist as we know it (duh), spacetime must be smooth and continuous.  Again, there are no singularities, there are no infinities, there are no contradictions.

A reminder to physicists:  The map is not the territory.  The math, no matter how elegant, is not the reality.  It is, at best, a description of reality.  A probability wave does not describe reality, but our perception of reality.  Physics has made no major advances since you have collectively forgotten this simple truth.  Oh, and the universe does not operate by complex laws, but by the interactions of very simple ones.

The implications of my 5 rules/laws/principles are profound.

• Black holes are not singularities, but hollow shells of maximal energy density.
• The interior of a black hole is a domain of zero energy nothingness.
• Inertial motion is a standing wave in spacetime.  Crossing this wave is the cause of many relativistic effects (losing/gaining energy).
• Just as no physical thing can reach the speed of light (the propagation rate of spacetime), no physical thing can hold perfectly still.
• There exist both a minimal and maximal usable energies. (The absolute minimum being, of course, zero.  Heisenberg rules!)
• There exist both a lowest and highest possible frequency/wavelength.  
• By corollary (multiplication, really), there exists a lowest and highest possible amplitude for each frequency/wavelength.
• This solves the general relativity/quantum mechanics problem.
• There are no infinities.  
• There are no singularities.  
• There are no contradictions.

Esolang OISC:2bis

 Obfuscated Indirect Subleq with Coprocessor: 2 word instruction, version 2.  (That's what 'bis' means, from the Latin.)

This is the new and improved version, now with an actual parser.  And a stack.  And you don't have to use a separate file for the negative memory assignments.

The raw numbers are extremely obfuscated, but the parser makes it easy to use.  This may be against the spirit of esolangs.  Positive, negative, and zero valued instructions change the effects, and decimals make arguments indirect.  All instructions are in positive memory (use the absolute value).  Negative memory can only be accessed indirectly.

    Two word instruction:  A B

    A B    Effect
    + +    B = B - A
    - +    if [A] <= 0, jump to B
    + -    if [A] <=0, call B
    - -    if [A] <= 0, relative jump by [B]
    + 0    Push [A] onto the stack
    - 0    Pop the stack into A
    0 +    Execute instruction [B] on the stack
    0 -    if [B] <= 0, return
    0 0    halt

    Assembler formats:

    #            comment
    %            data (optional in negative memory)
    name:        naming a memory word
    name         using a named word
    *name        indirect reference [[name]] (if N is 23, *N is 23.0)
    @            this word
    ?            next word
    % --NEGATIVE: --NEGATIVE--     mandatory memory separator
    !            0
    ;            end of instruction
    ,            separator
    " or '       string delimiters
    ZERO         automatically created word containing 0
    &            negative and pointer (parser internal use)

    /sub can be called with 1 or 2 words
        X Y      [Y] = [Y] - [X]
        X        [X] = 0
    /call, /jump and /relj can be called with 1 or 2 words.  Branching to a negative address will halt.
        X Y      if [X] <= 0, branch to Y (relative jump by [Y])
        X        unconditional branch to X (relative jump by [X])
    /push, /pop and /exec are called with 1 word
        X        push [X] / pop to X / execute instruction [X]
    /ret can be called with 0 or 1 word.  If the return stack is empty, the program will halt.
        X        if [X] <= 0, return
        -        unconditional return (ZERO inserted)
    /halt        takes no arguments

    Stack instructions:

         Positive                      Negative
    1    input char ( -- a)            output char (a -- )
    2    input digit  ( -- a)          output number (a -- )
    3    DUP (a -- aa)                 DROP (a -- )
    4    OVER (ab -- aba)              SWAP (ab -- ba)
    5    roll left N (abcd1 -- bcda)   roll right N (abcd2 -- cdab)
    6    reverse stack (abcd -- dcba)  clear stack (abcd -- )
    7    depth of stack ( -- a)        pick N (abcd3 -- abcdb) 
    8    bitwise true ( -- -1)         bitwise false ( -- 0)
    9    bitwise AND (ab -- a&b)       bitwise NOT (a -- ~a)
    10   bitwise OR (ab -- a|b)        bitwise XOR (ab -- a^b)
    11   shift left N bits (aN -- a)   shift right N bits (aN -- a)
    12   times (ab -- a*b)             divide (ab -- a/b)
    13   int division (ab -- a//b)     remainder (ab -- a%b)
    14   exponent e (a -- exp(a))      natural log (a -- log(a))
    15   convert to integer (a -- a)   convert to float (a -- a)
    16   alloc N words (sign matters)  free N words (sign matters)
    17   plus (ab -- a+b)              minus (ab -- a-b)
    18   sin (a -- sin(a))             asin (a -- asin(a))
    19   cos (a -- cos(a))             acos (a -- acos(a))
    20   tan (a -- tan(a))             atan (a -- atan(a))
    21   sinh (a -- sinh(a))           asinh (a -- asinh(a))
    22   cosh (a -- cos(a))            acosh (a -- acosh(a))
    23   tanh (a -- cos(a))            atanh (a -- atanh(a))

    

Implemented on GitHub.

    

New Us Army rifle and light machine gun

The US Army finally picked the SIG rifle and light machine gun as the winners of the 6.8mm NGSW project.

As much as I like the 6.5 Grendel, I think that the .243 would have been a much more logical (not to mention cheaper and lighter) choice. But the decision was skewed from the start by the competition being based on using a secret 6.8mm round that DARPA invented, plus a requirement that it push 3,000 fps out of a 13.5" barrel.

I don't have much of a problem with the rifle. It's a piston operated AR-10. This will be good for standardizing the market around one common model. The light machine gun is also a wonderful idea, even if it's not the bee's knees where accuracy is concerned. (Weighing only 14 pounds makes up for a lot of sins.)  Add in the request for 6.8mm barrels for the existing M240 medium machine guns, and you finally have a common ammo for all the standard infantry weapons. The one bone I have to pick is that the specs didn't call for a rifle or machine gun with "continuous push" recoil. That was a criminally stupid oversight.

Next on the table, the new .338 Norma machine guns. Now those are actually a really good idea. As a bonus, they share a common ammo (well, caliber) with the newer sniper rifles.

You have to ask the right questions

 To get the right answers, you have to ask the right questions.

The fundamental questions of physics are: 1) "What is motion?" 2) "What is time?" 3) "What is space?" 4) "What is spacetime?"

The answers to these questions turn out to be ridiculously simple.

1. Standing wave in spacetime. (If motion and gravity (spacetime curvature) have the same effects, they must have similar causes. Note that a tangent to the curvature of spacetime is literally distance over time.)

2. Steadily increasing linear eccentricity (C) of a hyperbola. (The focus is steadily moving away from the origin.) A^2 - B^2 = C^2

3. Steadily increasing radius of a sphere with center at the focus of the time hyperbola. (Distance C from the origin.) A^2 + B^2 = C^2

4. Potential energy field with a fixed maximum, from which all other fields draw their energy. (Total energy everywhere is a constant.) There being no such thing as negative energy, there is also a fixed minimum. This is where black holes show up, and why they are hollow shells of maximal density with nothing inside.

The universe is an expanding sphere in an ever expanding light speed cone defining a hyperbola which is time. As my daughter said, we are tiny sprinkles in the ice cream cone of existence.

Hypothesis: At creation, antimatter and "negative energy" went into the cone extending the other way from the origin. Thus, everything really does sum up to zero over the largest view.

Esolang OISC:3e

 I know, I know.  I'm fascinated and nobody else cares.

My ideas have shifted with the experience of building and using the assemblers and interpreters.  This is the latest, greatest version of how OISC:3 works.

Obfuscated Indirect Subleq with Coprocessor: 3 word instructions

Positive and negative memory both exist in the same save file.  Instructions are restricted to positive memory.  Indirect addressing is accomplished through the use of real/float/decimal numbers ("121.0").  This is the key to unlocking useful negative addressing and simplifying everything.

The assembler will work with raw numbers, names, and even with the built in instruction macro names (in italics below).  And yes, I have a working assembler and interpreter.  It even can output an executable raw numbers file.

Instruction formats:

A B C    [C] = [B] - [A]                 /sub    
A B 0    [B] = [B] - A                   /lit-    
A 0 C    if [A] <= 0, call C             /call
                pushes NextIP onto the return stack
0 B C    if [B] <= 0, jump to C          /jump
A 0 0    push [A] onto the stack         /push
0 B 0    pop the top of stack to B       /pop
0 0 C    execute instruction [C]         /exec
                operates on the stack
0 0 0    return                          /ret
                pops the top of return stack to NextIP

Assembler formats:

#            comment
%            data
name:        naming a memory word
name         using a named word
*name        indirect reference [[name]] (if N is 23, *N is 23.0)
@            this word
?            next word
% --NEGATIVE: --NEGATIVE--     mandatory memory separator
!            0
;            end of instruction
,            separator
" or '       string delimiters
ZERO         automatically created word containing 0

/sub can be called with 1, 2 or 3 words
    A B C    [C] = [B] - [A]
    A B      [B] = [B] - [A]
    A        [A] = 0
/lit- must be called with 2 words
    A B      [B] = [B] - A
/call and /jump can be called with 1 or 2 words.
    A B      if [A] <= 0, branch to B
    A        unconditional branch to A
/push, /pop and /exec are called with 1 word
    A        push [A] / pop to [A] / execute instruction [A]
/ret takes no arguments.  If the return stack is empty, the program will halt.  Branching to a negative address will also halt.

Stack instructions:

     Positive                      Negative
1    input char ( -- a)            output char (a -- )
2    input digit  ( -- a)          output number (a -- )
3    DUP (a -- aa)                 DROP (a -- )
4    OVER (ab -- aba)              SWAP (ab -- ba)
5    roll left N (abcd1 -- bcda)   roll right N (abcd2 -- cdab)
6    reverse stack (abcd -- dcba)  clear stack (abcd -- )
7    depth of stack ( -- a)        pick N (abcd3 -- abcdb) 
8    bitwise true ( -- -1)         bitwise false ( -- 0)
9    bitwise AND (ab -- a&b)       bitwise NOT (a -- ~a)
10   bitwise OR (ab -- a|b)        bitwise XOR (ab -- a^b)
11   shift left N bits (aN -- a)   shift right N bits (aN -- a)
12   times (ab -- a*b)             divide (ab -- a/b)
13   int division (ab -- a//b)     remainder (ab -- a%b)
14   exponent e (a -- exp(a))      natural log (a -- log(a))
15   convert to integer (a -- a)   convert to float (a -- a)
16   alloc N words (sign matters)  free N words (sign matters)
17   plus (ab -- a+b)              minus (ab -- a-b)
18   sin (a -- sin(a))             asin (a -- asin(a))
19   cos (a -- cos(a))             acos (a -- acos(a))
20   tan (a -- tan(a))             atan (a -- atan(a))
21   sinh (a -- sinh(a))           asinh (a -- asinh(a))
22   cosh (a -- cos(a))            acosh (a -- acosh(a))
23   tanh (a -- cos(a))            atanh (a -- atanh(a))