Merry Christmas!

Paul of Tarsus, who was Saul, said unto the Galatians, who were reverting to their previous, wicked ways:

Galatians 4: 

Now I say, That the heir, as long as he is a child, differeth nothing from a servant, though he be lord of all;

2 But is under tutors and governors until the time appointed of the father.

3 Even so we, when we were children, were in bondage under the elements of the world:

4 But when the fulness of the time was come, God sent forth his Son, made of a woman, made under the law,

5 To redeem them that were under the law, that we might receive the adoption of sons.

6 And because ye are sons, God hath sent forth the Spirit of his Son into your hearts, crying, Abba, Father.

7 Wherefore thou art no more a servant, but a son; and if a son, then an heir of God through Christ.

8 Howbeit then, when ye knew not God, ye did service unto them which by nature are no gods.

9 But now, after that ye have known God, or rather are known of God, how turn ye again to the weak and beggarly elements, whereunto ye desire again to be in bondage?

28 Now we, brethren, as Isaac was, are the children of promise.

29 But as then he that was born after the flesh persecuted him that was born after the Spirit, even so it is now.

30 Nevertheless what saith the scripture? Cast out the bondwoman and her son: for the son of the bondwoman shall not be heir with the son of the freewoman.

31 So then, brethren, we are not children of the bondwoman, but of the free.

G5:1 Stand fast therefore in the liberty wherewith Christ hath made us free, and be not entangled again with the yoke of bondage.

13 For, brethren, ye have been called unto liberty; only use not liberty for an occasion to the flesh, but by love serve one another.

14 For all the law is fulfilled in one word, even in this; Thou shalt love thy neighbour as thyself.

15 But if ye bite and devour one another, take heed that ye be not consumed one of another.

Entropy and temperature

 So much that we were taught in schools is wrong.  Well, perhaps not technically incorrect, but definitely misleading.

Take entropy, for example.  We are taught that entropy is chaos.  Entropy is randomness.

Not really.

What entropy really is, is averageness.  The more average something is, the higher its entropy.  The lower energy a system has, the higher its entropy.  The fewer states something has, the greater its entropy.

Temperature itself is a measure of disorder.  Higher temperature = more energy = more internal motion = greater disorder.  Lower temperature = less energy = less internal motion = less disorder.

These concepts are related.  Work can only be done when a system has useful differences.  Energy flows across gradients, which means the differences have to exist.  High entropy systems have low energy gradients.

Another new book!

 Alma Boykin's latest has arrived!

"The Hunter in Shadows", book 2 of Familiar Generations.

Get it.  Read it.  Then go back and read all her Familiar Tales.

Books released recently

 I used to be a voracious reader.  Now I merely read a lot.

Here are books released recently by some of my favorite authors.  Your mileage may vary.

Cedar Sanderson:  Crow Moon    A collection of fantasy short stories.

Celia Hayes:  Luna City 11th Inning Stretch        The ongoing saga of the wacky adventures of a world-class chef in a small Texas town.

Sarah Hoyt:  Bowl of Red        The ongoing story of shape-shifters running a diner in Colorado.

Here's a couple other authors whose works you may enjoy.

Alma Boykin (my favorite author)

Peter Grant

Dorothy Grant  (yes, they're a couple)

J. L. Curtis

And of course, Larry Correia, the mountain who writes.

Listack, a flat programming language

 I'm working on yet another new programming language.  After the success of Falsish, a False derivative with elements of Fish ><> enabling both global (upper case) and local (lower case) variables, with a stack of stacks enabling local scope, I wanted to make something better.  Or at least easier to read.  (False was made to be an obfuscated esolang.  It wasn't the first, but it did kick off the movement, as it happened at the beginning of the internet era.)  So I started working on something similar, but with a real parser to handle, you know, words, and not just individual symbols.

