The problem is that you can't prove it. In fact in a typical OOP libary you couldn't actually prove anything.
The fig leaf, LSP, was already mentioned. It even looks innocent enough:
𝑆⊑𝑇→(∀𝑥:𝑇)ϕ(𝑥)→(∀𝑦:𝑆)ϕ(𝑦).
Or in textual form: Let ϕ(𝑥) be a property provable about objects x of type T. Then ϕ(𝑦) should be true for objects y of type S where S is a subtype of T.
Sounds simple. We should test ϕ for every S and T, but… stop, stop stop. What is that ϕ?
Is it ∀ϕ? No, it wouldn't work: Child definitely have some different properties that other Person doesn't have, or the whole excercise is moot.
Okay, maybe it's ∃ϕ? No, that wouldn't enough, we may need certain properties to be common between Child and Person and it's hard to predict which ones.
Then… what the heck is ϕ? The answer to that is “simple”: that's property that you may need to hold both for Child and Person. In any future program that would use Child and Person.
Thus… to make OOP work we need a crystal ball that would tell us the list of things that we may ever decide to do with Child and Person.
That's… quite a tall order.
And that's why Rust doesn't have OOP: OOP is not a math. It's clever but fragile hack which was plenty useful on small computers of XX century.
In XXI century… it's time to forget about it.
Creators of Rust really tried to bring OOP into it, but, ultimately, “Rust is an ML in a C++ tenchcoat”. Math. And math theory for OOP does't really exists.
All these discussions about whether to use Composition or Inheritance and if it would work or not are coming from one root cause: without knowing in advance whether some property is that magical ϕ that you may need some time down the road… it's impossible to say if Child have to descendant of Person or not.
Heck, that core sin is even teached in almost every OOP course when they discuss Shapes, Rectangles and Squares. Because answer to the question “is Squares as Rectangle” is quite non-trivial in OOP. Or, rather, there are no answer, it all depends on what do you plan to write.
Thus yes, it's XXI century, it's time to forget about OOP. It was nice dream to bring encapsulation, inheritance and polymorphism in one place… it's classic “pick any two of three” situation and Rust provides any two, just not all three together.