“A self-driving car, also known as an autonomous car (AC), driverless car, robotaxi, robotic car or robo-car, is a car that is capable of operating with reduced or no human input. Self-driving cars are responsible for all driving activities, such as perceiving the environment, monitoring important systems, and controlling the vehicle, which includes navigating from origin to destination”. (Wikipedia).
As for how this works, this gives a rough idea (Wikipedia): “The perception system processes visual and audio data from outside and inside the car to create a local model of the vehicle, the road, traffic, traffic controls and other observable objects, and their relative motion. The control system then takes actions to move the vehicle, considering the local model, road map, and driving regulations”.
The key here is that there needs to be model. A model is a surrogate, an emulation of reality. But how is a model built? One collects data – the data can be originated in the real world, or by computers running other models – and then builds equations that embrace this data. One tries to build a model that fits the data as well as possible. There are very many ways to build models.
Then there is the issue of model validation. A validated model is trustworthy only within the domain of validation, and using it outside of this domain is very risky. This is an immensely complicated issue and we will not elaborate on it here.
Let’s suppose, without loss of generality, that the model is a system of equations that looks like this
y=[A]x + b
where x are the inputs, y are the outputs, [A] is a matrix wich describes the way the underlying system works and b is some external input or disturbance that cannot be controlled. Examples of x, y and b could be: angle of steering wheel, angle of front wheels and road/tyre friction coefficient (which depends on whethere there is rain, snow, etc.). In order to build [A] it is necessary to collect the above mentioned data (variables) and to put into the form of equations. In order to know what input (x) to apply in order to get the desired outcome (y) one must compute the inverse of [A] and that itself can prove problematic if [A] is ill-condition (i.e., it has weak rank). This can happen if the data or equations used to build [A] are not properly chosen. But let’s suppose this is not the case.
The first problem that may appear stems from the fact that we may have N variables we are interested in, and that we are able to build M equations around them. The ideal case is of course when N=M. However, when approaching a complex problem, it may be difficult to build those M equations, say M<N. One must then sacrifice some variables so that M=N and the above equation has one solid solution. But what if M<N? Suppose we end up having more equations than variables, i.e. N>M. In this case certain equations will need to be sacrificed so that the system can be solved (unless one wants to resort to pseudo-inverse matrices). So, during model building, one needs to leave out variables, or equations. However, when one has been building models for a few decades, one discovers that:
the most important variables in a model are those it doesn’t contain
In essence, a model always misses physics and this can prove to be more or less critical, depending on the application and, especially, if human life is involved.
Then there is the issue of model complexity. Suppose you have a great, tuned “local model of the vehicle, the road, traffic, traffic controls and other observable objects, and their relative motion”. The model, just all things in the Universe, is subjected to the Principle of Fragility, coined by Ontonix:
Complexity x Uncertainty = Fragility
where C stands for model complexity and U is the uncertainty in the environment (road conditions, traffic, weather, etc.). The more complex the model, and/or the greater the uncertainty in the environment, the more fragile the situation is. Fragile means vulnerable, and that means high risk. We also know that:
high complexity implies numerous modes of failure
In higly complex systems, many failure modes are nonintuitive. It is impossible to have AI-based self-driving systems embrace the immense number of circumstances that can manifest themselves in a traffic system, and building more sophisticated and complex models will only get things worse in virtue of the above principle. A great example of this fragility in action is reported in an article, describing how a “Man Fools Waymo Self-Driving Cars With Stop Sign T-Shirt”.
Performance versus robustness (the opposite of fragility) is a trade-off and that means compromise. High model complexity will amplify the ‘divide’ between performance and robustness, forcing even greater compromises on either one or the other.
One way to mitigate the risks is to simultaneously transition all road vehicles to self-driving on the same day. That would surely reduce the uncertainty (U) in C x U = F by removing the human element. However, there still would be all the other very numerous sources of surprises that cannot be forced into a math model. One can only imagine if cars start to talk to eachother and try to achieve some collective traffic goals. The complexity of such a situation would be insanely high and so would the number of potential failure modes. And casualties.
To answer the question in the title of this blog: fully self-driving cars are, with today’s technology, a hype and a mathematical impossibility. It is not necessary to see a car drive itself from San Francisco and park itself in new York (a few years ago someone said that in 2017 that was going to be possible). A trip from Como to Bellagio would be convincing enough.
Artificial Intuition 
Pingback: Self-Driving Cars and the Principle of Incompatibility – Artificial Intuition