PEFFI, Undirected graph traversal algorithm by selection of finite Fibonacci sets applied to communication, the example of communication routing in autonomous vehicle fleet navigation.

Abstract

Creation and method of Jérôme Chapoul's system, developed with personal funds, June 23, 2024

Description

Title of the invention: PEFFI, Undirected graph traversal algorithm by selection of finite Fibonacci sets applied to communication, the example of communication routing in autonomous vehicle fleet navigation. Context#:

[0001] As part of improving land traffic and decarbonization, states are investing heavily in research and technology transfer towards fully autonomous level 5 vehicles.

[0002] Although it is true that industrial autonomous vehicles struggle to pass level 2 on an industrial scale, level 3-4 vehicles exist in the research context.

[0003] In fact, to reach level 5, states are considering two options for the future: navigation on roads dedicated to autonomous vehicles, or navigation mixing mechanical and autonomous vehicles.

[0004] The first solution is the simplest technologically.

[0005] The problem in both claimant cases is the exchange of position and speed data between autonomous vehicles to achieve fleet navigation.

[0006] Two things happen, the vehicles must be in permanent communication via propagation channels (example: wifi), to exchange data, and route the latter in the event of channel obfuscation by obstacles.

[0007] This therefore implies chaotic data exchanges between vehicles, in an undirected graph, overloading the communication capacity by the repeated sending of messages at very short frequencies, but also, in fact, unnecessarily overloading the Processor pipeline.

[0008] Indeed, how can we know if a vehicle has received or sent the message from another end of the graph to another vehicle, or simply if all vehicles have received the message, or even if a moving vehicle is defective, or if part of the mesh is no longer receiving data from other vehicles?

[0009] The first solution is to send the message in an anarchic way in the network and to relay it between vehicles, with, if necessary, an address so that the vehicles can know who the message comes from.

[0010] However, passing this list of addresses to secure communication is too bandwidth-intensive; imagine 500 vehicles each passing an address of the type 5c645e5f..., this would represent 500 * 8 characters, or 500 * 8 bytes = 4000 bytes, or 4 Kilobytes just for the addresses...

[0011] Thus we can clearly see the load on the bandwidth, but also the slowdown attributed to the program, for the iteration of checking all the addresses, as well as the load on the pipeline and GPU attributed by the conditional checks of these addresses. My proposal:

[0012] I propose a power selection algorithm for finite Fibonacci sets, named PEFFI, to optimize the routing of data packets for communication between vehicles applied in undirected graphs, allowing a drastic reduction in the data transmitted over the bandwidth, allowing optimization of CPU processing, which will have the effect of significantly improving the availability and performance of the bandwidth, the CPU and its pipeline, during the reception of communications between vehicles, but also allowing better security for vehicles and their drivers by integrating into the vehicle's intelligence the exact knowledge of the network topology both local and global, allowing it to alert and escalate alerts quickly in the mesh of the undirected graph of the vehicle communication network.

[0013] This algorithm consists of a balanced use between a Fibonacci matrix, associated with a power function of 10 forming a negative decimal number (should be usable for negative decimals, to be verified).

[0014] Thus, it is possible to transmit all the vehicles that received the message, as well as their membership set (selection), in a single 4-byte packet via a Float. Or a Double or a long double of 10 bytes.

[0015] For a float of 4, this will give us approximately a set of 90 possible Fibonacci numbers (vehicles) for 19 possible sets, or a maximum chain of 1710 vehicles in 4 bytes, and in long double at least 1495 * 150 = 224,250 vehicles Method, algorithmic rules:

[0016] the vehicle identification is equal to 10 times the power minus the integer value assigned to the Fibonacci set, to which is concatenated the Fibonacci number assigned to the vehicle of the set.

[0017] a message transmitted by a chain of vehicles will be equal to 10 times the power of minus the integer value assigned to the Fibonacci set, to which is concatenated the sum of the Fibonacci numbers assigned to the vehicles of the set.

[0018] When a vehicle identifier is issued for the first time, and if its value is not composed of the sum of two Fibonacci numbers, its identifier will be equal to 10 times the power of minus the integer value assigned to the Fibonacci set, plus 1, to which is concatenated the Fibonacci number assigned to the vehicle of the whole, to overcome the following problem of the fibonacci sequence: 8+13 = 21, 21 =21. When the message is received by another vehicle, -1 will be subtracted from the previously calculated power. The equation:

[0019] Literal definition: For any finite set of vehicles belonging to a finite grouping set, concatenate as vehicle identifier 10 to the power of - (grouping number) and a number from the Fibonacci sequence contained between 2 and the maximum possible Fibonacci value on the positive part of the floating-point data divided by two.

[0020] Mathematical definition: Let V be a finite set of vehicles and R a finite set of groupings. For each vehicle veV belonging to a grouping reR, the vehicle identifier is defined by: ID(v) = 10 - (num(r)) - F

[0021] where: • num(r) is the number associated with the grouping rrr, • F is a number in the Fibonacci sequence such that 2 <F<Fmax#22 \leq F \leq \frac {F_{ \max}} {2} 2<F<2Fmax, • Fmax is the maximum possible Fibonacci value on the positive part of the floating-point data. In terms of formal notation, this can be expressed as follows: VveV,3reR:ID(v)=10-(mim(r)) F

[0022] with:

[0023] Fe{FnlFn is a Fibonacci number, 2 <Fn<2Fmax}

[0024] where {Fn}{F_n \}{Fn] represents the set of Fibonacci numbers.