I worked on that a bit, and it worked well enough, but I wanted something more.  Something different.  Stack based concatenative (Forth-like) languages have been done to death, because they are easy.  Factor looks intriguing, but its on-line documentation is, well, so thorough and detailed as to be unreadable.  And then I ran across a video on Stackless Python.  (Abandoned in favor of PyPy, apparently.)  The language implementation is more or less flat, without using the call stack to handle procedures calls and returns.  It claimed to be easier to use for advanced functions like concurrency.  EVE Online uses it to handle tens of thousands of simultaneous users.

Well, that certainly did sound different.  A challenge!  But how to implement it?  At about the same time, I read something about a stack based pure functional language that took as its arguments the program and the data stack, and returned a new data stack and program for every function call.  While this seemed inefficient, it had potential.  After all, a program is basically a list of past outcomes, future commands, and the current command as "now".

So that's what I am building.  I've done a few technical demonstrations, and gotten them working.  The key, as usual, is to make things simpler.  Always simpler, never more complex.  It's working spectacularly.  Whenever something seems difficult, I take a break, and the correct, simple way eventually comes to me.  I'm still refining, because this method of language implementation has opened up so many broad areas to explore.

Listack (current working name, because it uses lists and stacks) is a flat language.  It operates purely on a loop with a few context variables.  It does not call itself.  It is not, in and of itself, recursive.  It supports recursion, of course.  (While loops are implemented as recursion, for example.)  How does it work?  The past is a stack, with the most recent data on top.  Future commands are a queue, with the next one to be executed at the front.  Moving items from the future queue to the past stack and back is trivial, but the key to how everything works.  Listack is implemented as two deques, one for the past stack and one for the future queue.  The present is a single variable called current.  (There is also a deque of deques to implement local scope by saving versions of the past.)

The only real control flow operator in the language is IF.  All IF does is to delete one of two items, based on a boolean condition (true or false).  If the condition is true, it deletes the second item.  if false, the first.  That's all you need to implement control flow.  Well, that and a bit of meta programming to move elements around.  (I'm using ALL CAPS to show commands.)

In postfix notation, if works like this: 

        condition [do if true] [do if false] :IF

With the flat implementation, I can also implement a prefix version: 
        IF: [condition] [do if true] [do if false]

And infix, which seems easiest to read: 
        condition IF [do if true] [do if false]

With if, we can create while.  The begin gets added so we can implement continue and break in the body of the while.

original postfix: [condition] [body] :WHILE
becomes:  condition [body BEGIN [condition] [body] :WHILE] NOP :IF

prefix:  WHILE: [condition] [body]
becomes:  IF: [condition] [body BEGIN WHILE: [condition] [body]] NOP

infix:  [condition] WHILE [body]
becomes:  condition IF [body BEGIN [condition] WHILE [body]] NOP

And the best part is that I can have all three styles by just implementing the postfix version, then using meta programming to move the arguments around.  I can easily implement most commands with a prefix, infix, and postfix variant.  It's a bit tedious, but not complicated.

Procedures/functions are merely variables whose [contents] can be executed.  Of course, that's technically true of all variables, as the meaning of '5' is to push the number 5 onto the stack.

I could implement a local scope for commands , in addition to data.  I'm still considering that.  It's not like it would be difficult.  I'm just not sure of how or why to use it, and what it should look like.  Since local scope for the data stack is N(), perhaps the command queue should be N{} ?  (N is the number of items to push to the new deque from the old.  When the scope is closed, the remaining items get pushed back onto the old deque.)

I can also make the meta-programming routine available as a function in the language, so the user can create their own control flow commands.  FOR isn't complex at all.  It's just a while with some initialization beforehand and a regular change that gets tacked onto the body.

prefix:  FOR: [init] [condition] [change] [body]
becomes:  init WHILE: [condition] [body change]

You want it to look different?  Customize it!
infix:  FOR [[init] [condition] [change]] DO [body]       (Note: DO is pure syntactic sugar)
becomes:  init [condition] WHILE [body change]

You want a for-like until?
infix:  init DO [body] UNTIL [condition] [change]
becomes:  init body [condition] WHILE [change body]

Happy Thanksgiving!

Happy Thanksgiving to one and all! 

I'm a turkey.  Eat me!

