Falsification of probability

[DANILIN]

Falsification of probability

exploring possibility of falsification of random
qbasic qb64 programs were created in an hour
and a table using formulas

= CASEBETWEEN(0;1 )
= IF (B3 = B2; C2 + 1; 0)
= COUNTIF (C$3: C$55000; D2)
= SUM(E2:E10)
= E2 / E3



idea: fake a 50% chance

results:

research E green pure excel:
randomly distributed naturally

research 0 yellow qb 0:
randomly distributed naturally

research 1 in red qb 1:
explicit fake equal number in a row

research 2 violet qb 2:
smart fake but not all programmed
and skew due to algorithm

Conclusion: identify fake random real

' 0.bas
OPEN "0.txt" FOR OUTPUT AS #1
FOR s = 1 TO 50000: PRINT #1, (INT(RND * 1000) MOD 2): NEXT
CLOSE

' 1.bas
OPEN "1.txt" FOR OUTPUT AS #1
FOR d = 1 TO 5: FOR s = 1 TO 100
FOR i = 1 TO s: PRINT #1, 1: NEXT
FOR i = 1 TO s: PRINT #1, 0: NEXT
NEXT: NEXT: CLOSE

' 2.bas
OPEN "2.txt" FOR OUTPUT AS #1
FOR k = 1 TO 100: FOR s = 1 TO 7
FOR d = 1 TO 2 ^ (7 - s)
FOR i = 1 TO s: PRINT #1, 1: NEXT
FOR i = 1 TO s: PRINT #1, 0: NEXT
NEXT: NEXT: NEXT: CLOSE

sequence fake shuffled
turns into a random sequence

and began to correspond to distributions



and excel more clearly than programs
but c# synthesis programs are possible online

using a random synthesis program
and dividing into small 0 and large 1
synthesized 55000 random and tested

despite normality of number of consecutive 0...7
a larger number in a row is not possible
therefore sequence is worse than usual rnd

'rndxx.bas
OPEN "rndxxx.txt" FOR OUTPUT AS #1

FOR i = 1 TO 55555: r = Rand
    IF r < 0.5 THEN PRINT #1, 0 ELSE PRINT #1, 1
    'IF r <= 0.5 THEN PRINT #1, 0 ELSE PRINT #1, 1
    'IF r <= 0.7 THEN PRINT #1, 0 ELSE PRINT #1, 1
NEXT: CLOSE

FUNCTION Rand: STATIC Seed
x1 = (Seed * 214013 + 2531011) MOD 2 ^ 24
Seed = x1: Rand = x1 / 2 ^ 24
END FUNCTION

in C# randomness is also low-power
I suppose understood by people as supposedly normal

using System;using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace Rextester
{ public class Program
    { public static void Main(string[] args)
        { Random rand = new Random();
for (int i = 1; i < 5555; i++)
{ var d = rand.Next(2);
if (d<0.5)
    Console.WriteLine("0");
     else Console.WriteLine("1");
}}}}

on-line compiler: https://rextester.com/WXH62544


significant reliable probability: shuffled
that is: 2-sided and that is: integraly probability


Program peretas.bas creates a sequence
random a: 0 and 1 by manual algorithm from Internet

and program creates random d: 0 ... 77777
for shuffling and sorting an array d array a is ordered
and perhaps against repetition it is better to shuffle cards 1000000

'peretas.bas
DIM a(55555), d(55555)

OPEN "aa.txt" FOR OUTPUT AS #1: OPEN "dd.txt" FOR OUTPUT AS #2
OPEN "aaaa.txt" FOR OUTPUT AS #3: OPEN "dddd.txt" FOR OUTPUT AS #4

FOR i = 1 TO 55555: r = Rand: a(i) = INT(r * 2): PRINT #1, a(i): NEXT
FOR i = 1 TO 55555: r = Rand: d(i) = INT(r * 77777): PRINT #2, d(i): NEXT

FOR i = 1 TO 55554: FOR j = i TO 55555
        IF d(i) > d(j) THEN SWAP d(i), d(j): SWAP a(i), a(j)
NEXT: NEXT

FOR i = 1 TO 55555: PRINT #3, a(i): PRINT #4, d(i): NEXT
CLOSE

FUNCTION Rand
STATIC Seed
x1 = (Seed * 214013 + 2531011) MOD 2 ^ 24
Seed = x1
Rand = x1 / 2 ^ 24
END FUNCTION

Theoretical values in Excel Excel via formulas

=C3/2
=D3+C4
=D4*55000

show: out of 55000 for 7 steps covered 54570
numbers in their sequences
and probably deviation betrays a false accident

and shuffling involved 54885 close to theory

Theoretical values in Excel Excel via formulas

https://www.youtube.com/watch?v=YIJmgOTnkTU&t=33

[DANILIN]

Check for randomness of digits of number of PI

Using 55,000 digits of pi
first in Word translated to column by replacement
Excel compiles formulas for dividing into:
even \ odd and small \ big

and then my tables are used
at same time comparing with theoretical separation