[0025] In summary: 1. Each vehicle veVv \in VveV belongs to a grouping reRr \in RreR. 2. The vehicle identifier vvv is a combination of 10-(num(r))10A{-(\text{num](r))]10-(num(r)) and a Fibonacci number FFF such that 2 <F<Fmax#22 \leq F \leq \frac{F_{\max}}{2}2<F<2Fmax. _

[0026] Final formal equation:

[0027] VveV,3reR:ID(v)=10-(num(r))-Fe{FnlFn, Fibonacci number, 2 <Fn<2Fmax}•

[0028] Literal explanation of the equation and communication constraints:

[0029] Cv = Selection(fibo vehicles) concatenated following 10A (- set number).

[0030] Example CV = 14 concatenation 10 ( - 1) = 0.114

[0031] Example 2 CV = 20 concatenation 10 ( - 3) = 0.00120

[0032] Cv represents the vehicle chain.

[0033] To understand the algorithm, one must first understand the benefit of using the Fibonacci sequence.

[0034] Each vehicle will take as its identifier a value, this value will be one present in the Fibonacci sequence.

[0035] The advantage is that for each addition of values ​​in the Fibonacci sequence, an identical value can never be found by adding any other value in the sequence.

[0036] Thus, for the sequence 2, 3, 5, 8, 13, 21, 34, ..., 13 + 5 + 2 = 17, cannot be found with any other number in the Fibonacci sequence. From this, it is very easy for us to deduce the numbers that compose it from this value. 17 = 15 + 5 + 2, because there is only one way to obtain this value.

[0037] However, receiving the number 13 can be problematic. Recall that in the Fibonacci sequence, the value of the selected number in the sequence corresponds to the sum of the two preceding numbers. That is, n = (n-1) + (n-2). Therefore, if the selected number is 13, it can be either the value 13 or the value 5+8.

[0038] To differentiate this case, we will add 1 to the power calculation of the preceding equation, to indicate that the value is unique. ( (10 A-3) + 1) = 1.001

[0039] Thus in the case of a communication, the vehicle will understand that the transmitted number is, in the preceding case 13, and not 5+8, it will therefore be able to subtract one from the value previously received and send the message to the next one.

[0040] Example 2 CV = 13 concatenation ((10 ( - 3) + 1)) = 1.00120

[0041] upon reception by the digit 5: 5+13 concatenation 10 ( - 3 = 0.00118

[0042] To put it simply, when the message is first transmitted by a number, the power will increase by +1, and when the second message is transmitted after the first number is received, the normal power of 10A -3 will be applied.

[0043] Now, each vehicle in the mesh will take as an identifier, with a 4-byte float, a number from the Fibonacci sequence, between the range of 2 and 90 higher Fibonacci iterations, and will also be assigned a set identifier between 0 and 19. This will allow the creation of a finite set of Fibonacci elements, in a selection of finite elements between 1 and 19, which will be iterated for each subsequent set of vehicles needed to cover a road mesh.

[0044] The vehicles will therefore know, from the received number, who sent the message, where it passed through, and will not resend the message to vehicle identifiers already present in the received Fibonacci number. Similarly, it will also be possible to see when a vehicle leaves the set; if its number is not present despite multiple transmissions, it can therefore be expelled before a security check verifies that there has been no incident for that element of the set, and thus open that number to a new vehicle entering the set.

[0045] Minimalist code example for float encoding:

[0046] #pragma once

[0047] #include<math.h>

[0048] #include <string>

[0049] #include <sstream>

[0050] #include <iostream>

[0051] class Peffi

[0052] {

[0053] public:

[0054] Peffi()

[0055] {

[0056] Fibo!dVehicule[0] = 2;

[0057] FiboIdVehicule[l] = 3;

[0058] FiboIdVehiculeConnected[0] = 0;

[0059] FiboIdVehiculeConnected[l] = 0;

[0060] for (int cpt = 0; cpt < 88; cpt++)

[0061] {

[0062] FiboIdVehicule[cpt] = valUn + valDeux;

[0063] valUn = valDeux;

[0064] valDeux = valUn + valDeux;

[0065] FiboIdVehiculeConnected[cpt] = 0;

[0066] }

[0067] };

[0068] ~Peffi() {};

[0069] float AddIdToVehicule(int& _ensembleValue)

[0070] { [0071 ] std: : stringstream idStream;

[0072] idStream « AddEnsemble(_ensembleValue);

[0073] for (int cpt = 0; cpt < 90; cpt++)

[0074] {

[0075] if (FiboIdVehiculeConnected[cpt] == 0)

[0076] {

[0077] FiboIdVehiculeConnected[cpt] = FiboIdVehicule[cpt];

[0078] idStream « FiboIdVehicule[cpt];

[0079] }

[0080] }

[0081] return std::stof(idStream.str());

[0082] }

[0083] float AddEnsemble(int & _ensembleValue)

[0084] {

[0085] return pow(10,-_ensembleValue);

[0086] }

[0087] std::string CheckChainedListeVehiculesMessageSend(float & _IdMessage)

[0088] {

[0089] }

[0090] private:

[0091] float valDeux = 2;

[0092] float valUn = 1;

[0093] int FiboIdVehicule

[90] ;

[0094] int FiboIdV ehiculeConnected

[90] ;

[0095] }; Conclusion:

[0096] Using this algorithm will decrease the processing time of communications, free up the pipeline processors for other calculations, and significantly decrease the vehicle cycle loop time to make it available for other calculations.

[0097] It would be interesting to use this algorithm, in a non-directed network, with an external supervisor, for example, a fixed computer supervising communications between autonomous vehicles.< / iostream> < / sstream> < / string>

Claims

[Claim 1] Demands I claim to be the sole creator of the system, and to have carried out this research outside of a professional framework.