Always remember that the first Thanksgiving feast was when the surviving Pilgrims (not many, most present were relatively new arrivals) gave thanks to God for teaching them the errors of socialism, and for providing the bounty of each individual family's efforts.

Please help them out

Two good men both need your financial help.

Lawdog needs money to pay for his legal defense from trumped-up charges by a Leftist DA with an axe to grind.

https://www.givesendgo.com/LawDog

Big Country Expat needs money to fund the legal team to sav e his granddaughter from her crazy mother and abusive, junkie father.

https://www.givesendgo.com/SaveAdrianaGrace

Please find the time to scrape together a few bucks to help them out.

Falsish esolang

 Okay, I'm a junkie.  I like making esoteric programming language (esolang) variants.  I was focusing on Subleq, but have moved my sights along to False now.

False is one of the earliest purpose-built esolangs, dating back to 1993.  You can learn more about it here.

Anyway, I was also interested in the capabilities of the fish ><> esolang.  Especially how it could create new stacks.

So, I added the new stack capability to False, along with making a new local variable list with each stack.  That meant I also had to add a new way to have global variables.

I think I succeeded in my task.  For what it's worth, it was fun and educational.  After I gave up on the first misguided and overly complicated attempt, that is.  Wow, what a difference building the right foundation makes.  😊

You can find out more about Falsish here, and download the Python code from here.

Here is a sample program, written in Falsish:

{Factorial}
[$1=~[$1-F;!*]?]F:
5$F;!
\"Factorial of "." is: ".10,

No amnesty. Not now, not ever.

The Left is requesting "amnesty for me, but not for thee." Here is a quote from the Atlantic article.

"We have to put these fights aside and declare a pandemic amnesty. We can leave out the willful purveyors of actual misinformation while forgiving the hard calls that people had no choice but to make with imperfect knowledge."


Always remember that, to the Left, the truth is "misinformation".  

It's amusing that they actually believe that opinions have a completely random relationship to the truth.  

"Given the amount of uncertainty, almost every position was taken on every topic. And on every topic, someone was eventually proved right, and someone else was proved wrong. In some instances, the right people were right for the wrong reasons."

The Broken Science Initiative

 William Briggs, "Statistician To The Stars" is one of my daily blog reads.
This is worth your time.

The biggest problems in science today are:
Big money
The expansion team effect
Expertocracy
Scientism
Scidolatry
https://www.wmbriggs.com/post/43158/
https://youtu.be/-t5lHXAvuLQ

https://brokenscience.org/

And the Nobel Prize for physics goes to...

 Alain Aspect, John Clauser, and Anton Zeilinger for their work in proving Bell's Theorem.

Of course, Bell's Theorem proves nothing, but that is beside the point.

Bell's Theorem ignores the probabilities of the outcomes happening, applying an equal probability to each - but only for the "classical" side of the argument. It therefore assumes it own conclusion, and then forces that to happen. When you assume that particles don't behave in the way they are known to behave, and then rigorously test them, of course they behave otherwise! 

Let me make an analogy: I hold in my hand a rock. When I toss it up, it may: 

1. Keep going up forever. 
2. Slow down and eventually stop.
3. Slow down then accelerate downwards. 

There are three possible outcomes, so each has probability 1/3. But wait! I imagine a fourth outcome.

4. Accelerate upwards ever faster. 

Now there are four possible outcomes, each with probability 1/4. But wait!  I imagine a fifth outcome.

5.  The rock will disappear in a puff of purple smoke.

Now there are five possibilities, each with a probability of 1/5.  That's logic!  And if I test it by actually throwing a real rock, and any outcome happens more than 1/5 of the time, then the world is inherently random and illogical, and the underlying science is inherently unknowable.

Do you see the error in this argument? I sincerely hope you do. Because this lies at the very heart of Bell's Theorem, and is the entire basis for his famous inequality.

More Bell's Inequality nonsense

 The YubTub channel 'Sixty Symbols' just did a video on Bell's Inequality.  There are quite a few of these out there.  They're all correct, as far as following the logic of Bell's Theorem goes.  That logic, however, is ridiculously bad.

