DESI results don't favour a cosmological constant but a varying quintessence of some form.

The DESI results using Baryon Ascotic oscillations together with supernova spectrum to find galaxy velocity, seem at (3.4 Sigma) not to favour the cosmological constant but an dark energy or quintessence that reduces with time. Combined results have the equation of state parameter as 0.86 +.10 -.11. Zheng et al in https://arxiv.org/abs/2412.04830 Remember our axial force modelled qunintessence as a neutrino dark energy caused by the attractive force between neutrinos, which we estimate an equation of state or owega of 17/18 or 0.94444.

Recent Paper looks for Lepton Axial force in solar oscillations.

In https://arxiv.org/abs/2412.10724 Fang et al, look at how the matter effect on an lepton axial force world effect neutrio oscillation, and provide a strong exclusion g_vv g_A <10^-51. However they assume that all protons and neutrons have exactly the same axial force interaction. Because of conversation in beta decay we must have Q(n)=1+Q(p) so neutons and protons might have opposite charges .e.g 1/2 escaping Fangs, bounds. With photons and neutrons being oppositely charged to oscillation measurement might be very changed, and also if matter is net uncharged due to a background of slow neutrinos in matter.

Neutron Lifetime Puzzle

The neutron lifetime puzzle is that neutrons in beam have a lifetime of around 887 sec, while neutrons trapped in a magnetic bottle have a lifetime 1% less of around 877 secs. In https://arxiv.org/pdf/1906.10024 Giacosa and Pagliara suggest resolving this through the quantum zero effect, to do so some new physics must be observing or interacting with the neutron in a bottle, every billionth of a second. Consider a neutrino background interacting with the axial force with strength 1/10000, we might have 1*10^17 neutrinos per cubic centimeter and the range might of the force might be 5nm. I each 5nm cubic there would be = 0.01 neutrinos, but they would be travelling new light speed, so in 10^-9 secconds, about 0.3 would pass. Giving approximately the correct amount of lifetime reduction, and better a good fit if the density was 3 time larger at 3*10^17 neutrino. Experimentally this could be confirmed by having a magnetic bottle far neutron or proton rich material to reduce the neutrion background. A magnesium 24 magnetic bottle held in a vacuum in a large room might remove a lot of the neutrion background, leaving the results near the beam decay rate. Indeed such neutron decay in a magnetic bottle might be a excellent detector of the density of a neutrino background.

The New FASER experiment at CERN has muon neutrino interaction results at the high side of the error wide.

The FASER experiment has just published its muon neutrino interaction results. https://arxiv.org/pdf/2412.03186

It detected more interactions, 362 and expect 322, but just within the error bound of +/- 50.5 Could these high end extras be from our extra force?

The excess looks like its is in the middle low energy range for muon neutrinos but not muon anti neutrinos. The medium for the transport of the neutrinos is 100Km of rock and concrete which for us. we might have a background neutrino density of neutrinos. Could the high energy neutrino be pair producing extra medium energy neutrinos here at 1/alpha_nu * background density and then the anti-neutrino attraction to neutrinos scattering the anti-neutrinos more than the neutrinos.

Bounds on NSI from COHERIANT and other experiments

A new paper, by V. Romeria et al, https://www.arxiv.org/pdf/2411.11749 has some bounds on NSI's Ranging from G_A <10^-3 to G_A <10^-5 for Axial forces that are electrophobic.

Benchmarks for Vectorised Simpsons Rule

On a 16 Thread Ryzen 7. It came in slightly slower. My Global Warming Infrared Attention code, took, 2h 59m 23s non vectorised, and 3h 4mins and 42 seconds, vectorised.

A Vectorised Simpsons Rule for JDK 23

If you are doing numerical integration in Java, try this code on the latest JDK 23, it using the new Vectorisation methods for a faster result.

import jdk.incubator.vector.DoubleVector;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

// Release Candidate Version, package will change in Release Version, true for JDK 23
import  jdk.incubator.vector.DoubleVector;
import jdk.incubator.vector.VectorOperators;
import jdk.incubator.vector.VectorOperators.Operator;
import jdk.incubator.vector.VectorSpecies;

import static jdk.incubator.vector.VectorOperators.ADD;


public class SimpsonsRuleVectorised {



    private static double third = 1.0/3.0;

    private static int THREADS = 16;

