reflexive | Reflexive is a web based live class and source code browser

Primary key columns can never be null. Use a UNIQUE constraint instead:

As hinted in my previous answer, the eliminator for equality in Coq inherits this behavior from intensional type theory, where it was introduced to keep type checking decidable. However, later people realized that it is possible to have an elimination principle for equality that validates axiom K without ruining decidability. This is not implemented in Coq, but it is implemented in Agda:

Im UML, this class means that Every Unit is aggregated into some other Unit.

The UML standard doesn’t cover code generation, so interpretation of this as code depends on which tool you choose. Every proprietary code-generation tool should either stop with an error or provide an additional constructor that creates a new Unit that references itself. Otherwise, what Unit does the caller pass to the constructor for the very first Unit?

Other ways to fix the problem include taking an open-world interpretation of this UML model (where not all true information is present, as is the case for OWL), or loosening the multiplicity to 0..1.

The issue here is that parsing the axiom relies on an OWLEntityChecker implementation to convert strings to class or property expressions, in this case Mulher to the entity as declared in your ontology, e.g., urn:test:Mulher.

There is an example on how to configure this in the OWLAPI tracker: https://github.com/owlcs/owlapi/issues/507

Protege uses a similar mechanism but it has its own OWLEntityChecker implementations, which wouldn't be available to you if you're only using OWLAPI.

The example below uses a naive implementation of OWLEntityChecker which will use the fragment of the IRIs for all entities in the ontology to identify the entities; this is limited, because in real ontologies the IRI fragments can easily clash or be missing. However it might help, if the example on the bug tracker isn't good enough.

You can use dependency relations for this.

Pasting some example reflexive verb sentences into the displaCy demo, you can see that the reflexive pronouns for these verbs always have an expl:comp relation. A very simple way to find these verbs is to just iterate over tokens and check for that relation. (I am not 100% sure this is the only way it's used, so you should check that, but it seems likely.)

I don't know French so I'm not sure if these verbs have strict ordering, or if words can come between the pronoun and the verb. If the latter (which seems likely), you can't use the normal Matcher or PhraseMatcher because they rely on contiguous sequences of words. But you can use the DependencyMatcher. Something like this:

^{Note: this answer does not directly reply to the question, since the origin of the problem was not related to the scrollbars}

The problem is caused by the fact that setHtml always resets the contents. While the result might appear instantaneous, it is not, since the document has to be layed out again based on the size of the scroll area, which eventually updates the scroll bars.

While technically it is possible to delay the scrollbar reposition, the real issue is that setHTML is not the proper way to provide highlighting, especially for mouse hovering: every single individual movement of the mouse would cause what explained above, and this is clearly not a good solution, performance wise.

It's also important to remember that setting the HTML in a Qt editor is only interpreted, since the HTML is parsed and then "translated" into a Qt document; you'll see that toHtml() will not return the code used for setHtml(), even if no change has been made.

In fact, the proper way to alter the format of a Qt rich text editor, is to interact with its lower level API, accessing the QTextDocument and modifying it using a QTextCharFormat.

Note that while normal editing is applied using the QTextCursor interface, it would not be effective for this purpose, since it is considered as an "user action" and adds the format change to the undo stack of the document.

In order to apply changes to the underlying document without changing its contents, it's necessary to use the QTextLayout of the QTextBlock that will contain the highlighted text, then it's possible to create and set a FormatRange for that layout by specifying the character boundaries and actual format.
This approach has the benefit that the format changes do not change the actual document formats, but only the way the document is displayed, so, for instance, toHtml() will never include the highlighting.

This is the summarized procedure:

1. get the QTextCursor based on the mouse cursor position;
2. select the word under the mouse;
3. get the QTextBlock and ensure that the mouse is actually inside the rectangle of that block (cursor.WordUnderCursor always finds the closest word, even if it's not exactly under the mouse);
4. get the range of the selection and check if the range is changed from the previous call;
5. clear the previous layout format (it could be a different word or even a different block);
6. if there is a selection, create a FormatRange with the start position based on the block cursor position, and with a given text format;
7. set the format on the layout;
8. notify the document that its contents are "dirty" and need to be layed out again (and repainted);

In order to call the function whenever the mouse moves, the mouseTracking property should be set, and the viewportEvent must be overridden to properly track mouse events.

This looks like the adequate data type according to the exercise description. You can build trees with an arbitrary number of distinct leaves, e.g. Node (fun n => if n =? 0 then Leaf 3 else Leaf 5), Node (fun n => Leaf n) or Node (fun n => Node (fun m => Leaf (n + m)).

I think the definition of valid is decoupled from the validity of the response. That can be checked by validating the message integrity and matching the transaction id. If you get a response that is valid in that sense you construct the valid pair.

Now...

This matches its local candidate, thus we are good here.

This matches the local address of the relay candidate.

For the remote candidate check:

You have been sending the stun message via the TURN server specifying a xor-peer-address in the send indication and also receive a xor-peer-address in the data indication of the response.

See also https://datatracker.ietf.org/doc/html/rfc5245#section-7.1.3.2.2 for full detail. It is a bit vague since TURN is specified somewhere else.

This depends on how well the turn server software that you use has implemented the RFC. You'll need to check it.

The port is part of the xor-peer-address that gets sent to the TURN server so the natural assumption would be that any lookups happen against the full address.

But in the case of the other side being behind a symmetric NAT the port (and sometimes the IP but that is rare) used will be different. Which is likely the reason for the specific requirement in the RFC.