Bell's Inequality (the essential point of Bell's Theorem), by the way, is the "proof" that quantum systems are inherently random, that entangled particles communicate instantaneously, and a several other bits of nonsense.

I now create a parody of the argument that Bell makes, using the exact same logic he employs, to point out the rampant silliness:

Let us suppose that I am standing on a basketball court, ball in hand.  I am at the three point line, and try to make that shot.  Logic states that I will either score, or miss.  This is a binary solution, with only two possible outcomes.  A 50/50 situation.  But when I actually try to do this, I only manage to score once in 50 tries.  That's a 2% probability.  2% is much less than the 50% predicted.  Contradiction!  Paradox!  Basketball is inherently illogical!

I'm not kidding.  That is the essence of Bell's Theorem, one of the fundamental papers in quantum science.

Summary in one meme

 

The truth in one meme.  A succinct summary of the current era.

Neil Oliver says "Take back our money!"

 Remember my post about how modern banking works?  (Banks create money out of nothing, then charge you interest on the loan that has to be paid back with real money.)  I'm not the only one concerned about this travesty of bankers profiting off us no matter what.  Neil Oliver has something to say about it.

Quantum Tunneling

Quantum tunneling works because the barrier is also made of particles whose location is not fixed. Sometimes, the barrier particles aren't there to block the tunneling particle, and it escapes. Think of a jail break from a prison where the guards are numerous and on random patrol schedules and routes. Every once in a while, if you get lucky and time it just right, you can walk out while all the guards just happen to be absent or looking the other way.  The more guards there are, the less likely this opportunity is to occur.

No hocus, and certainly no pocus, required.

Good advice

When dealing with law enforcement:

Deny, deny, counter-accuse, stand on your rights.

Never tell nobody nothing!

Song of the day

 I haven't heard this on the radio in ages.  It used to be quite popular.

On Canceling Debt and Modern Banking

With regards to Joe the Usurper canceling some student debts:

You have to understand how modern banking works, especially at the federal ("We own the printers") level. It costs them nothing in the short term to cancel debt.  That doesn't mean they won't still raise your taxes, though.

Debt is money created out of nothing. It's an entry in a spreadsheet. When you pay it off, the money returns to being nothing, a '0' in the spreadsheet. Only while the debt is active does the money exist. The trick is that you have to pay real money as the interest. When debt is canceled, the bank loses nothing but the income stream of interest payments.

Paying off debts is deflationary. The money is returned to sender and destroyed.  Canceling debts is inflationary, because the money isn't destroyed. It's still out there, being traded around.  It's exactly the same as printing money and handing it out. Okay, well, to be honest, it's the issuance of the debt in the first place that is inflationary. But if the money isn't zeroed out again through repayment, it is a permanent net increase in the money supply, making the rest of the currency worth just that bit much less.

Ah, the joys of modern banking.  What, you thought that the banks could only lend out money they actually had on deposit?  Silly citizen, that hasn't been the case for decades.  

In traditional fractional reserve banking, if a bank maintained a 5% reserve, they could lend out 95% of total deposits.  In modern fractional reserve banking, they can lend out 19 times their total deposits.  And if you put the loaned money back into a bank account, it counts as a deposit.

