Let me say that your question is pretty advanced and is actually about a specific and characteristic design aspect of the model-theoretic semantics of RDF and its extensions s.a. OWL Full. Also, it is not a good idea to discuss the question in the context of the RDFS entailment rules: not only is this question really specific to the model-theory, but trying to answer it in terms of the entailment rules even leads in the wrong direction. I will say more about this at the end of my answer. But before I try to give an answer, I want to start with a note: The term "extensional semantics" for the non-normative extension given in the RDF semantics is IMO misleading for two reasons:

Firstly, the resulting language (let's call it "RDFS-EXT") is not really "extensional" in the same sense as, for example, the OWL Direct semantics, i.e. the semantics underlying OWL DL, is extensional: it does not make classes into sets! OWL Full is characterized by using these kinds of "extensional" semantic conditions throughout its specification (at least for all semantic conditions corresponding to OWL axioms), but that doesn't change the state of classes and properties regarding their nature of being /individuals/ with /associated sets/ as their extensions.

Secondly, even if one is clear about what I have just said concerning the nature of classes and properties, then the term "extensional" still often suggests to people that these kinds of semantic conditions have something to do with the extensions of classes and properties, i.e. that they produce results based on these extensions and their relationships. But this is not really the case, at least this is not the focus of these semantic conditions, it only often happens "as a side effect" of them, because the semantic conditions of RDFS and its extensions (s.a. OWL Full) are about classes and properties most of the time.

I tend to refer to these semantic conditions rather as "if-and-only-if" conditions. What they are about is the following: The "if direction" (the "intensional conditions") entail from certain combinations of triple-style relationships new logical relationships that are in many cases non-triple-style. For example, the if-condition in the RDFS model-theory about class subsumption leads from a triple-style relationship

```
(01) <I(:car),I(:vehicle)> in IEXT(I(rdfs:subClassOf))
```

to a non-triple-style relationship

```
(02) ICEXT(I(:car)) subset ICEXT(I(:vehicle))
```

which relates the two class extensions associated with the two classes (individuals!) I(:car) and I(:vehicle); the "I" is the actually used interpretation of the names ":car" and ":vehicle". The other direction in the "extensional" "if-and-only-if" condition (I like to call it "fi-condition") does the opposite: it leads from an often non-triple-style relationship, such as (02) to a triple-style relationship such as (01).

Now, to answer your question, it is important to understand that in the RDF semantics (and in its extensions) entailments can only be sets of triple-style relationships, so (02) is not an RDFS-entailment from (01), also one could call it a "logical entailment" - it is not a valid reasoning result in RDFS. Hence, if you have an RDF graph consisting of the triples

```
:car rdfs:subClassOf :vehicle
:sportscar rdfs:subClassOf :car
```

if in RDFS the only semantic condition about class subsumption would be the if-condition, then you would /not/ receive

```
:sportscar rdfs:subClassOf :vehicle
```

which would render RDFS semantically pretty pointless, because transitive reasoning about the class hierarchy should be a least requirement. The funny thing here is that you would actually get the following entailment on a logical level:

```
ICEXT(I(:sportscar)) subset ICEXT(I(:vehicle))
```

so the desired result is kind of "pending"; it simply doesn't pop up due to a missing "backwards semantic condition" leading from the "logic space" back into the "RDF space", so to speak. (*Note:* there are no such spaces, and there is also no mapping between distinct spaces. It is rather a nice, though technically invalid, way to look at the situation.)

Now, adding the full "if-and-only-if" condition to RDFS would make the language probably a bit too expressive, and would rapidly become more expressive if you start adding new language features: you would then go straightly towards something like OWL 2 Full. Therefore, RDFS has "special-purpose" or "poor-man's" if-and-only-if conditions, namely the transitivity and reflexivity conditions for class and property subsumption: they are special cases of the full if-and-only-if conditions and, in fact, follow logically from the full conditions. They are strong enough to give us what we expect from RDFS while keeping the semantic expressivity rigidly under control.

So the short answer is: these conditions are needed to make RDFS meet its expressivity requirements (in particular reflexive-transitive reasoning on class and property hierarchies) without becoming too expressive, e.g. they still allow for easy-to-be-implemented rule-style RDFS reasoning.

Btw, these kinds of special-purpose if-and-only-if conditions are not rare: There is also the RDFS semantic condition for rdf:type, which leads back from set membership to a triple-style relationship. And if you look at rule-languages such as the RL/RDF rules - or the RDFS entailment rules(!) - one could say that, in a sense, many if not all of the rules correspond to special-purpose if-and-only-if conditions (if they would be translated into model-theoretic conditions), since they all lead directly from triple-style relationships to triple-style relationships, short-cutting the path through the "logic space". Btw, this is the primary reason why RDF rule languages are relatively "light-weight" compared to logic-based languages: there is no option to do flexible and complex logic reasoning in the "logic space", reasoning just directly "hops" from the "RDF space" into the "RDF space".

The extensional semantics become very relevant when going the OWL Full path to more expressive extensions of RDFS. If all semantic conditions in OWL Full were purely "if" conditions, then funny things would happen: On the one hand, one would still get many of the inconsistencies of ontologies that one gets with unrestricted if-and-only-if OWL Full, since in most cases the "fi" parts of the semantic conditions are not needed to get a logical contradiction - if there is one, then mostly already via the "mapping" of the RDF triple-style assertions in the ontology to the corresponding logical relationships via the "if" parts of the semantic conditions. Hence, the "if" conditions are far from being "weak", as often claimed by people; in fact, they are generally the stronger parts, leading from boring sets of atomic (triple-style) formulae to more sophisticated non-triple-style formulae. In the worst case, one can make an RDF-based language formally inconsistent by only defining "if" conditions! On the other hand, many of the entailments that are characteristic for OWL Full won't exist anymore, in particular many entailments having to do with terminological reasoning, i.e. relationships of classes and properties. They are still kind of around in the "logic space", but are not "visible" as RDF triples.

I experience this on a daily base, for example whenever I prove correctness of an OWL 2 Full entailment spot test (and I am doing this pretty often): one almost always needs one or the other "fi" (backwards) part of an if-and-only-if condition to receive the expected results. Well, as said, it is these conditions that bring you back from the "logic space" into the "RDF space"! Beyond experience, the if-and-only-if conditions are fundamental for the "OWL (2) correspondence theorem", which is generally expressed in the form that OWL DL is a "sublanguage" of OWL Full (although saying it this way is only an "approximation" of the actual technical relationship between OWL 2 DL and OWL 2 Full, which is more complicated). Without the "fi" parts of the semantic conditions, the theorem could not be proved.