- From: Chris Miller <clm8zr@virginia.edu>
- Date: Sat, 27 Jun 2026 04:47:12 -0400
- To: Pierre-Antoine Champin <pierre-antoine@w3.org>
- Cc: public-rdf-star-wg@w3.org, cmill4ed@mail.umw.edu, chris.lll.miller@gmail.com
It wouldn't be the first complaint about my writing.
Prior feedback says things like:
Content is too short.
Sentences are too long.
My pronouns are ambiguous.
Truth tables are not sorted.
"Thus" is only for provable conclusions.
Of course, grammar and mechanics...
I was hoping that a whitelisted vocabulary wasn't required for voice.
C K Ogden & I A Richards will not be in my budget this year.
But I understand that Rudolf Carnap has cited a "word magic" version
of "Meaning of Meaning" in "Philosophical Foundations of Physics" [1].
I don't want it to sound like I'm against controlled vocabulary .
Later, I may be a vocal advocate.
So far, the only rule I've learned is: don't use Latin
phrases/abbreviations [2].
& I want to quote "de-re"@la for lack of a concise phrase.
My reflections on technical writing has made me think that significant
revisions against vagueness could be raised on the basis of rules and
terminology alone.
Blacklisted vocabulary could be readily identified by such a writer.
I've unwittingly read several works using reduced English .
It's not how I've heard things until recently.
I've heard some questions using "itself" where they ask for meanings
other than those occurring in the rest of the sentence.
I tend to switch subject fields seasonally.
"The center of gravity of 'philosophical logic'
today lies in theoretical computer science,
but not the center of gravity of this book,
which is written with the needs
in mind of students of philosophy
and philosophers who are not specialists in logic." [24]
So, basically, programming on challenging technology just stops.
RDF-MT has mentioned Tarski , Herbrand & Skolem , whose primary texts
are not the most accessible introductions to logic .
Going back, I had found the interdisciplinary rivalry between Minsky
and Dreyfus in the library [41].
Dreyfus makes it sound as if Minsky's frames paper was assimilating
logic from Husserl, after Dreyfus employed it to critique Minsky [26].
I recognized "reification" from browsing Quine.
It seemed like an unusual word.
But so did "ontology" and so on.
Other concepts are taken over from Kant , Bolzano , Frege , Hilbert ,
Cantor , Dedekind , Russell , Pierce , Leśniewski ...
Roughly, means are adverbial phrases which answer "how" questions .
Manners, methods, routes, ways, implements, instruments, ... there are
only so many definitions in the language for means.
To ask for meaning is to ask for these "how's" of ontology.
By ISO definitions , intentional employment of 'concept' in both
definiens of 'meaning' and 'ontology' supports their connection .
Why not just say "meaning" rather than "ontology" ?
"Meaning" has seen increased usage against 'essence' (in itself).
Ontology claims comprehension of all employment of the verb "to be" .
Ontology is a dimension of transcendental realism amenable to
reproducible science .
Amphiboles of freewill & its purposes or consequences are not
reproducible empirically .
Further , meaning can request a change of opinion in a person (empathy).
For example , suppose that a researcher finds testimony of a phenomena
of "automatic writing" to be credible [9] .
He might then pursue a different subject field , say psychology rather
than computation .
But in computation , the concern is usually for effective procedures .
Recall that some procedures like substitution just work, while others
like factoring do not efficiently work ... or have non-obvious
implementations .
When considering a primitive action like material implication (arrow)
as the atomic meaning of a copula , adverbial modification is like
defining a procedure gone to by the control of a primitive action.
#mb-x-2
#mc-x-rdfxml
#mh-x-1
#mi-x-wff
#mj-x-walkthrough
#mk-x-definitions
#ml-x-history
#mm-x-analysis
#mn-x-diagram
#mo-x-graphs-only
#x-tag
#x-anachronism
#mp-x-graphics
#mu-x-article
#g-x-biblio
Somewhere I thought the LPG interpretation was described as "how the
predicate is used in the triple" .
This is an attempt to answer that problem regardless of whether or
where it was said.
I doubt that this is will pass standardization.
If only because, it is not necessary like reification vocabulary is.
It might make a better tutorial or debate.
I will argue that it is still computable software.
An argument is not a proof nor implementation.
You might think of this as documentation for pseudocode.
Or you might consider it a case of " ... easy to do something , harder
to say what it means ... " [43] .
Or you might consider it as an alternative narrative of the framework .
The prior table I sent is about a graph shape and a procedure for
producing it by keyword in an extended concrete syntax.
By using a keyword, it removes some boilerplate triples from syntax only.
The boilerplate is repeating a triple already afforded by rdf:ID of an
asserted triple.
The procedure behind its keyword (*ID2), is similar to a preexisting
one, rdf:ID [4].
*ID3 is a misnomer , it is identical to rdf:ID and should be retracted .
Because of this similarity, its feasibility is estimated with
reasonable confidence.
For more confidence, the assembly might consult the expert estimation
of an implementer like Dave Beckett [3].
I have no personal plans to use this shape at this time.
I am pessimistic about there being enough interest in the shape or its
interpretation to alter the assembly's direction.
That said, arguing for its relevance to the assembly's agenda & its
satisfaction of LPG curators will serve two goals.
First, it will justify posting to public-rdf-star-wg@w3.org list.
A few months ago, I had neither any defects nor enhancements to suggest for RDF.
I was learning IETF BCP 47 for rdf:langString [5,6].
I haven't been following rdf-star too closely .
Second goal for discussion is to make an argument that will persuade
the audience to decide on an interpretation for "abstract objects"
even without implementing the proposed feature enhancement [7].
The shape is germane to the agenda of "making statements about
statements" in that this phrase is not closed on its commitments to a
structure or quantity of relationally mapping for 'aboutness' .
The shape extends an already accepted concept of hierarchical &
partitive relations across reification to a second instance of
reification about a first reification.
It may be of some interest to the audience whether such expressions
are only possible for graphs in contrast to hierarchies typically
found in tree structures.
Testing the shape will show that "RDF Semantics" has already
anticipated such usage through activation of a semantic condition [8].
Some example correspondences of graphs shapes to tree languages are suggested.
Some diagrams of concrete graphs are depicted.
I will identify some of my mistakes for retraction.
I have skimmed the public-rdf-star-wg archive up to 2023.
The thesis remains that there is a distinction between annotation of a
*complete-sentence versus annotation to an *adverbial-phrase .
Motions will be described that a member of the assembly could propose .
#mb-x-2
My second point was only a point of genuine confusion , except that
its data structure seems relevant, at least to runtime efficiency or
reification.
I ought to be careful of asking the working group to directly engage
in education & outreach .
Thanks for your answer and encouragement.
When you say "associates" , I understand it as affirming a principle
of computers that all structures consist of 2 or 1-ary operators, for
example, logic gates or processor instructions .
It sounds all right, although a certain connotation of recalling
particular personalities has concerned me in recent years as being
etymologically justified and not anti-psychologism in formality.
Then again, saying "projects" sounds solipsistic , and otherwise not
quite correct .
In any case, your usage is terminological, which is paramount for an
international organization [10].
Interpretation of 3-valued logics (T,F,undefined/possible) and
associative graph relations employs disjunctive introduction to open
probabilistic formalisms.
Problems of linguistic meaning can be whether concepts like metaphors
and similarities are even definable as inductive or probabilistic.
To follow the expected primary of empirical objectivity is to ask of
impersonal electric charge.
Suppose that data structures may subsist physically.
It is said that there is even a "cold boot attack" way of
restructuring memory access from another machine .
Typically, data structures determine combinations in a retrieval process .
That retrieval has characteristics like the strength of its inference
; what it entails for the process.
Because of retrieval's deductions , these associative' relations
(which are sensible in graph syntax) may also perform partitive &
hierarchical relations in the retrieval process.
For this provision of RDF-MT, I'm also looking at Jeff Z Pan [12] .
It partitions a triple into components .
It orders components into a totality .
There is a definition for 'mapping' which includes "best" , that is
permitting 'abduction' [14].
There is a textbook that asks the reader to associate a program with
each mapping [13].
(a,a) b false .
(a,c) b true .
(c,a) b false .
(c,c) b false .
The "mapping" then is a (proper) subset of these factors which selects
for appropriate settings (assertions) .
A database of two triples { (a b c) , (d e f) } has a large powerset of IR^2 .
2^36 ~= 68 billion .
I would have to doubt that there is any invocation of a powerset
operation for that in the software implementation because of such a
size .
By raising the precedence of (another) powerset to a (similar) mapping
, a powerset-envelope is a shared structure of prediction .
Only one of the powerset possibilities (all elements) is the actual
(persisted) state of the database .
{} xor {(a,b,c)} .
{} xor {(a,b,c)} xor {(d,e,f)} xor { (a,b,c) , (d,e,f) } .
{ {} , {(a,b,c)} , {(d,e,f)} , { (a,b,c) , (d,e,f) } } .
In the first point, there was mention of translation or rewriting .
It is in a formal and computational intent.
Likewise still here in the 2nd, this envelope must replace each comma
with xor , in order to express a persisted state .
The shared structure and derivative language are similar , but do
differ in their computer implementations .
And in addition to source and target languages , the translator is
itself another program .
'Metalanguage' is coordinated with "object language" in
"meta-mathematical" texts [15].
So it goes, by yet another route, that whenever we speak of
"interprets" , "reads" , "abbreviates" , "paraphrases" it regiments
translation: substitution , distribution , inference , cancellation ,
modeling , approximation ...
Most of the examples given in RDF by names & shapes, solicit such
interpretations for inference, but leave the tree symbolism as an
exercise for the reader.
We might recognize an object-language as amphibolous if it contains a
powerset because {} (empty set) will be a token yet mean nothing .
I failed to understand something that seemed important , and now the
record has been set straight .
Pierre-Antoine , your answer makes the set-theoretic contrast very plain .
It would seem that a certain memory address in a range element of
IP(b) is the (a,c) pair for (a,b,c) .
Depending upon implementation, that might immediately (zero offset)
turn out to be (a) looked up at that location.
However, that address's location's existence in the persistence of
IP(b) corresponds to reification of (a b c) because both the triple &
its implementing memory address are unique .
That design, might then decide whether to copy the reification of (a b
c) under IP(rdf:predicate) or to preemptively extend the IP(b)=(a,c)
structure with a boolean flag or memory link such as reify=TRUE goto
yonder.
In such an extended structure , a retrieval procedure may not have to
start with zero knowledge about where to move next if it leverages an
equivalence of reification with an implementing data structure.
Sorry, I don't know much about database implementations.
#mc-x-rdfxml
<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:ns1="ns1:"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
<rdf:Description rdf:about="ns1:qsa" >
<ns1:qpa rdf:resource="ns1:qoa" rdf:ID="xia" />
</rdf:Description>
<rdf:Description rdf:about="#xia" >
<rdf:predicate rdf:resource="ns1:qpa" rdf:ID="xic" />
</rdf:Description>
<rdf:Description rdf:about="#xic" >
<ns1:qpe rdf:resource="ns1:qoe" />
</rdf:Description>
</rdf:RDF>
Above is RDF/XML of the shape described before .
It passes the validator service [44] .
%s/qsa/ex:Usa/g
%s/qpa/ex:_2026/g
%s/qoa/ex:Event/g
%s/qpe/ex:circa/g
%s/qoe/ex:June/g
+------------------------------------+
| ex:Usa [ ex:_2026 ] ex:Event . xia |
+-------/----------------------------+
[ xic ] ex:circa ex:June .
The interpretation is something of a par relation or probabilistic
expectation on event ostension .
'par' is a disjunction of semantic relations , like inner v. outer ,
or in-situ against ex-situ , where one scope compares to the other .
It may be said to be 'associative' because it is not yet determined in
a direction as 'hierarchical' .
Logical quantification is expected to bind scope over ex:Event .
There was an event (more or less around June sometimes).
Not: there was a year .
The next example will not parse as imagined .
<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:ns1="ns1:"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:qcm="http://qab.mE.law/2036/05/16-rdf-syntax-ns#" >
<rdf:Description about="ns1:qsa" >
<ns1:qpa rdf:resource="ns1:qoa" rdf:ID="xia" qcm:XI="xic" />
</rdf:Description>
<rdf:Description about="#xic" >
<ns1:qpe rdf:resource="ns1:qoe" rdf:ID="xie" />
</rdf:Description>
</rdf:RDF>
qcm:XI is the *ID2 keyword .
I hope that it is plain how contrived and imagined the extended
namespace 'qcm' is .
It would unify with 'rdf' if ratified .
Obviously , misusing 'rdf' will be problematic for XML .
There could be 4 such *ID2 keywords if multiplied by each reification part ..
id-s
id-p
id-o
id-t
Or , a partitive selector might be employed on a rdf:Description
element for a triple's object .
There might be decreased runtime efficiency in serializing RDF/XML for *ID2 .
Someone should suggest a better name too .
#mh-x-1
Edge properties or property sets are being considered as annotations
(attributions) of reifications of asserted triples.
Many of the examples and use cases employ an annotation shape for
hierarchical interpretation.
Attributions are subordinate to a superordinate identifier; this is
hierarchy in a metalanguage.
There are other practical options for refactoring.
A first mode of modification is to edit , like in a text editor or
code generation utility.
Another way of some lower rank , is to justify employment of *meta-syntax .
Using annotation without justification for meta-syntax suggests
read-only access, and cross-domain named-graphs .
Reification is cross-domain , whereas rdf:ID , xml:base & named-graphs
imply copies for refactoring [16].
Other modes of refactoring already mentioned are pivoting into the
subject of reification as a named-graph & xml:base
distribution-law/variants .
Both of those are interesting approaches and their justifications bear
on arguments for this reification shape.
Read-only access does preclude xml:base strategies in the original
namespace as would be controlled by HTTP.
Cross-domain reification seems to connote authority, authorization,
trust, or proof in establishing an argument, which is still
speculative for the data activity even after canonicalization .
#mi-x-wff
Those examples in the email survey or summarize syntax and usage
differences of LPG compared to RDF [45].
Emphasize that Examples A & B are not RDF languages but have names
diminutive of RDF correspondence .
It might not have reasonably followed that any particular shape is a
more correct interpretation .
Ora Lassila followed up later in the thread on the potential for
worsening divergence .
But I read [45] as a summary about syntax differences between RDF & LPG .
If I have to decide whether my writing was merely dense , terse or
senseless , then that larger question is like unto denying a fact,
versus denying a theory.
So it seems that my role is to be "politely assertive" in affirming
the fact/shape [17] in #mc-x-rdfxml .
Sorry that I didn't post it the first time.
Beyond facts, beyond a shape, is of course more debatable .
Reasoners not spanning named-graphs is news to me [50] .
Any prior use of "dataset" by me was probably incorrect , and should
be 'named-graph' .
I have misunderstood some of the new terminology.
The preposition 'at' (or locative case) goes with ostension .
Concede that RDF* blank node in EX:C is not the focus compared to a
RDF11 named-node or fragment identifier .
In other words , assume that blank-node subjects of reification are
feasible without understanding why blank-nodes are not well-formed in
the "predicate" (QP) (2nd) component of (asserted) triples .
It seems that there is another class of deviant reifications wherein
the object component of rdf:predicate triples is a blank node ; it
could not be literally asserted de-re .
Posit that this shape is another option to examples A B C when the
subject is known to pertain to a particular component .
Such a pattern is likely to see use when there is a
realistic/intensional/nominalistic/descriptive component asserted
with/to a literal/extensional/data component .
In other words , some components are representative of application
context , whereas others are explicit about software internals .
These propensities guide refactorings and revisions in SDLC .
Considering the marriage of Alice & Bob = :r ,
What is the scope of :r :start & :end <dates> ?
It could be the case that :Alice has deceased , or that :Bob initiated divorce .
It doesn't say whether the person or the property or both are within scope ..
What it does say is that some event with subjects (A,B)&(B,A) was
ostended to from time to time .
These are aspects of (empirical) positivism , in that no negations or
falsehoods are asserted .
No rules of inference are asserted .
The operations of interpretation that explain could only be "in data"
when associated as an object-language (XSLT/XPath) and therein
evaluated to query/traverse "nearby" shapes by prearranged relative
path bindings .
Inference for a collection of statements (annotated) remains the
responsibility of software using a triplestore .
There are few or no general semantic entailments to make or else I
speak in haste .
Distribution combinations of ostension cross event might form a
superset of formal language generation for use in writing inferences .
This shape merely abbreviates a path traversal that software is likely
to design into implementing inference .
#mj-x-walkthrough
The counterexamples and 3rd subject of reification have been removed.
The "tag" names have been retained to match prior.
Some have recommended not using subtags with vowels to discourage enunciation .
The validator prefers absolute names; hence using a custom prefix.
Using 'ns1' rather than another prefix suppresses a quirk on my
triplestore, so whatever.
The actual expansion of 'ns1' is 'ns1:' , which is not a full URN
syntax, but there is no de-referencing and the validator is accepting.
Triplestore loading may report 11 triples & 8 resources.
1 is by entailment , the other 10 are in syntax .
#mk-x-definitions
Some definitions for referring to procedures follow.
These procedures may be types of query, search, or retrieval within a
triplestore.
Or they may refer to software utilizing a triplestore .
To quote or disquote is an inverse relation of the other.
There is a mode of expectation which is unambiguous/singular
correspondences in instants of reification .
The syntax does allow others .
Another mode of reification , which is not yet singular is that of
partial statements.
A partial statement may only define some and not all of the reifying triples .
For example, it may define a subject & predicate but not an object,
because a process which consumes the database will evaluate the
application of the predicate to the subject in order to calculate what
the object is equal to.
Lexemes of "to index" or "index of" are a term meaning total
enumeration and collection of a class of statements.
Syntax also permits (less likely) uses of subjects of reification in a
mode of plurality or deviance .
Consider the following overloads per just one subject of reification .
If disjunction is only on one of all reifying triples (rdf:object),
then all of the projects can be resolved.
It might be that the subject of reification's name says nothing of
what de-re is there.
However, if multiple reifying triples have disjunctions, then their
projection is a product which expects exhaustive combinations of
de-re's .
Considering plurality, it seems that hierarchical composition ought to
collect (Seq,Bag,Alt) subjects of reification from multiple instants
of reification , rather than overload by de-re .
Concepts of 'substrate' and 'metadata' are salient to final or
terminal graph shapes .
subjects of reification index what is their 'de-re' , plain assertion
statements.
A triplestore implementation is implicitly an index of assertions .
However , a graph may shape its own index , or subgraphs within
meta-syntax facilities .
"yonder" is past both 'this' and 'that' .
the formal indication of a 'horizon' is disjunctive introduction ; rel. OWA .
'discrete' and 'atomic' are adjectives comparable to integers .
'reificiation vocabulary' is the type of identifiers used as triple
components to instantiate a reification .
It includes the following (compact) forms: rdf:subject , rdf:predicate
, rdf:object , rdf:Statement & rdf:type .
'component reification vocabulary' is: rdf:subject , rdf:predicate ,
rdf:object .
These were prior abbreviated as QSQ , QPQ , QOQ .
Its misuse can express deviant instants of reification .
'deviant reification' is an instance of reification with any
alteration from an rdf:ID production shape .
'partial statements' are deviant reifications which lack connections
to some but not all reification vocabulary .
Some deviant reifications could recover unique statements despite a
non-unique identifier for those statements when, 1) only one component
reification vocabulary term is in multiple assertions , or 2) there is
a total product of combinations for each plurality of component
reification vocabulary .
A primer on reification/reference might include an extended concrete
type of a graphics pixel .
That pixel used like a hyperlink , connects a user interface element
to other information such coordinates , color & layer .
Such is that in graphics software layers may undergo linear
combination operations but not be finally rendered at an operand's
value unless by requested inspection of a layer .
This pixel demonstration indicates discouragement of deviant reification .
Otherwise it is diminutive of HTML image map .
A 'partitive selector' e.g. "[]" in diagram below is a unary
superordinate element superimposed upon a component of triple syntax
for specifying which intersecting identifier is asserted as part of a
2nd reification instance .
The behavior of a partitive selector over/on/of a subject of 1st
reification is undefined and should probably be a syntax error because
it does not correspond to any triple part of its reification instance
..
'approximation' can connote precision but a Taylor Series formula
example is sin(x) ~= x^3 .
'transpose' is a matrix operation , but in RDF it must be procedurally
extended so as not to conflate object components .
Iterating over asserted triples to swap only the first two components
is a start .
A 'functor' despite other definitions intends a predicate or function
that is defined totally by its inputs and outputs in data .
'Dereferencing' is a procedure used to access an entity by its
identifier , e.g. http & application/xml .
'Reification' is an instantiation relation which itself instantiates
definitions to entities , unless deviant in which case the name in the
'instant of reification' is not a unique identifier .
'instants of reification' have no state beyond their assertion .
A 'subject of reification' is the identifier of an instance of reification ..
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ns1: <ns1:>
SELECT * WHERE {
ns1:qsa ns1:qpa ns1:qoa .
?xia rdf:subject ns1:qsa .
?xia rdf:predicate ns1:qpa .
?xia rdf:object ns1:qoa .
}
LIMIT 1
'de re' is the hypothesized statement (which may or may not be
asserted) in the objects of 'component reification vocabulary' ; not
rdf:Statement .
'de re' is nearly similar in meaning to 'disquotation' , except a
'subject of reification' is a node equivalent to the parse of a
quotation (structure) [47] .
'de re' is an inverse relation of finding the 'subject of reification'
from an instance of reification .
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ns1: <ns1:>
SELECT * WHERE {
<ns1:#xia> rdf:subject ?qs .
<ns1:#xia> rdf:predicate ?qp .
<ns1:#xia> rdf:object ?qo .
?qs ?qp ?qo .
}
LIMIT 1
Prior , I had said 'reifier' for 'subject of reification' and actually
'reifier' is a developmental provision for quotation .
'transpose' is a matrix operation , such as iterating a named-graph
for 1-to-1 triple replacement , especially for ostensive propositions
rather than descriptive predicates .
Qs qp Qo . # retract
qp Qs Qo . # assert
Issues with built-in vocabulary like reification are left undefined
(not argued) .
An issue with aligning noun-phrases & verb-phases with space & time
ostension is that natural language permits a morphological analog to
'transpose' called 'nominalization' and 'verbing' when attempting to
resolve its applicability to descriptive predicates .
#ml-x-history
I still don't know of any "logic" besides RDF that makes semantic
differences between all three terms: subject, predicate, object.
Arguably it seems that RDF doesn't make semantic differences between
components , but rather only makes syntactic differences between s p o
..
These terms are from grammar, philology or linguistics, but have all
seen usage in formal logics.
Those usages inform conventions of interpretation into symbolic logic.
The pre-Socratic Diodoran conditional appears to have the same
truth-table as the modern material-conditional [18].
Aristotelian syllogistic-logic was only subject & predicate.
Linguistic objects are multiplied into syllogistic predicate combinations.
First-order logic usually says predicate & object.
Linguistic subjects are first-order objects to predicates (typically
1st argument).
1-ary predicates are also called 'monadic' , pertinent to Syllogistic
& Venn diagrams.
P.F. Strawson contracts some synonymous phrases to form a "subject"
for first-order [19].
He cites W.V.O. Quine from 1970 `(subject-term) , but the 1969 edition
of Quine is missing that word [20].
Strawson seems to say that an individual-variable (of a predicate) ,
in so far as it is defined as a discrete set , has elements of
singular subject terms.
By substitution rules, grounding a variable as any of its constant
variants makes an object into a "subject" .
A monadic diagram might depict this as = variable:container::variant:point .
Other interpretations of existential-quantification in first-order
require computation to use subsumption, which has a lot to do with
some of the work on OWL [21].
I wasn't going to get into all of that here, in part because I usually
think that the locution "some" does intend this (more-complicated or
physical) Real-Number domain precision.
The point that I'm trying to drive in this section is how this
Strawson-Quine precedent influences the interpretation of triples,
especially working within monotonicity.
Bivalent predicates are slightly redundant in CWA , because
containment is sufficient to assert their truth.
Qs qp "true"^^xsd:bool . # qp(Qs).
When taken with the option of rdf-objects to be rdf-literals
(primitive datatypes) it goes against rdf-predicates evaluating to
truth-values (boolean) because operations corresponding to other
datatypes (e.g. numeric) are said to be "functions" .
You might not want to reuse monotonicity to evaluate the object if
your predicate is a partial function or ever maps to FALSE.
Such a disadvantage is that of 2-ary predicate interpretations.
ex:Bob ex:says-sorry ex:Alice .
The major advantage for logic is that a function defined piecewise as
a functor is that other datatypes (e.g. numeric) are wrapped as a
bivalent meta-predicate (boolean).
( ex:Bob , ex:Alice ) ex:says-sorry "true"^^xsd:bool .
An annotation of this might be interpreted as retraction .
ex:Bob ex:says-sorry ex:Alice {| ex:not ex:sorry |} .
But that is not the RDF model which said to permit paraconsistency.
It only indicates going back to the subject list translation .
( ex:Bob , ex:Alice ) ex:says-sorry "true"^^xsd:bool .
( ex:Bob , ex:Alice ) ex:says-sorry "true"^^xsd:bool {| ex:not ex:sorry |} ..
#infers
( ex:Bob , ex:Alice ) ex:says-sorry "false"^^xsd:bool .
#raises inconsistency
That makes an rdf-subject a source to the rdf-predicate , which
evaluates to the rdf-object.
A source of a domain has been defined as the parameters passed to a
function or predicate .
Some programming languages permitted associative/dictionary parameters
that could be reordered by naming attributes [37].
That can make compound (multiple) arguments within a subject like a
named-graph, although moreso for ostension.
<ex:Subject-65525119> <ex:from> <ex:Bob> <ex:Subject-65525119> .
<ex:Subject-65525119> <ex:to> <ex:Alice> <ex:Subject-65525119> .
<ex:Subject-65525119> <ex:quoth> "sorry" <ex:Subject-65525119> .
<ex:Subject-65525119> <ex:says-sorry> "true"^^xsd:bool <default:main> .
<ex:Subject-65525119> <ex:says-sorry> "true"^^xsd:bool <default:main>
{| ex:not ex:sorry |} .
#infers
<ex:Subject-65525119> <ex:says-sorry> "false"^^xsd:bool <default:default> .
<ex:Subject-65525119> <ex:quoth> "not sorry" <ex:Subject-65525119> .
It is trivially conflated on absence-of-information versus
information-of-absence .
An extended <ex:Subject-65525119> is not closed .
It ought to be copied to <ex:Subject-65525120> and therein extended by
inference .
<ex:Subject-65525120> <ex:quoth> "not sorry" <ex:Subject-65525120> .
<ex:Subject-65525120> <ex:says> "true"^^xsd:bool <default:branch> .
It ought to factor the predicate down to the copula <ex:says> .
The revisions compare languages <default:main> versus <default:branch>
(inclusive disjunction).
says_sorry(65525119)@main vel says(65525120)@branch .
The languages of @main versus @branch are not procedures within the data.
It intends that @branch is a better interpretation (strict inequality) .
( says_sorry(65525119) < says(65525120) )@default .
But the concept of ranking language scores relies on the charity of
the reader if not for a linguistic survey.
So much for subjects, objects, domains, ranges.
But philosophical logic holds similar conventions for adverbs as well.
It is as if they can be translated like adjectives, or modifiers of events.
Walk(Sebastian, <t, slowly, aimlessly, in-Bologna>)
(1) Sebastian walked slowly at t
and Sebastian walked aimlessly at t
and Sebastian walked in Bologna at t.
[27]
But note that of Sebastian, the language is still a tree structure.
Copula modification is passed as an argument just like <ex:quoth> .
Walking is not so much an action, as it may be a superordinate event
ostended to time t.
These decisions make the existents of different types.
Sebastian is a continuant constituted of matter.
But an event is ... extended in space and time.
So walking is an event type of ... energy or work ?
Carnap would call 'Walk' a descriptive predicate [28].
It is supposed to be self-evident that it is impractical to measure .
But now there are digital pedometers and map overlays and so the
question of how to quantify reference to a linguistic object is mired
in research .
It is easier to say having these tools, that the procedural decisions
look more like knowing when and where the proverbial "walk" started &
stopped because everything material is always somewhere .
In contrast to the y(x)=z order influenced by linguistics, there is
also a s=p(o) convention following mathematical notation.
The OWL2 TR uses an argument list in the object-position [29].
So the only contract which is prescribed for the "proposition" of a
triple inside monotonicity is that it is a structure appropriate for
the interior of a model.
That is all cases .
Semantic consequence or model-theoretic validity is noted as a
double-turnstile symbol .
A typical data interpretation is that of extensionally defined functors.
But, it doesn't even have to be an atomic formula.
The 3-4-5 partitive components of a triple are not a propensity
determinative of all propositions , and its syntax incurs overhead
when attempting to decompose logical theory formulation languages.
A triple needn't even contain a descriptive predicate.
It may merely ostend objects "by means of systematic order-symbols --
namely, number-symbols" [28] , implicitly positing truth by monotonic
assertion.
"It differs only in taking the points two by two:
'Here is darker than here'." [30]
Note that ordinals are base-1 whereas cardinality may be zero [33].
The cyber-communicative level of meaning is that the web of data
activity is prioritized to extend the "associative" & "hypertext"
linking agendas from Memex & Augment [34] with multipurpose
matrices/rasters for personal bookmaking and gray-literature libraries
which are round-tripped from paper to digitalization and back again as
enhanced hardcopies .
There is prior art (or precedent) for manuscript copies .
Measurements of Five-Star notebook paper from 1998-2022 show
guidelines for folded booklets though paper-cutters, photocopiers, and
long-reach staplers, but the line colors are also amenable to digital
removal [48] .
How the guidelines show this, is by correspondence to a
rotate-to-landscape & scale-down-2-pages formula.
(8.5/11)^(-1)*5.5=crop-width/space-between-"red"-vertical-lines
The ideal locations for crops are already centered correctly as
colored guidelines usually within 5 hundredths of an inch.
There is no public software capable of post-processing such scan data
by feature recognition .
It seems to be a convenience anticipated by the manufacturer.
The mnemonic/rhyme@en in the decimal places (given by calculator)
hints a correct solution.
But since the formula is derived from the standard US-Letter paper
size , it implies that the booklet-fold problem was at least as old as
8.5inx11in .
It's not clear whether it was even informed by photography (see L.
Carroll & B. Russell) or photocopies (see Minsky) .
I'm not in a position to demand information from others who have
interests in reselling their private productivity .
Word processing and typesetting are considered solved problems.
And basically practice is worth more than presentation if it takes
this much effort .
It is usually held that tolerance for mistakes and proclivities of
otherwise logical & intelligent people is a virtue [35].
#mm-x-analysis
Your parser may report 11 triples like the validator does.
However, the intent was 10 triples .
Validator repeats one line in the triple list.
Number Subject Predicate Object
4 ns1:#xia rdf:predicate ns1:qpa
6 ns1:#xia rdf:predicate ns1:qpa
I hesitate to say that this is an error because the Validator does not
say "distinct" nor "unique" .
Back to a triplestore sparql endpoint, the eleventh triple is either:
rdf-entailment: rdf:predicate rdf:type rdf:Property .
or
rdfs-entailment: ns1:#xia rdf:type rdfs:Resource .
This seems to be entailment regimes.
#mn-x-diagram
The 'ASCII art' does use containers & edge lines.
However, these do not denote custom predicate names such as: qpa, qpe.
These drawn features may be considered as lines , backgrounds or highlighting.
The box '|+-' around assertion aaa is a 1st reification ; subject of
that reification: xia.
The diagonal '[/]' is a 2nd reification; subject of this reification: xic .
This reification of part of that reification is stroked down from
yonder asserted predicate .
Diagram depicts intersection of the box & the diagonal .
+---------------------+
| qsa [qpa] qoa . xia |
+----/----------------+
[xic] qpe qoe .
<ns1:qsa> <ns1:qpa> <ns1:qoa> .
ns1:#xia rdf:type rdf:Statement .
ns1:#xia rdf:subject <ns1:qsa> .
ns1:#xia rdf:predicate <ns1:qpa> .
ns1:#xia rdf:object <ns1:qoa> .
ns1:#xic rdf:type rdf:Statement .
ns1:#xic rdf:subject ns1:#xia .
ns1:#xic rdf:predicate rdf:predicate .
ns1:#xic rdf:object <ns1:qpa> .
ns1:#xic <ns1:qpe> <ns1:qoe> .
The main takeaway about diagrams is that one must remain critical
about what the legend defines [22].
Containers, especially sub-containers like ovals or perpendiculars,
must be read as having a formal language.
They must be interpreted like a layer or background that changes
expectations about shapes through them.
What can be seen from the numerous LPG/RDF-star examples & use-cases
is that these compositions have features of both singularity and
hierarchy.
In the case of the intersection depicted here, there is hierarchical
inheritance of xia.
Paths and arguments from xia can comprehensively define xic by having
selected [qpa].
Languages inside or outside of diagrammatic containment are not so
dissimilar here.
Rather, one is a fragment of the other, or one is a metalanguage for
an object-language.
#mo-x-graphs-only
It would be even more astonishing if only graphs, and not trees, are
capable of such a pivot on reification.
The shape is still acyclic .
What is the difference between the subject of reification and a
hierarchical node in a tree, like <body>?
I'm not sure that I'm ready to define that.
RDF is the only source by which I know the graph interpretation of a
node for a quote , which is said to be the subject of a reification .
In hypertext, moving toward the root <html>, many nodes are not
visible like text-nodes are .
Where occurrences or tokens (or characters) all print visibly , the
root node is the whole string .
Subdivisions of the string into sub-formulas are as if tracing
concentric containers on a surface.
It is quite another matter, whether there are rules for making all
nodes render visibily .
Quotation is moving up a parse-tree toward its root.
de-re is moving down a tree toward its leaves .
What is it to reify something perpendicular to these invertible directions ?
That's what #xic does .
The graph interpretation of container access is (coincidentally) also
3-ary for reification triples .
Reifying triples of #xia yields 4 parts .
#xic is a subject of reification of 1 of 4 parts of #xia's instance .
The diagram has extended rules for interpreting the part-whole
relations cross a reification instance .
Parts of a sub-graph are multiplied times parts of triples, wherein a
diagonal can be found .
This makes sense because of what computable processes can do with a
database as an object-language .
A subject of reification used in an application, may alter by relation
or translation to another language therein.
What would happen if these were equivocally valued as their own
identifier language tagged?
<ns1:#xia> rdf:value "ns1:#xia"@XML .
<ns1:$xic> rdf:value "ns1:#xic"@XPath .
This might work if with both string and tag , but its not quite correct .
Inside RDF, the subject of reification's "language" is the selfsame as
RDF (IRI) .
It doesn't need a "language" because it is already within a graph's language .
Hence, it is said that RDF is its own *meta-syntax .
Outside of RDF, the subject of reification names a model suggestive of
graph shape, and queries that can be formed from its name (its type,
and so on ).
Admittedly, the metalanguages for a 1st subject of reification's
entity , versus a 2nd subject of reification's entity , are slightly
different in the examples here .
Here is what the equivocal langString values should be .
In the 1st, #xia, it shows @XML .
<?xml version="1.0" encoding="UTF-8"?>
<rdf:Statement rdf:ID="xia"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
<rdf:subject><qsa/></rdf:subject>
<rdf:predicate><qpa/></rdf:predicate>
<rdf:object><qoa/></rdf:object>
</rdf:Statement>
Notice that although the rdf namespace is reused , this is not rdf/xml
and will not load in a triplestore .
It is still well-formed XML that hints of correspondences to RDF .
In the 2nd, #xic, it shows @XPath.
/rdf:Statement/rdf:predicate/qpa
Or:
/rdf:Statement[@rdf:ID="xia"]/rdf:predicate/qpa
These were tested on the XML above .
Hopefully , you will concede these examples are representative of
classes of similar software , although it is more difficult show .
There is an irony to language tags being used to describe such
inter-formal-language mutations .
They are effectively still relations , although 0-ary or at least grounded ..
It's not that rdf datatype (^^) components couldn't also be so e.g.
URL parameters .
But that RFC-4647 tag query permits Kleene star bindings .
So the browser has a query language for tags without recourse to a
triplestore [46].
Supporting this argument cites Quine, whom in turn cites Frege.
"These contrasts, then, have emerged between general terms and singular terms.
First, the ostensions which introduce a general term differ
from those which introduce a singular term
in that the former do not impute identity of indicated object
between occasions of pointing.
Second, the general term does not,
or need not, purport to be a name
in turn of a separate entity of any sort,
whereas the singular term does.
"These two observations are not independent of each other.
The accessibility of a term to identity contexts was urged by Frege(3)
as the standard by which to judge whether
that term is viewed as subject in that context to the algorithm of identity:
the law of putting equals to equals." [23]
In other words, any time an identifier is used inter-language, it
presumes translation is possible .
Usually an immutable string is presumed .
But there have been libraries which sought to transliterate naming
conventions, like from JavaScript camel case to XML snake case .
The problem of translation could go further .
By supplying a requested language with the identifier it might permute
the entity .
That makes it sound like getting langStrings in EMCAScript is good for
interoperability .
The examples above are to presume some software which operates on data .
XML and Xpath are sufficient , but it could have been any
general-purpose language .
By the time a statement is assigned to a programs' variables , they
are in a tree parse .
By the time an object traverses into a property to modify it , that
path is designed into its function .
Wherein those parts of a program are constant , they could reenter a database .
Reentering removes the program's process & predicates a symbol for it
(@XML or @Xpath) .
Untagged identifiers as triple components inherit something like *@rdf
from context .
This in part explains why URLs are so long is that they are intended
to be globally context-free .
To some extent , schemes already perform these operations [38] .
The 'tag:' scheme placeholder might be repurposed for an eval call [39] .
#x-tag
Reification, Quotation, token, referential opacity are lexemes
(phrases) which occur in several of Quines works.
Some of these are originally from prior philosophers, Frege, Pierce,
Tarski, et al.
However, Quine's books are also notable for their early computer art
within the book design.
The Leptonica Project calls one of these algorithms "seed fill" [32].
The Harvard paperback of "Elementary Logic" cover is framed like an
ANSI standard publication circa mid-1970s. [25]
The Open Court "Roots of Reference" has his portrait aligned opposite
page a similar border.[30]
You might say this is reading too much into it, but having tried it
myself, it does help with processing a document image using existing
graphics software ( image processing , cropping ) because of paper
edges .
So one of the follow ups for that ought to be looking though
micro-graphics (microfilm) standards.
I remember those devices from the 1990s in the back of the library
winding away. I still haven't used one .
This anachronistic speculation that a computer program could read a
notebook (manuscript) is something like antique vaporware.
It might mis-recognize that the tape was authored by Scotch, much like
characters can be recognized optically (OCR).
#x-anachronism
With all the publications available, it would seem as if the assembly
ought to have all significant options on the table already.
That seems precarious for any arrogance to predicate a solution as as
yet undiscussed.
Yet, given the repetition of other patterns, yes, it would seem as if
*ID2 (or this shape) may not have been a use case .
It might be raised, only to be marked as out of scope of the assembly's agenda .
It might be relegated to a test case .
I would guess that something similar would have appeared in a journal
of categorical mathematics within the past 50 years.
There is no sense in claiming originality without research into "prior art" .
#mp-x-graphics
The point that I raised on the Charlottesville list was that , if the
framework has similarities to graphics and computer vision , then
there may be a large amount of underutilized hardware in the form of
"embarrassingly parallel" processors (GPU, FPA) that in principle
could have been adapted toward the abstract syntax in response to
market demand.
This was in reply to an ostensive topic of <html:img alt=""> circa 2023 [31].
The main implications to suggest are those of permissions and exceptions.
#mu-x-article
There is a review article of Quine by Peter Hylton (chapter 5) in CCQ [40] ..
The topic on "Reference and Ontology" is close to this one .
Although it could have easily been less relevant, Hylton's citations
of primary sources show attention to finding mathematical
interpretations .
What those block quotes say , is wanting in detail , but I wanted to
pull a couple out because they are not technically wrong nor against
this .
Although Quine speaks of reification , and it has nearly the same
relation to quotation that this assembly has taken , there isn't a
graph-theoretic definition of reification vocabulary like there is
around RDF .
There are indications that Quine understood the similarities between
matrices and paintings as discrete samples [49] .
But there isn't a readily apparent connection of that to expository
prose of first-order logic .
Things (reified) are some singularity of an object in a field .
That doesn't quite match 2nd-reification of 1st-reification because
the de-re of the 2nd is an object language .
Quine does speak of "linguistic objects" .
But usually the discussion sounds of-science unless misread as a metaphor .
That is science objects until reified as qualities or measurements .
Numbers are reified .
On regimentation , the formality of quantification is compared to (an
informality of) "focus" .
Quine is of course aware of binocular vision and its history with
George Berkeley & Frege .
Is "focal" to be read as a metaphor ?- Or as having a frame from
perception of XYZ Cartesian coordinates ?
Arguably , ocular focus is not in use for imagination , therefore it
connotes cognition .
Provisionally, I would offer that it is not clear which natural
language example requires such a graph shape as opposed to a tree
parse .
We don't know how to say it without it being also taken simpliciter,
even if it can be given with a pictorial communication .
Here's what Hylton found Quine saying:
"Suppose I speak (what appears to be) the object language
but translate you as speaking the complement language.
Someone else can with equal justice claim that
I am in fact speaking the complement language
so that when I translate you I am actually attributing to you the
object ontology,
not the complement ontology.
We seem, in short, to be in danger of a regress.
I translate your use of the word 'Rover' as referring to the
space-time complement of the family dog, but if my words themselves
are subject to various translations, what claim do they actually
make?"
p.140 Hylton
"Reference goes inscrutable if, rocking the boat,
we contemplate a permutational mapping of our language on itself,
or if we undertake translation."
--p.142 in Hylton , Quine "Theories and Things" p.20
Mapping language onto language is the problem , but not at the level
so large as lexicon.
Those complements are very large as well .
Requesting to understand by negation or cycles indicates translations
that may not complete to a sound conclusion .
Missing examples seem agreeable to Hylton's thesis that we don't know
how to 'type' entities to be discrete and explanatory .
"Each utterance is contextualized by its preceding utterances ,
and its potential future utterances form part of the context horizon
of each present utterance . "
[42]
There is no difference in (*meta-)syntax for computers between
referring versus relations .
I'm sorry in advance for the typographical errors , awkward &
non-technical constructions .
Before , I said "accessor" w/o realizing it was in terminological use in a TR.
It nearly meant C-style OOP object accessor syntax like in JavaScript
, which has been replaced here by Xpath.
xml:base in RDF/XML hasn't been tested .
The most likely objections are that reference , either as a type or a
property chain , belongs to another vocabulary or entailment regime ,
in order to make the shape .
That or , or the application is weakly defined , with low utility .
Much of this is guesswork about where to go next , which the assembly
probably doesn't need to hear .
#g-x-biblio
[1] https://search.worldcat.org/title/530617 p.115
https://search.worldcat.org/title/1430032
Also 8th rev. ed. New York: Harcourt Brace 1946
Also New York Harvest Books 1960
Pertinent not from [1]: https://search.worldcat.org/title/1138618881
[2] https://asd-ste100.org/
[3] https://librdf.org/
[4] https://www.w3.org/TR/2014/REC-rdf-syntax-grammar-20140225/#idAttr
[5] https://github.com/w3c/EasierRDF/issues/22
[6] https://www.rfc-editor.org/info/bcp47/
But see also RFC-6497, RFC-6067, OMG-LCC, ANSI/NISO Z39.53:2001, Unicode-LDML.
[7] Find substring "abstract object" in
https://www.w3.org/TR/2014/REC-rdf11-mt-20140225/#reification
https://www.w3.org/2003/glossary/keyword/All/resource.html?keywords=resource
Candidate coordinate terms are 'linguistic object' , 'object language' .
[8] https://www.w3.org/TR/2014/REC-rdf11-mt-20140225/#rdf-interpretations
[9] Kelly https://search.worldcat.org/title/680469452 p.33
André Breton in Gutting https://search.worldcat.org/title/45195854 p.102
[10] https://www.iso.org/obp/ui/en/#iso:std:iso:5127:ed-2:v1:en:term:3.1.7.08
[12] Pan https://doi.org/10.1007/978-3-540-92673-3_3 p.77
[13] Lloyd https://search.worldcat.org/title/11186391 pp.26,30
[14] https://www.iso.org/obp/ui/en/#iso:std:iso:5127:ed-2:v1:en:term:3.1.11..09
https://www.iso.org/obp/ui/en/#iso:std:iso-iec:2382:ed-1:v2:en:term:2123831
[15] Kleene https://search.worldcat.org/title/474898002?oclcNum=474898002&p=63
[16] https://lists.w3.org/Archives/Public/public-rdf-star-wg/2023Apr/0022.html
[17] https://www.iso.org/obp/ui/en/#iso:std:iso:12616:-1:ed-1:v1:en §10.8 .
[18] Sanford https://search.worldcat.org/title/18948731 p.27
[19] Strawson https://search.worldcat.org/title/1193127 pp.4,11
[20] Quine https://search.worldcat.org/title/816815691 p.62
[21] Marriott https://search.worldcat.org/title/37631225 p.413
[22] https://w3c-cg.github.io/rdf-star/presentations/RDF-star_Lotico.pdf
[23] p.75 Ch. IV "Identity, ostension, and hypostasis"
in Book "From a Logical Point of View"
https://search.worldcat.org/title/6412573
Feigl https://search.worldcat.org/title/1540003
"Referential opacity" is in another chapter of Quine.
[24] -- p.viii "Philosophical logic" John P. Burgess .
https://search.worldcat.org/title/276141382
[25] Quine https://search.worldcat.org/title/52429883
https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub33-May1974.pdf
[26] Dreyfus rev. ed. https://search.worldcat.org/title/1513768650 p.35
[27] p.164 Quine in https://search.worldcat.org/title/1595344363
[28] Carnap LSS p.13 https://search.worldcat.org/title/884588185
[29] Click "Show RDF in examples" button under TOC.
https://www.w3.org/TR/2012/REC-owl2-syntax-20121211/#Intersection_of_Class_Expressions
[30] p.57 https://search.worldcat.org/title/26345947
[31] https://html.spec.whatwg.org/multipage/images.html#alt
(I thought that the whatwg source used to mention OCR as an example;
it does not say that).
[32] http://www.leptonica.org/filling.html
[33]See cover https://search.worldcat.org/title/934725501
https://en.wikipedia.org/wiki/Northern_cardinal
[34] https://search.worldcat.org/title/1507199094 pp.7,48,78,133,260 .
[35] https://www.borrett.id.au/computing/petals-bg.htm
[37] https://en.wikipedia.org/wiki/Named_parameter
[38] https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml
[39] https://en.wikipedia.org/wiki/Eval
[40] CCQ https://search.worldcat.org/title/52494468 p.115
[41] https://en.wikipedia.org/wiki/University_of_Mary_Washington
"Simpson Library"
[42] Landgrebe Smith rev. ed. https://search.worldcat.org/title/1484548621 p.87
[43] Abelson Sussman MIT OCW SICP (LISP) video .
[44] https://www.w3.org/RDF/Validator/rdfval
[45] https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/0019.html
[46] https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Selectors/:lang
[47] https://www.w3.org/DesignIssues/Reify.html
"not a form of quotation" in
https://www.w3.org/TR/2014/REC-rdf11-mt-20140225/#reification again
[48] https://liballeg.org/a5docs/5.2.1.1/graphics.html#al_convert_mask_to_alpha
imagemagick.org -modulate -colorspace hsv -separate
[49] Quine https://search.worldcat.org/title/441298020 p.4
[50] https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/0096.html
On Fri, Apr 17, 2026 at 5:36 AM Pierre-Antoine Champin
<pierre-antoine@w3.org> wrote:
>
> Hi Chris,
>
> to your last point:
>
> > Why does RDFMT say "from IP to the powerset of IRxIR" instead of just "from IP to IRxIR" [pairs of cartesian product]?
>
> IEXT associates a *set* of pairs to each property, that's why it is defined this way.
> If we wrote "from IP to IRxIR", it would associate a single pair to each property.
>
> For the rest of your email (below), I'm sorry, but I struggle to understand the point you are making (even after re-reading the old thread you seem be responding to).
>
> best
>
> On 13/04/2026 10:47, Chris Miller wrote:
>
> https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/0019.html
>
> 904 QS- QP- QO- XI- XD .
> 910 QSA QPA QOA XIA XD .
> 920 XIA QSQ QSA XIB XD .
> 928 XIA QSQ QPA --- XD .
> 930 XIA QPQ QPA XIC XD .
> 939 XIA QPQ QPB --- XD .
> 940 XIA QOQ QOA XID XD .
> 951 XIA QPA QBE --- XD .
> 952 XIA QPQ QBE --- XD .
> 953 XIA QPE QOE --- XD .
> 955 QBE QPE QOE --- XD .
> 967 XIC QPE QOE XIE XD .
>
> 904 sets SPOID. XI=rdf:ID (new reifier). XD=named-graph/dataset (default).
> XIA is a reifier of (QSA,QPA,QOA). XIA entails triples from 920,930,940 but not their tokens XIB,XIC,XID. Other XI* reifying statements are entailed but not restated in the table. 928 & 939 are WFF by AAA, which serve as counter-examples to 95*. (QPE,QOE) is an edge-property/property-set. (XIA,QPA) in 951 does not distinguish between 920v928. (XIA,QPQ) in 952 does not distinguish between 930v939. 953 is Example B (see link). 955 fails LPG-interop for EP/PS. 967 corrects LPG-interop for EP/PS. 953 & 967 are each a statement and both about statement 910. Call XIE a 3rd-reifier+12-statements. Enhance RDF/XML with rdf:ID2='XIC' & rdf:ID3='XIE' productions to entail:
> XIC rdf:type rdf:Statement .
> XIC rdf:subject XIA .
> XIC rdf:predicate rdf:predicate .
> XIC rdf:object QPA .
> XIE rdf:type rdf:Statement .
> XIE rdf:subject XIC .
> XIE rdf:predicate QPE .
> XIE rdf:object QOE .
>
> XIC does not need bnode-ns. Counter-examples approximate an argument about how to read translations/rewrites of EP/PS. 953 ought to be typically sufficient when taken with additional rules in an application & it reduces triple count. But there are no operators like implication, negation, nor containment through RDFMT. XIA does not preclude access to any of its linked components. LPG seems to read EP/PS as (~QSA&~QOA)->QPA , which is almost QSA xor QPA xor QOA. But this cannot mean "about QPA" like QP transposed with QS in XD. This must mean QPA within a context of 910->XIA, and hence named-graph (XD*) proposals. A distribution law translates the usage as (~XIA\QSA&~XIA\QOA)->XIA\QPA. Still, RDF does not have a procedure which copies nor relates the infix containment symbol \ of the concatenation XIA\QPA to components XIA,QPA (unless by xml:base). 928 & 939 are unlikely to be practical interlocutions, but do show that 951 & 952 cannot translate pairs into triple-queries without assuming a cardinality operator about QO of XIA. RDFMT by AAA does not make that restriction, but OWL could raise inconsistency. 953 reads XIA as possibly inheriting from how QSA or QOA are used in 910. 967 reads XIC as not making any assertion about how QSA or QOA are used in XIA, but only asserts how QPA is used in XIA. XIE equals constant accessor parameters to how a component is used in 910. Therefore rdf:ID2 & rdf:ID3 productions are a general translation for EP/PS, when decisions about reductions of total context are unclear. It ought to have an implementation effort similar to that of rdf:ID. As an objection, it could be said that, like rdf:List, rdf:ID2 & rdf:ID3 lead to unwanted verbosity.
>
> Why does RDFMT say "from IP to the powerset of IRxIR" instead of just "from IP to IRxIR" [pairs of cartesian product]?
Received on Saturday, 27 June 2026 08:52:12 UTC