As an item of curiosity, the current mandatory reserve rate is: zero.  Banks can create all the debt money they like, with no limit.  They're just numbers on spreadsheets, after all.  Until the Fed monkeys around with the reserve percentage, forcing small banks to call in their loans, bankrupting small businesses.  (Anybody else remember 2008?  This is what really happened then to collapse the economy.  And when small banks couldn't meet the new, higher standard, the Fed forced them to sell out to the big banks.)  (Never forget that the 2008 recession was a choice the government made.  It didn't happen by accident.)

More on why Bell's Theorem is bunk

Bell's theorem utilizes mathematical sleight of hand to "prove" its point.  It uses probabilities to describe the "real" inequality, but the square roots of probabilities to describe the "quantum" equation.

Reference the Wikipedia article.  This is the inequality for "real" locality.

These are probabilities, each of which has a value of +1 or -1, so at most 1+1+1-1 = 2.  Seems straight forward so far.

Then the theorem goes on to derive the quantum formula for the same system.

This looks legit, except for one problem.  The 1/√2 is not a probability, but the square root of a probability.  (In QM, the coefficients are squared to get rid of imaginary numbers, and these squares add up to 1.)  So when we square them to get the actual probability, we get 1/2 for each.  1/2 + 1/2 + 1/2 - 1/2 = 1, which is less than 2.

How has this glaring error gone unnoticed for decades?

The "proof" for the three test system is even dumber.  It sets up a two state system with three possible inputs, for a total of 9 possibilities, then goes on to show that once you remove four possibilities, the remaining 5 cannot be evenly divided by two.  It's utter twaddle.They are always opposites, but only when measured on the same axis. 

Create two measuring systems, each with three axes spaced evenly about the center.  Test A in one and B in the other.  If you measure both A and B along axis 1, they will be true and false (or false and true).

If you measure A on axis 1 and find it to be true, what is the chance that B will be true on axis 2?  Axis 3?  50% each, obviously, since they are both evenly spaced from axis 1 and each other, and B must be true in some axis other than 1.

Creating a "test" that ignores the probabilities of events and only counts possible outcomes is silly, not to mention disingenuous.

A year ago

 History may not repeat, but it often rhymes.

Why Bell's Theorem is bunk

  First off, you need to know that Bell's Theorem purports to prove that for quantum mechanics to be true, local realism must be false.  More precisely, that entangled particles communicate their states to each other faster than light.  This is simply wrong.

  Background:  Quantum particles are really waves.  The wave function is the basis of QM.  It shows how the probability of a particle being in some state evolves over time.

  Entangled particles have opposite properties.  When treated as waves (which they are), their phases are 180 degrees (pi radians) apart.

  Probability:  Our knowledge of what state something is in, expressed through statistics.  In QM, probability is expressed as a sum of square roots.  If a particle can have two states, "heads" and "tails", and each state shows up 1/2 of the time, their probabilities are expressed as: (1/√ 2) + (1/√ 2).  Rant:  The main problem with the Copenhagen Interpretation of QM is that they believe the probabilities are the actual particle, and that the coin can really be heads and tails at the same time until you look at it.  In other words, they mistake the map for the territory.

  Bell's Theorem (AKA Bell's Inequality):  For a decent explanation of this, watch the "Looking Glass Universe" series of videos on the topic here.  Fun, isn't it?  Basically, Bell's Theorem states that for local realism to hold, you count up the states a particle can be in, compare it to the QM derived probability, and you'll find that the QM probability is greater that local realism allows.  Experiments prove this.  (More background:  the EPR paradox.)

  Fault in Bell's Theorem:  It's completely stupid to treat analog sine waves as digital square waves.  Bell's Theorem ignores the simple fact that outcomes have different probabilities of occurring.  Looking Glass Universe has a video that indirectly shows this here.  

  When you measure a particle, the particle interacts with the measuring device in some statistically significant way.  Measuring always changes a particle's properties.  So, when you measure spin, the only possible results are up and down.  (These are short hand terms for right handed and left handed spins, by the way.  They come up because they way the testing device works makes electrons either go up or down, based on their spin.)  However, the probability of getting spin up isn't always 50% (1/√ 2).  It's based on the state of the electron and the state of the testing device.  The more the electron's spin is pointed off the axis of the apparatus, you have a smaller chance of getting an "up" result, and a larger chance of getting a "down" result.  Because these are waves interacting in a probabilistic fashion.  For a demonstration, watch Minutephysic's video here.

  The flaw is simple.  Sine waves are not merely on or off, positive or negative.  They have a continuously changing phase.  If you measure it crudely, you will get a result of positive or negative.  But that's ignoring a lot of information about the wave.  Look at the images below, and see if you can tell the difference between a sine wave and a square wave.  (Hint:  The sine wave is analog, where the square wave is digital.)

