AiAntiGravity

AI is accelerating discovery everywhere—from reading ancient scrolls with imaging + machine learning to optimizing complex physical systems. In every case, fine-tuning to achieve resonance is critical—and that’s where AI shines.

Speculative Concepts

Reports about devices like the “Graviflyer” describe counter-rotating discs, high-voltage differentials, Tesla-coil RF bias, magnets, and ultrasound. If such effects exist, they’re likely extremely sensitive to resonance—exactly the kind of multi-parameter tuning AI can search efficiently while logging evidence from scales, probes, and sensors. The same principle applies to the PAIS effect, where plasma acoustic interactions appear only when voltages and frequencies align in just the right way, and to the work of Thomas Townsend Brown, whose electrogravitics experiments suggested lift from high-voltage fields when tuned into resonance. In every case, resonance is the fragile key, and AI provides the systematic exploration needed to find and hold it.

Our Focus

My name is Bill SerGio and I made a large fortune using AI Neural Networks I wrote to automate the buying of half hour blocks of television time.
I thought I would demonstrate how you can apply ML.NET to explore parameter spaces in safely simulated or instrumented setups—adjusting voltages, frequencies, phases, and rotations to lock onto stable resonant regimes. Unlike Python toolchains that often require stitching together many external libraries, ML.NET is natively integrated into the .NET ecosystem, giving us type safety, performance, and seamless deployment in our C# applications. Backed by Microsoft, it allows our research code to move directly into production web apps and lab systems without rewrites, ensuring both speed and stability in experimentation.

AI Type #1 – Physical Feedback

AI measures changes in lift or weight on a precision scale and dynamically adjusts voltages, frequencies, and rotations in a real-time feedback loop to tune resonance and maximize anti-gravity effects.

AI Type #2 – Virtual Simulation

In this approach, the anti-gravity engine exists only in code. Components are modeled with physics-based formulas, and AI explores the parameter space virtually to discover resonant behaviors before any physical build is attempted.

AI Type #1 – Physical Feedback

AI Type #2 – Virtual Simulation

AiNetStudio – ML.NET Graviflyer Demo

Use ML.NET to model lift from parameters and suggest the next settings to explore resonance.

1) Data Model


// Models/GraviflyerReading.cs
using Microsoft.ML.Data;

public sealed class GraviflyerReading
{
    public float VoltageKV { get; set; }
    public float FrequencyKHz { get; set; }
    public float PhaseDeg { get; set; }
    public float RotationRPM { get; set; }
    public float UltrasoundKHz { get; set; }

    public float CurrentmA { get; set; }
    public float TempC { get; set; }
    public float Humidity { get; set; }
    public float Vibration { get; set; }

    [ColumnName("Label")] public float LiftGrams { get; set; }
}

public sealed class GraviflyerPrediction
{
    public float Score { get; set; } // predicted LiftGrams
}

2) Train with ML.NET (LightGBM)


// Services/ModelTrainer.cs
using System.Collections.Generic;
using Microsoft.ML;
using Microsoft.ML.Trainers.LightGbm;

public static class ModelTrainer
{
    public static (ITransformer model, DataViewSchema schema, RegressionMetrics metrics)
        Train(IReadOnlyList<GraviflyerReading> rows)
    {
        var ml = new MLContext(seed: 42);
        var data = ml.Data.LoadFromEnumerable(rows);

        var features = new[]
        {
            nameof(GraviflyerReading.VoltageKV),
            nameof(GraviflyerReading.FrequencyKHz),
            nameof(GraviflyerReading.PhaseDeg),
            nameof(GraviflyerReading.RotationRPM),
            nameof(GraviflyerReading.UltrasoundKHz),
            nameof(GraviflyerReading.CurrentmA),
            nameof(GraviflyerReading.TempC),
            nameof(GraviflyerReading.Humidity),
            nameof(GraviflyerReading.Vibration),
        };

        var pipeline =
            ml.Transforms.Concatenate("Features", features)
              .Append(ml.Transforms.NormalizeMinMax("Features"))
              .Append(ml.Regression.Trainers.LightGbm(new LightGbmRegressionTrainer.Options
              {
                  LabelColumnName = "Label",
                  FeatureColumnName = "Features",
                  NumberOfLeaves = 31,
                  MinimumExampleCountPerLeaf = 10,
                  LearningRate = 0.05f,
                  NumberOfIterations = 300
              }));

        var model = pipeline.Fit(data);
        var preds = model.Transform(data);
        var metrics = ml.Regression.Evaluate(preds, "Label", "Score");
        return (model, data.Schema, metrics);
    }
}

3) Propose Next Settings (Model-Guided Search)


// Services/CandidateSelector.cs
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML;

public sealed record Candidate(float VoltageKV, float FrequencyKHz, float PhaseDeg, float RotationRPM, float UltrasoundKHz);