Results: average for both divisions: 0.5
and separation matches chance by true
and it’s still possible to shuffle
and it’s still possible to explore other constants and roots





Meaning of task: true chance for people is unnatural
and it is possible to synthesize low-power human probabilities

But if we are talking about overcoming chance
understanding wave of probability increases reliability

Probability waves increase reliability:
my development of past 10th anniversary

[DANILIN]

Invented by me at random algorithm of RNG
where is trigonometry used

check shows distribution is bad
comparing even\odd and small\large
but shuffling turns array into a normal one

I came up with an algorithm Blizzard at school
in last century even under old regime and in our century
about same too foreign called vortex

Blizzard algorithm: number 1 is random and is added
random increment and control range
and if necessary controlled repetition of numbers

'VYUGA.bas
DIM a(55555)
RANDOMIZE TIMER: CLS
OPEN "VYUGA.txt" FOR OUTPUT AS #1
d=37
a(1) = INT(RND*d)+1
PRINT #1, a(1)
FOR i = 2 TO 55555
    a(i) = a(i-1) + INT(RND*3*d)+1
    22 IF a(i) > d THEN a(i) = a(i)-d: GOTO 22
    PRINT #1, a(i)
NEXT

https://ideone.com/cPYZad

//VYUGA.cs
using System;using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace VYUGA
{ public class Program
    { static double w; 
	static void Main(string[] args) 
        { Random rand = new Random();
int d=37;
double s = rand.Next(5000000);
double a = Math.Round(d*s/5000000)+1;
Console.WriteLine(a);

for (int i = 1; i < 255; i++)
{ w = rand.Next(3000000)+1;
double v = Math.Round(w*d/1000000)+1;
a=a+v;
da: if (a>d) 
{ a=a-d; goto da; }
Console.WriteLine(a);}
Console.ReadKey(); }}}

check shows distribution is good
comparing even\odd and small\large

and a Blizzard suddenly makes normal randomness trigonometric

therefore I am looking
for an algorithm of form Mersenne twister c# & qbasic

[DANILIN]

Nearest step: shuffling by weak algorithm
weak randomness is randomness of normal

Sequence is bad
and inserted into Excel in 2 columns at a distance
and to left end-to-end of 2nd column is a column of numbers in a row
and columns are sorted end to end from maximum to minimum

Grouped together: reverse and forward sequences
and then sort both by ordering reverse
sequence is shuffled simultaneously.

Test shows normality of a shuffled
sequences of even\odd and large\small

An automatic algorithm without rnd reads array straight
and immediately there is an array reverse: ... it's a computer ...

Sorting reverse array shuffles forward array
and it turns out sequence is normal

'tasov.bas
DIM a(55000), d(55000)
OPEN "aa.txt" FOR INPUT AS #1
OPEN "dd.txt" FOR OUTPUT AS #2

FOR i = 1 TO 55000
    INPUT #1, a(i): d(55000 - i + 1) = a(i):NEXT

FOR i = 1 TO 54999: FOR j = i TO 55000
        IF d(i) > d(j) THEN SWAP d(i), d(j): SWAP a(i), a(j)
NEXT: NEXT

FOR i = 1 TO 55000: PRINT #2, a(i): NEXT: CLOSE

//tasov.cs
using System; using System.Linq;
using System.Collections.Generic;
using System.Text; using System.IO;
namespace tasov
{ class Program
    { static long[] a; static long[] d;
        static void Main(string[] args)
        {a = new long[55500]; d = new long[55500]; 
var inpFile = new StreamReader("aa.txt");
for (int i = 1; i <= 55000; i++) 
{ a[i] = Convert.ToInt64(inpFile.ReadLine());
d[55000-i+1] = a[i]; }

for (int i = 1; i <= 54999; i++) 
for (int j = i; j <= 55000; j++) 
if (d[i] > d[j])
{ var temp = d[i]; d[i] = d[j]; d[j] = temp;
temp = a[i]; a[i] = a[j]; a[j] = temp; }

var outFile = new StreamWriter("vv.txt");
for (int i = 1; i <= 55000; i++) 
outFile.WriteLine(a[i]);
Console.ReadKey();}}}

I'm testing the idea: RNG trigonometric

created a bad array that doesn't pass validation
binary even\odd and small\large

therefore, we shuffle equally real in Excel & basic & c#
just using this bad array

means: sequence is weak
shuffled through a sequence of weak
turns into a normal sequence

based on results of this topic

[DANILIN]

Developments of several years issued on new year's weekend
received a state certificate of registration of computer system

Research and transformation of sorting of pseudorandom sequences

and formula is fixed on internet N=LOG(1-c)/LOG(1-p)

Abstract includes tables and formulas and graphs
therefore it is possible to publish images of pages


Research and transformation of sorting of pseudorandom sequences

[DANILIN]

Program for distribution spectra of random
number of consecutive identical features
less \ more and even \ odd

number of numbers depends on seconds
and counts 10 ^ 5 elements per second
and I imagine what will happen in fast languages

'datable99.bas