Images from Wikipedia

  The fundamental error shown with a very simple example to make it more obvious:  Assume that you have an unfair coin.  Heads shows up 1/3 of the time, tails 2/3.  If you toss the coin twice, how often would you expect to see heads come up twice?  1/3 * 1/3 = 1/9.  How often would you expect to see tails come up twice?  2/3 * 2/3 = 4/9.  But if you simply lay out a table of all possible outcomes (because outcomes are all you can measure), it shows two heads 1/4 of the time and two tails 1/4 of the time: equal probabilities!

     Flip 1        Flip 2
    Head          Head
    Head          Tail
    Tail            Head
    Tail            Tail

  Bell's Theorem does not rule out local realism.  It rules out analog being digital, which is true by definition.  Quantum coins are not fair.

  The map is not the territory.

Edit:  Here are two videos giving a very clear and comprehensive view of Bell's Inequality.  It should be obvious where the problem lies - when you assume that all probabilities are always equivalent (the a-b-c chart in the first video), you're describing a square or triangle wave, not the sine waves of reality.

Motion

To get the right answers, you must ask the right questions.  In this case, the question is not, "How does Relativity work?  What is it?"  The right question is "How does motion work?  What is it?"

Motion is caused by a standing wave in spacetime, because it must be.  Einstein showed that if two things are indistinguishable, then they are identical.  (Which is also generally considered to be common sense.)

If relativistic effects are caused by both motion and by gravity, then these two effects must have the same cause.  That cause is the stretching of spacetime.  It really is this simple in concept.

I can't draw, so I'll "borrow" an internet picture about the Alcubierre drive (which can't work for incredibly obvious reasons now that we've proven the existence of gravity waves moving at the speed of light).

Stolen shamelessly from trekmovie.com

This is how motion and special relativity work.  The particle is somewhere in the center region.  Spacetime is warped around it as a standing wave.  Relativistic effects depend on the warping, which depend on the angle you're viewing it from.  Don't forget that you have your own warped spacetime, so you have to adjust for that.  The math is no more difficult than high school trigonometry, because the theory of relativity is nothing more than the very careful application of the Pythagorean theorem of right triangles.  (A squared plus B squared equals C squared.)  Things going forward (right) gain energy from the gradient (blueshift).  Things going backwards (left) lose energy to the gradient (redshift).  Things going exactly sideways don't change at all.

Please remember that this is a 2.5 dimensional picture of a 3 dimensional effect.  The faster the object moves, the more the field will be tilted/warped around it.

If two objects are moving at the same speed in the same direction (at relative rest), they will not see any relativistic effect, because the losses for one are exactly cancelled by the gains in the other along the straight line between them.  Any change in speed or direction by either body will show a relativistic effect, because then the two bodies are no longer at rest relative to each other, and the math no longer cancels out to zero.

Note that spacetime is a field of potential energy governing motion.  The gradient is literally distance over time.  Note that space is flat/Euclidian (a^2 + b^2 = c^2), while time is hyperbolic (a^2 - b^2 = c^2).  This complicates the math in general relativity, but you can more or less ignore it when dealing solely with special relativity.

Special side note - A particle's spin rate is internally constant, no matter its speed, no matter the local strength of gravity.  This means that spin self adjusts to exactly match relativistic effects.  This strongly suggests that spin is, in effect, an expression of time.

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))

The basis of physics

1.  Total energy is a constant at every point.

2.  There is no such thing as negative energy.

3.  Spacetime is a field of potential energy.

Everything else follows.

Black holes are hollow spheres of maximal energy density/zero potential energy.  There is nothing inside them.  There are no singularities.  There are no infinities.  There are no contradictions.

The spacetime gradient is a change in distance divided by a change in time.  It's literally motion and acceleration.

Oh, I almost forgot.  Rule zero:  Everything except energy sums to zero.  (Even energy sums to zero if our antimatter/negative energy counterpart universe is moving away from us on the opposite end of the conic section.)

More thoughts on the ice cream cone universe

 So, if the universe really is ice cream cone shaped...

Space is a sphere, indicated by the circle on the cone.  Time is a hyperbola, perpendicular to the circle (as all dimensions should be perpendicular).