public static class CandidateSelector
{
    public static IReadOnlyList<Candidate> ProposeTopN(
        MLContext ml, ITransformer model, int topN = 5,
        (float min, float max, float step) v = (5, 40, 5),
        (float min, float max, float step) f = (5, 200, 5),
        (float min, float max, float step) p = (0, 360, 15),
        (float min, float max, float step) r = (0, 4000, 200),
        (float min, float max, float step) u = (0, 40, 5))
    {
        var engine = ml.Model.CreatePredictionEngine<GraviflyerReading, GraviflyerPrediction>(model);
        var list = new List<(Candidate c, float predicted)>();

        for (var vv = v.min; vv <= v.max; vv += v.step)
        for (var ff = f.min; ff <= f.max; ff += f.step)
        for (var pp = p.min; pp <= p.max; pp += p.step)
        for (var rr = r.min; rr <= r.max; rr += r.step)
        for (var uu = u.min; uu <= u.max; uu += u.step)
        {
            var c = new Candidate(vv, ff, pp, rr, uu);
            var pred = engine.Predict(new GraviflyerReading {
                VoltageKV = vv, FrequencyKHz = ff, PhaseDeg = pp,
                RotationRPM = rr, UltrasoundKHz = uu
            }).Score;
            list.Add((c, pred));
        }

        return list.OrderByDescending(x => x.predicted).Take(topN).Select(x => x.c).ToList();
    }
}

4) Closed-Loop Runner (Apply → Measure → Learn)


// Services/ExperimentRunner.cs
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ML;

public interface IActuator
{
    Task ApplyAsync(float voltageKV, float freqKHz, float phaseDeg, float rpm, float ultrasoundKHz, CancellationToken ct);
}
public interface ISensor
{
    Task<float> ReadLiftGramsAsync(CancellationToken ct);
    Task<(float tempC, float humidity, float currentmA, float vibration)> ReadTelemetryAsync(CancellationToken ct);
}

public sealed class ExperimentRunner
{
    private readonly IActuator _actuator;
    private readonly ISensor _sensor;
    private readonly List<GraviflyerReading> _buffer = new();

    public ExperimentRunner(IActuator actuator, ISensor sensor)
    {
        _actuator = actuator;
        _sensor = sensor;
    }

    public async Task RunAsync(TimeSpan settleDelay, int cycles, CancellationToken ct)
    {
        var ml = new MLContext(seed: 42);

        for (int i = 0; i < cycles; i++)
        {
            ct.ThrowIfCancellationRequested();

            var (model, _, metrics) = ModelTrainer.Train(_buffer);
            Console.WriteLine($"R^2={metrics.RSquared:F3}, MAE={metrics.MeanAbsoluteError:F3}");

            var next = CandidateSelector.ProposeTopN(ml, model, topN: 3);
            foreach (var c in next)
            {
                ct.ThrowIfCancellationRequested();

                float V(float x) => Math.Clamp(x, 0, 40);
                float F(float x) => Math.Clamp(x, 0, 200);
                float P(float x) => Math.Clamp(x, 0, 360);
                float R(float x) => Math.Clamp(x, 0, 4000);
                float U(float x) => Math.Clamp(x, 0, 40);

                await _actuator.ApplyAsync(V(c.VoltageKV), F(c.FrequencyKHz), P(c.PhaseDeg), R(c.RotationRPM), U(c.UltrasoundKHz), ct);

                await Task.Delay(settleDelay, ct);

                var lift = await _sensor.ReadLiftGramsAsync(ct);
                var (tempC, humidity, currentmA, vibration) = await _sensor.ReadTelemetryAsync(ct);

                var row = new GraviflyerReading
                {
                    VoltageKV = V(c.VoltageKV),
                    FrequencyKHz = F(c.FrequencyKHz),
                    PhaseDeg = P(c.PhaseDeg),
                    RotationRPM = R(c.RotationRPM),
                    UltrasoundKHz = U(c.UltrasoundKHz),
                    CurrentmA = currentmA,
                    TempC = tempC,
                    Humidity = humidity,
                    Vibration = vibration,
                    LiftGrams = lift
                };
                _buffer.Add(row);

                Console.WriteLine($"Measured Lift: {lift:F3} g @ V={row.VoltageKV}, f={row.FrequencyKHz}kHz, φ={row.PhaseDeg}°, rpm={row.RotationRPM}, us={row.UltrasoundKHz}kHz");
            }
        }
    }

    public IReadOnlyList<GraviflyerReading> GetAll() => _buffer;
}

5) Hardware Stubs (replace with your drivers)


// Hardware/ActuatorAndSensorStubs.cs
using System;
using System.Threading;
using System.Threading.Tasks;

public sealed class StubActuator : IActuator
{
    public Task ApplyAsync(float voltageKV, float freqKHz, float phaseDeg, float rpm, float ultrasoundKHz, CancellationToken ct)
    {
        Console.WriteLine($"Apply: V={voltageKV}kV, f={freqKHz}kHz, φ={phaseDeg}°, rpm={rpm}, us={ultrasoundKHz}kHz");
        return Task.CompletedTask;
    }
}

public sealed class StubSensor : ISensor
{
    private readonly Random _rng = new(123);
    public Task<float> ReadLiftGramsAsync(CancellationToken ct) => Task.FromResult((float)(_rng.NextDouble() * 2.0 - 0.5));
    public Task<(float tempC, float humidity, float currentmA, float vibration)> ReadTelemetryAsync(CancellationToken ct)
        => Task.FromResult((22.0f, 40.0f, 10.0f, 0.0f));
}