    public static double integrateThreaded(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        ForkJoinPool pool = new ForkJoinPool(THREADS);
        double d[] = new double[N];

        for(int i=0; i {
                double mul = ii%2==0? 2*third: 4*third;
                if (ii==0) { mul = third; }
                if (ii==N-1){ mul = third; }
                double mul1 = mul;
                double x = a + h * ii;
                double fi = f.eval(x,ii, params);
                if (Double.isNaN(fi) ){
                    System.err.println(f.getClass().getName() + "IS NaN at "+x);
                }
                d[ii] = mul1*fi;
            });
        }
        try {
            pool.shutdown();
            if (!pool.awaitTermination(1, TimeUnit.HOURS)){
                pool.shutdownNow();
            }
        } catch (Exception e){}
        DoubleVector doubleVector = DoubleVector.fromArray(DoubleVector.SPECIES_64, d, 0);
        double sum = doubleVector.reduceLanes(ADD );

        return sum * h;
    }

    public static double integrate(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        double fa = f.eval(a,0, params);
        double fb = f.eval(b, N-1, params);
        if (Double.isNaN(fa) ){
          System.err.println(f.getClass().getName() + "IS NaN at "+a);
        }
        if (Double.isNaN(fb)){
            System.err.println(f.getClass().getName() + "IS NaN at "+b);
        }
        // 1/3 terms
        double sum = third * (fa + fb);


        // 4/3 terms
        for (int i = 1; i < N - 1; i += 2) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            sum += 4.0 * third * fx;
        }

        // 2/3 terms
        for (int i = 2; i < N - 1; i += 2) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            sum += 2.0 * third * fx;
        }

        return sum * h;
    }

    public static double integrateConsecutive(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        double fa = f.eval(a,0, params);
        if (Double.isNaN(fa) ){
            System.err.println(f.getClass().getName() + "IS NaN at "+a);
        }

        // 1/3 terms
        double sum = third*fa;


        // 4/3 terms
        boolean isOdd = true;
        for (int i = 1; i < N - 1; i += 1) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            if (isOdd) {
                sum += 4.0 * third * fx;
            } else {
                sum += 2.0 * third * fx;
            }
            isOdd=!isOdd;
        }


        double fb = f.eval(b, N-1, params);
        if (Double.isNaN(fb)){
            System.err.println(f.getClass().getName() + "IS NaN at "+b);
        }
        sum = sum+ fb*third;

        return sum * h;
    }

    public static void main(String args[]){
        // Roots of polynumerial to integrate
        List in = Arrays.asList(-0.9, -0.8,-0.7, -0.6,-0.5, -0.4, -0.3, -0.2, -0.1, 0, .1,.2,.3,.4,.5, .6,.7, .8, .9 );
        DoubFunction func = new DoubFunction() {
            @Override
            double evalInner(double x, double[] params, int i) {
                return in.stream().map(y->y.doubleValue()-x).reduce(1.0,(a,b)->(a*b));
            }
        };
        double consec=0;
        long startConsec = System.currentTimeMillis();
        for(int i=1;i<1000; i++) {
            consec = integrateConsecutive(-1, 1, 100000, func);
        }
        double timeConsec = (System.currentTimeMillis() - startConsec)/1000.0;
        double standard=0;
        long startStandard = System.currentTimeMillis();
        for(int i=1; i<1000; i++) {
                standard = integrate(-1,1,100000,func);
        }
        double timeStandard = (System.currentTimeMillis() - startStandard)/1000.0;
        double threaded=0;
        long startThreaded = System.currentTimeMillis();
        for(int i=1;i<1000; i++) {
            threaded = integrateThreaded(-1, 1, 100000, func);
        }
        double timeThreaded = (System.currentTimeMillis() - startThreaded)/1000.0;
        System.out.println("Standard Integrator: "+standard+" time taken: "+timeStandard+" seconds");
        System.out.println("Consecutive Integrator: "+consec+" time taken: "+timeConsec+" seconds");
        System.out.println("threaded Integrator: "+threaded+" time taken: "+timeThreaded+" seconds");
    }

}

class AtomicDoubleLocal77 {
    private AtomicReference value = new AtomicReference(Double.valueOf(0.0));
    double getAndAdd(double delta) {
        while (true) {
            Double currentValue = value.get();
            Double newValue = Double.valueOf(currentValue.doubleValue() + delta);
            if (value.compareAndSet(currentValue, newValue))
                return currentValue.doubleValue();
        }
    }
}