If the universe really is expanding, then the circle is getting bigger and moving up the cone.  Assuming the foci of the hyperbola are the centers of the circles, that means the hyperbola's modulus must also be getting larger.  This could be the explanation for galactic redshift.  It's not space stretching, but time.  The photons are running uphill over the long stretch (heh) of time.

Does that mean that the big bang happened at the center, and our universe went one way, while the antimatter universe went the other?  This would match up with physics rule zero, that postulates that everything except energy adds up to zero.  Huh.  This makes just a bit too much sense, and is a little too simple.

Subleq Plus

I got the Subleq+ compiler and interpreter working.  They're posted on GitHub.  This is a huge advance over hand jamming the physical addresses.  Many thanks to Chris Lloyd for the basis of the system.  The parser is still mostly his code.

Subleq is a single instruction computer.  That instruction consists of three words, A B C.  The function is [B] = [B] - [A]; if [B] <= 0, jump to C.  "[x]" means the contents of memory at location x.  As limited as it seems, you can theoretically do anything with a computer like this.  It just takes longer.

Why am I interested in this?

1. I'm a geek.  If that wasn't obvious by now, you haven't been paying attention.
2. Subleq reminds me of a programming project I found in a magazine for the Commodore-64 back when I was a kid.  There was some toy language that only had two instructions:  Increment an address by one, and decrement an address by one and jump if it was zero.  I played around with that for weeks.  Good times.  Happy memories.
3. This has gotten me back into programming for the first time in almost 30 years.  I actually went to college for programming back in the early 90's.  I dropped out (the second time) when I noticed that I, as a Junior, was helping the grad students with their projects.  I also saw that my friends were having trouble finding local jobs in the field, as the industry was leaving Ohio and moving to California at the time.  I just lost interest and motivation.
4. Being partially disabled and mostly stuck at home, I have a lot of time on my hands and I get bored.  This is a nice challenge.

So, where to go from here?  I could adapt the system for OISC:2.  But I would want to update the design to accommodate some of the new ideas I've had for OISC:3.  Negative memory references actually to go negative memory, where they are automagically redirected.  OISC:3 will use a stack, and the program counters, etc, won't be in addressable memory.  Input and output will also be stack commands.  This, of course, won't work well for OISC:2, because of the constraints of the language.  So I think I'll just leave it alone, and maybe adapt the parser to it.  Oh, and I'm renumbering the mode commands to use negative numbers, because I like the symmetry of having things like addition/subtraction, multiplication/division, power/log, sin/asin and or/xor having opposite signs.

Is a stack too much power for an esolang like this?  If course it is!  Could it take some of the challenge of using a language like this away?  Of course it can!  But that's not really the point, is it?  It's not to use the language so much as to create a usable language.  And it still doesn't have an explicit instruction.  It's all just data and memory locations.  But then, that's all computers really are.

Esolang OISC:2b

Obfuscated Indirect Subleq with Coprocessor
2 word instructions
version b

I finally have a working emulator for OISC:2b that accepts positive and (optional) negative memory files.  The coprocessor has been improved.  Positive memory is loaded as integers only.  Jumps to negative memory Halt.

Two word instructions:  A B

If A & B are both positive: [B]=[B]-[A]
If A & B are both negative: [[B]]=[[B]]-[[A]]

If A is positive and B is negative: IF [A] <= 0 Jump |B|
If A is negative and B is positive: IF [[A]] <= 0 Jump B

If A is 0 and B is positive: STDIN -> [B]
If A is 0 and B is negative: STDIN -> [[B]] 

If A is positive and B is 0: [A] -> STDOUT
If A is negative and B is 0: [[A]] -> STDOUT

If A & B are both 0: HALT

Negative memory can be addressed by indirection, but instructions are only in positive memory.

Negative Memory
Address        Function
-1                IP (initially 0)
-2                NEXT (always IP+3)
-3                RETURN (initially 0, set to NEXT before any jump.)
-4                Register a
-5                Register b
-6                Register c
-7                Mode (activates a, b, c; then resets to 0)
-8                MaxPos memory size
-9                MaxNeg memory size
-10...           Data (address: start from 0, add 10, negate)