RANDOMIZE TIMER
tb = TIMER: s = 0
OPEN "zz99.txt" FOR OUTPUT AS #2
n = VAL(MID$(TIME$, 7, 2)) * 10 ^ 5
DIM b(n), d(n), e(n), f(n)
DIM j(n), k(n), m(n), p(16), q(16)
LOCATE 1, 1: PRINT " THEORY        Average       BIG           EVEN "

FOR i = 2 TO n - 1
    b(i) = INT(RND * 900) + 100: s = s + b(i): m = s / i

    IF b(i) < m THEN d(i) = 0 ELSE d(i) = 1
    IF (b(i) MOD 2) = 0 THEN j(i) = 0 ELSE j(i) = 1

    IF d(i) = d(i - 1) THEN e(i) = e(i - 1) + 1 ELSE e(i) = 0
    IF e(i) = 0 THEN f(i) = e(i - 1) ELSE f(i) = 12
    IF f(i) > 12 THEN f(i) = 12

    IF j(i) = j(i - 1) THEN k(i) = k(i - 1) + 1 ELSE k(i) = 0
    IF k(i) = 0 THEN m(i) = k(i - 1) ELSE m(i) = 12
    IF m(i) > 12 THEN m(i) = 12

    p(f(i)) = p(f(i)) + 1: q(m(i)) = q(m(i)) + 1

    IF (i MOD 1000) = 0 THEN LOCATE 3, 1: PRINT i, " from ", n, INT(100 * i / n); " %", 
NEXT

LOCATE 3, 1: FOR t = 1 TO 12
    PRINT INT(n / (2 ^ (t + 1))), INT((p(t - 1) + q(t - 1)) / 2), p(t - 1), q(t - 1)
NEXT

te = TIMER
PRINT: PRINT te - tb; "second", INT(n / (te - tb)); " in second  "
PRINT n, " elements ",

PRINT #2, te - tb; "second", INT(n / (te - tb)); " in second  "
PRINT #2, n, " elements ",: PRINT #2,

PRINT #2,: PRINT #2, " THEORY        Average       BIG           EVEN ": PRINT #2,
FOR t = 1 TO 12
    PRINT #2, INT(n / (2 ^ (t + 1))), INT((p(t - 1) + q(t - 1)) / 2), p(t - 1), q(t - 1)
NEXT

Results:

 40 second             139555  in second  
 5600000       elements     

 THEORY        Average       BIG           EVEN 

 1400000       1400610       1399595       1401625 
 700000        700026        700122        699931 
 350000        349716        349508        349925 
 175000        174823        174892        174755 
 87500         87424         87564         87285 
 43750         43837         43931         43744 
 21875         22028         21983         22074 
 10937         10850         10865         10835 
 5468          5481          5496          5466 
 2734          2755          2732          2778 
 1367          1388          1396          1380 
 687           687           687           687

Practical distributions correspond to theoretical ones
so random sequence is qualitative
and it is possible to study patterns of different sequences

Binomial Logarithmic Integral Pyramidal Distribution
BLIP distribution of Random numbers

Feature of program: index of indixes p(f(i)) & q(m(i))

I think random have problems with parity:
parity of random changes too sharply

[DANILIN]

Number of consecutive matches is calculated by formula N = log(1-C)/log(1-P),
where N is step, P is probability, C is reliability of probability.

Substituting C and P: N = log(1-0.99)/log(1-0.5) = 6.7 = natural value 7,
that means that 7th step of distribution should include
about 1% of half data, due to counting repetitions and 0 and 1, in amount of 100%.

Distribution step number:
at C = P = 0.5; N = 1 = log0.5/log0.5 = log(1-1/2)/log(1-1/2) = 1
at C = 0.25; P = 0.5; N = 2 = log0.75/log0.5 = log(1-1/4)/log(1-1/2) = 2, etc.

Multiplication of constant probabilities c+p^n = 1
personifies reliability of probability and creates a formula
N = log(1-c)/log(1-p)
c - probability of winning guaranteed
p - probability of winning event.

for example: with a probability of 99% for a probability of 48.65%
number of mismatches in a row n = log(1-0,99)/log(1-0,4865) = 7
and that means about 50% probability is easy to guess 7 times in a row.

it is simpler to calculate by formula N=7+(5*(1/p-2))
for example p = 0.1 N = 47 is normal and p = 0.78 N = 4 is normal
and same formulas are valid for probabilities above 50%.




what I was required to prove

[DANILIN]

Checking in Wolframalpha

Reliability win and lose
both probability of winning and losing create 4 combinations:

C+p^N=1
(1-C)+p^N=1
C+(1-p)^N=1
(1-C)+(1-p)^N=1

Everything is interchangeable :

C=1-c
c=1-C
P=1-p
p=1-P

Artificial intelligence of Wolframalpha knows logarithm:

solve C+(1-p)^N=1 for N

https://wolframalpha.com/input/?i=solve+C%2B%281-p%29%5EN%3D1+for+N

[DANILIN]

Quantum random observe principles of binomial distribution