Coprocessor
Mode    Function
0          NOP
1          c = ~b (bitwise not)
2          c = b & a (bitwise and)
3          c = b | a (bitwise or)
4          c = b ^ a (bitwise xor)
5          c = b << a (shift b left by a bits)
6          c = b >> a (shift b right by a bits)
7          sign of b   (+1, 0, -1)
8          floor of b (integer)
9          truncate b (round down, integer)
10        c = b - a
11        c = b + a
12        c = b * a
13        c = b // a (integer division)
14        c = b % a (mod, integer remainder)
15        c = b / a
16        c = b to power of a
17        c = a root of b
18        c = log base b of a
19        c = sin(b)
20        c = cos(b)
21        c = tan(b)
22        c = asin(b)
23        c = acos(b)
24        c = atan(b)
25        c = sinh(b)
26        c = cosh(b)
27        c = tanh(b)
28        c = asinh(b)
29        c = acosh(b)
30        c = atanh(b)
31        c = sqrt(b**2 + a**2)  (hypotenuse)
32        a = pi, b = e, c = phi (golden ration)
33        c radians <-- b degrees
34        c degrees <-- b radians
35        c = greatest common divisor of b and a
36        c = a permutations of b items (unique)
37        c = a combinations of b items (not unique)
38        c = b! (factorial)
39        c = sum of 0..b (integers, works with negatives)

Esolang OISC:3d

Updated:  18 April 2022

No, I can't leave well enough alone.  I think we've established that by now.  This one might be more useful.  Too useful?  Negative addresses were a pain in the previous versions, and most instructions aren't indirect, so I've swapped functionality to simplify the interpreter.  It should also make programming easier and negative memory much more useful.  Note that memory address 0 is still impossible to directly address.  

Positive memory is loaded as integers only.
A jump to negative memory Halts & Fails.

Instruction    Function
A B C            [C] = [B] - [A]
0 B C            If [B] <= 0, Jump to C//[-C]
A 0 C            If [A] <= 0, Relative jump by C
A B 0            [[B]] = [[B]] - [[A]]  (indirect addressing)
A 0 0            Input [A] as character
0 B 0            Output [B] as character  (if [B] < 0, Halt & Fail)
0 0 C            Output [C] as number
0 0 0            Halt & Succeed

Address        Function
-1                IP (initially 0)
-2                NEXT (always IP+3)
-3                RETURN (initially 0, set to NEXT before any jump.)
-4                Register a
-5                Register b
-6                Register c
-7                Mode (activates a, b, c; then resets to 0)
-8                MaxPos memory size
-9                MaxNeg memory size
-10...           Data (address: start from 0, add 10, negate)

Mode    Function
0          NOP
1          c = ~b (bitwise not)
2          c = b & a (bitwise and)
3          c = b | a (bitwise or)
4          c = b ^ a (bitwise xor)
5          c = b << a (shift b left by a bits)
6          c = b >> a (shift b right by a bits)
7          sign of b, +1, 0, -1
8          floor of b (integer)
9          truncate b (round down, integer)
10        c = b - a
11        c = b + a
12        c = b * a
13        c = b // a (integer division)
14        c = b % a (mod, integer remainder)
15        c = b / a
16        c = b to power of a
17        c = a root of b
18        c = log base b of a
19        c = sin(b)
20        c = cos(b)
21        c = tan(b)
22        c = asin(b)
23        c = acos(b)
24        c = atan(b)
25        c = sinh(b)
26        c = cosh(b)
27        c = tanh(b)
28        c = asinh(b)
29        c = acosh(b)
30        c = atanh(b)
31        c = sqrt(b**2 + a**2)  (hypotenuse)
32        a = pi, b = e, c = phi (golden ration)
33        c radians <-- b degrees
34        c degrees <-- b radians
35        c = gcd(b, a)  (greatest common divisor)
36        c = a permutations of b items (unique)
37        c = a combinations of b items (not unique)
38        c = b! (factorial)
39        c = sum of 0..b (integers, works with negatives)