- From: Martynas Jusevičius <martynas@atomgraph.com>
- Date: Sat, 17 Dec 2022 14:42:21 +0100
- To: Adam Sobieski <adamsobieski@hotmail.com>
- Cc: David Booth <david@dbooth.org>, "semantic-web@w3.org" <semantic-web@w3.org>
- Message-ID: <CAE35Vmwa2qsKLk18G8rKrAnjhgyTF1pSmd-GMMifQiCgGP0g9w@mail.gmail.com>
For read-write Linked Data mapping to SPARQL, based on URI patterns and
with parameter support, you can take a look at Linked Data Templates.
https://atomgraph.github.io/Linked-Data-Templates/
On Thu, 15 Dec 2022 at 02.47, Adam Sobieski <adamsobieski@hotmail.com>
wrote:
> When reading a traditional function (e.g., C/C++/C#/Java/JavaScript), the
> statements in “{}” brackets are to be interpreted as occurring in a
> sequence. When reading a graph, the contents of “{}” brackets are to be
> interpreted as a set. Accordingly, the concept of a function which returns
> a graph faces an uphill battle in terms of syntactical clarity when using
> “{}” brackets. I will think about clearer examples.
>
> Here are some sketches of templates, macros, and functions which utilize
> the “{}” brackets to produce sets of nested contents.
>
>
>
> @prefix list: <http://www.w3.org/2000/10/swap/list#> .
>
> @prefix log: <http://www.w3.org/2000/10/swap/log#> .
>
> @prefix ex: <http://example.org/#> .
>
> @prefix graph: <http://www.w3.org/2000/10/swap/graph#> .
>
> @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
>
>
>
> ex:ng??(?x ?y) :graph
>
> {
>
> ?x rdf:type foaf:Person .
>
> ?y rdf:type foaf:Person .
>
> ?x foaf:knows ?y .
>
> ?y foaf:knows ?x .
>
> } .
>
>
>
> {
>
> ex:ng??(ex:Alice ex:Bob) :graph ?graph .
>
> ?graph graph:member ?stmt .
>
> ?stmt log:equalTo { ?s ?p ?o } .
>
> }
>
> =>
>
> {
>
> ?s ?p ?o .
>
> } .
>
>
>
> The intended semantics of that “ex:ng??(?x ?y)” syntax is that, for each
> valid argument for ?x and ?y, a named graph is provided with a string-based
> pattern for its URI. That is, wherever the URI-pattern is utilized, a named
> graph is provided with contents as described, in the above case, four
> statements.
>
>
>
> When I look at that sketch, I want to extend it to include guards for the
> input parameters, as if it were a function. I want to express that ?x and
> ?y must be rdf:type of foaf:Person and distinct individuals for the
> arguments to be valid. One complication is that there is a matter of "in
> which graph or dataset(s) must these conditions hold"?
>
> Maybe we could add a named graph parameter into the mix? With a URI-based
> named graph, we could use a syntax like “ex:ng??(?kb ?x ?y)”.
>
>
>
> @prefix list: <http://www.w3.org/2000/10/swap/list#> .
>
> @prefix log: <http://www.w3.org/2000/10/swap/log#> .
>
> @prefix ex: <http://example.org/#> .
>
> @prefix graph: <http://www.w3.org/2000/10/swap/graph#> .
>
> @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
>
> @prefix owl: <http://www.w3.org/2002/07/owl#> .
>
>
>
> ex:ng??(?kb ?x ?y) :graph
>
> {
>
> @requires ?kb holds { ?x rdf:type foaf:Person } .
>
> @requires ?kb holds { ?y rdf:type foaf:Person } .
>
> @requires ?kb holds { ?x owl:differentFrom ?y } .
>
> ?x foaf:knows ?y .
>
> ?y foaf:knows ?x .
>
> } .
>
>
>
> {
>
> ex:ng??(:this ex:Alice ex:Bob) :graph ?graph .
>
> ?graph graph:member ?stmt .
>
> ?stmt log:equalTo { ?s ?p ?o } .
>
> }
>
> =>
>
> {
>
> ?s ?p ?o .
>
> } .
>
>
>
> Could those three "@requires" be a one-liner:
>
>
> @prefix list: <http://www.w3.org/2000/10/swap/list#> .
>
> @prefix log: <http://www.w3.org/2000/10/swap/log#> .
>
> @prefix ex: <http://example.org/#> .
>
> @prefix graph: <http://www.w3.org/2000/10/swap/graph#> .
>
> @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
>
> @prefix owl: <http://www.w3.org/2002/07/owl#> .
>
>
>
> ex:ng??(?kb ?x ?y) :graph
>
> {
>
> @requires ?kb holds { ?x rdf:type foaf:Person . ?y rdf:type
> foaf:Person . ?x owl:differentFrom ?y . } .
>
> ?x foaf:knows ?y .
>
> ?y foaf:knows ?x .
>
> } .
>
>
>
> {
>
> ex:ng??(:this ex:Alice ex:Bob) :graph ?graph .
>
> ?graph graph:member ?stmt .
>
> ?stmt log:equalTo { ?s ?p ?o } .
>
> }
>
> =>
>
> {
>
> ?s ?p ?o .
>
> } .
>
>
> With something like those sketches, above, I’m hoping to express that the
> arguments provided must be as indicated, in this case two distinct people,
> as holding in a provided knowledgebase (a named graph or SPARQL endpoint,
> ?kb). The described graph-based template/macro/function would then produce
> a graph containing two statements: “?x foaf:knows ?y” and “?y foaf:knows
> ?x”.
>
> It’s unclear what would or should happen if a template/macro/function were
> “invoked” with invalid arguments. Maybe it would or should, then, return an
> empty graph and/or maybe an error or exception would or should be thrown?
>
> What is the construct in N3 with its variables? I think of it as a
> template/macro/function. The current approach to invocation involves a
> URI-based pattern which resembles binding arguments to parameters to invoke
> the template/macro/function.
>
> What are the values which are bound to the variables? Thus far, I am using
> URIs (xsd:anyURI) in the sketches. In theory, the graph-based
> templates/macros/functions should work with built-in datatypes like strings
> (xsd:string) or numerical types (e.g., xsd:integer). So, the actual values
> bound to the variables are, thus far, URIs.
>
> Hopefully this content, above, clarifies what I'm hoping to express in the
> sketches while also introducing some new possibilities.
>
>
>
> Also, while I’m excited about the mapping which provides a means of
> accessing and utilizing query string portions of URIs, and about its
> potential uses with graph-based templates/macros/functions, one potential
> limitation of the approach is that there exists an upper limit on URI
> string length (2048 characters?).
>
>
>
>
>
> Best regards,
>
> Adam
>
> ------------------------------
> *From:* David Booth <david@dbooth.org>
> *Sent:* Wednesday, December 14, 2022 4:58 AM
> *To:* Adam Sobieski <adamsobieski@hotmail.com>; semantic-web@w3.org <
> semantic-web@w3.org>
> *Subject:* Re: Templates, Generics, and Parametric Polymorphism in
> Semantic Web Languages
>
> Hi Adam,
>
> I am not yet understanding how to interpret the examples you have given.
> To understand your suggested template syntax, I need an example to
> clearly differentiate these 4-5 things:
>
> 1. What is template prior to expansion? (Think of this as a
> function.)
> 2. Which parts of that template represent the variables
> that will be replaced with actual data during template expansion?
> (Think of these as the formal parameters to that function.)
> 3. For each of those variables, what is the actual value
> to be substituted into the template, in place of that variable?
> (Think of these as the actual parameters to that function.)
> 4. What is the final result of template expansion, after values
> have been substituted in for the variables? (Think of these
> as the function result.)
> 5. If you are also showing a syntax for invoking template expansion,
> then what part of the example is illustrating that? (Think of this
> as showing the function invocation.) The syntax needs to:
> a. identify the template to be expanded (like identifying the
> function to be called); and
> b. bind an actual value to each template variable (like binding
> an actual parameter to each formal parameter).
>
> I assume that your example included some or all of the above, but it
> isn't easy for me to see which bits are which. Could you clarify please?
>
> Thanks,
> David Booth
>
> On 12/14/22 00:12, Adam Sobieski wrote:
> > Existing query-based solutions, e.g., SPIN, could be of use for
> > expressing the preconditions and effects of operators in planning
> > domains. Beyond the processing and inferencing functionalities of
> > solutions for templates and rules, there is the comparative
> > expressiveness of the templates and rules to consider, and also the ease
> > of consuming and inspecting the templates and rules to consider for each
> > solution. I am thinking about how convenient it can be made for
> > developers to utilize a more expressive planning domain definition
> > language / ontology and its resultant APIs and object models while
> > developing next-generation planning algorithms and solvers.
> >
> > With respect to the proposed mapping for Semantic Web languages which
> > enables the access and use of URIs' query string portions, I recently
> > changed the syntax in the sketches and examples from “^^” (which had
> > some complications) to “??” (which I hope reminds developers of the URI
> > query string).
> >
> > Understanding that "ex:ng??(ex:Alice ex:Bob)" maps to a URI, here is an
> > updated example of what a /named graph template/in N3 could resemble:
> >
> >
> > @prefix list:<http://www.w3.org/2000/10/swap/list#> .
> >
> > @prefix log:<http://www.w3.org/2000/10/swap/log#> .
> >
> > @prefix ex:<http://example.org/#> .
> >
> > @prefix graph: <http://www.w3.org/2000/10/swap/graph#> .
> >
> > ex:ng??(?x ?y) :graph
> >
> > {
> >
> > ?x rdf:type foaf:Person .
> >
> > ?y rdf:type foaf:Person .
> >
> > ?x foaf:knows ?y .
> >
> > ?y foaf:knows ?x .
> >
> > } .
> >
> > {
> >
> > ex:ng??(ex:Alice ex:Bob) :graph ?graph .
> >
> > ?graph graph:member ?stmt .
> >
> > ?stmt log:equalTo { ?s ?p ?o } .
> >
> > }
> >
> > =>
> >
> > {
> >
> > ?s ?p ?o .
> >
> > } .
> >
> >
> > I am brainstorming about other new uses of and scenarios for the mapping.
> >
> >
> >
> > Best regards,
> >
> > Adam
> >
> >
> > ------------------------------------------------------------------------
> > *From:* David Booth <david@dbooth.org>
> > *Sent:* Tuesday, December 13, 2022 5:16 PM
> > *To:* semantic-web@w3.org <semantic-web@w3.org>
> > *Subject:* Re: Templates, Generics, and Parametric Polymorphism in
> > Semantic Web Languages
> > Since every rules language (including N3) in essence defines a template
> > language for the rules, I think it's worth asking: why are the existing
> > template facilities inadequate for my use cases, and how might they be
> > extended to handle them? If we can improve them to be more flexible,
> > that may be better than adding more bandaids.
> >
> > Bear in mind that SPARQL is also a commonly used "rules language", using
> > either CONSTRUCT or INSERT. ShExMap also acts as a rules language (and
> > template language), as does SPIN.
> >
> > David Booth
> >
> > On 12/13/22 16:41, Adam Sobieski wrote:
> >> Martin,
> >> All,
> >> Hello. I updated the Automated Planning and Scheduling Community
> Group's
> >> wiki to showcase /Reasonable Ontology Templates (OTTR)/:
> >> https://github.com/w3c-cg/planning/wiki/Ontologies
> > <https://github.com/w3c-cg/planning/wiki/Ontologies>
> >> <https://github.com/w3c-cg/planning/wiki/Ontologies
> > <https://github.com/w3c-cg/planning/wiki/Ontologies>> .
> >> I am also interested in computation and Semantic Web technologies. I am
> >> thinking about inspectable, reflectable, reifiable, semantic templates,
> >> macros, and functions (see also: the Function Ontology (FnO)). It could
> >> be that the reification of language-integrated semantic templates and
> >> functions would involve OTTR and/or FnO models.
> >> With respect to automated planning and scheduling, planning domains'
> >> operators' preconditions and effects can be represented as inspectable,
> >> reflectable, reifiable functions using Semantic Web technologies (in
> >> particular using n-ary semantic predicate calculus expressions).
> >>
> >> Semantic templating can be of use for implementing generic types and
> >> functions, e.g,. "Widget<T>" and "function<T>(x, y, z)".
> >>
> >> I am thinking about how best to represent conditional branching logic
> in
> >> semantic templates. These scenarios interest me in the contexts of
> >> planning domains and computer lexicons. Also interesting, with respect
> >> to OTTR, are patterns and compression.
> >> Utilizing the mapping I shared, we could do new things. While I'm still
> >> thinking about the specific syntax (e.g., "^^" or "??"), we could now
> >> access and utilize the query string portions of URIs in Semantic Web
> >> languages. I'm arguing that this would be generally useful and that it
> >> would specifically benefit the technologies under discussion.
> >> Best regards,
> >> Adam
> >>
> >> ------------------------------------------------------------------------
> >> *From:* Martin Georg Skjæveland <martige@ifi.uio.no>
> >> *Sent:* Tuesday, December 13, 2022 8:23 AM
> >> *To:* william.vanwoensel@gmail.com <william.vanwoensel@gmail.com>;
> >> adamsobieski@hotmail.com <adamsobieski@hotmail.com>
> >> *Cc:* doerthe.arndt@tu-dresden.de <doerthe.arndt@tu-dresden.de>;
> >> semantic-web@w3.org <semantic-web@w3.org>
> >> *Subject:* Re: Templates, Generics, and Parametric Polymorphism in
> >> Semantic Web Languages
> >> Hi,
> >>
> >> there seems to be enough keyword matches to allow me to mention a
> >> project that I have been working on, Reasonable Ontology Templates
> >> (OTTR), see http://ottr.xyz <http://ottr.xyz> <http://ottr.xyz <
> http://ottr.xyz>>.
> >>
> >> OTTR is a template language for in particular RDF. It does not have all
> >> the features you mention, its primary feature is to be able to
> >> compactly represent complex statements as template instances that are
> >> expanded via a simple recursive template expansion mechanim to plain
> >> RDF.
> >>
> >> Example; (using a modelling pattern from the Pizza ontology), this OTTR
> >> template instance
> >>
> >> [ ottr:of <http://tpl.ottr.xyz/p/pizza/0.2/NamedPizza
> >> <http://tpl.ottr.xyz/p/pizza/0.2/NamedPizza
> > <http://tpl.ottr.xyz/p/pizza/0.2/NamedPizza>>> ;
> >> ottr:values (x:argument1 x:argument2 (x:argument3-1 x:argument3-2))
> >> ]
> >>
> >> expands to:
> >>
> >> x:argument3-1 a owl:Class .
> >>
> >> pz:hasTopping a owl:ObjectProperty .
> >>
> >> x:argument1 rdfs:subClassOf pz:NamedPizza ;
> >> rdfs:subClassOf [ a owl:Restriction ;
> >> owl:onProperty pz:hasTopping ;
> >> owl:someValuesFrom x:argument3-1
> >> ] ;
> >> rdfs:subClassOf [ a owl:Restriction ;
> >> owl:onProperty pz:hasTopping ;
> >> owl:someValuesFrom x:argument3-2
> >> ] ;
> >> rdfs:subClassOf [ a owl:Restriction ;
> >> owl:hasValue x:argument2 ;
> >> owl:onProperty pz:hasCountryOfOrigin
> >> ] ;
> >> rdfs:subClassOf [ a owl:Restriction ;
> >> owl:allValuesFrom [ a owl:Class
> >> ;
> >> owl:unionOf (
> >> x:argument3-1 x:argument3-2 )
> >> ] ;
> >> owl:onProperty pz:hasTopping
> >> ] .
> >>
> >> x:argument3-2 a owl:Class .
> >>
> >> pz:hasCountryOfOrigin
> >> a owl:ObjectProperty .
> >>
> >>
> >> This example is found here: https://tpl.ottr.xyz/p/pizza/0.2/NamedPizza
> > <https://tpl.ottr.xyz/p/pizza/0.2/NamedPizza>
> >> <https://tpl.ottr.xyz/p/pizza/0.2/NamedPizza
> > <https://tpl.ottr.xyz/p/pizza/0.2/NamedPizza>>
> >> More templates here: https://tpl.ottr.xyz/ <https://tpl.ottr.xyz/> <
> https://tpl.ottr.xyz/
> > <https://tpl.ottr.xyz/>>
> >> Playground here: https://weblutra.ottr.xyz/ <https://weblutra.ottr.xyz/>
>
> > <https://weblutra.ottr.xyz/ <https://weblutra.ottr.xyz/>>
> >>
> >> Cheers,
> >> Martin
> >>
> >> On Tue, 2022-12-13 at 12:59 +0000, Adam Sobieski wrote:
> >>> William,
> >>> All,
> >>>
> >>> Thank you. This proposed language feature is generally useful and, in
> >>> my opinion, merits consideration across Semantic Web languages (e.g.,
> >>> N3, Turtle, TriG). I'm working on more concrete arguments
> >>> here: https://github.com/w3c-cg/planning/discussions/27
> > <https://github.com/w3c-cg/planning/discussions/27>
> >> <https://github.com/w3c-cg/planning/discussions/27
> > <https://github.com/w3c-cg/planning/discussions/27>> .
> >>>
> >>> Some clarifying key points:
> >>> 1. There exists a bidirectional mapping between the proposed
> >>> syntax and URIs/URLs with their query string portions utilized.
> >>> 2. These URIs with their query string portions utilized can be
> >>> used wherever a URI node or named graph can, across Semantic Web
> >>> languages.
> >>>
> >>> Expanding on point 1, the following:
> >>>
> >>> ex:Widget^^(ex:Foo ex:Foo2 ex:Foo3)
> >>> maps with:
> >>>
> >>>
> http://example.org/?T[]=http%3A%2F%2Fexample.org%2F%23Foo&T[]=http%3A%2F%2Fexample.org%2F%23Foo2&T[]=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> <
> http://example.org/?T[]=http%3A%2F%2Fexample.org%2F%23Foo&T[]=http%3A%2F%2Fexample.org%2F%23Foo2&T[]=http%3A%2F%2Fexample.org%2F%23Foo3#Widget>
> <
> http://example.org/?T[]=http%3A%2F%2Fexample.org%2F%23Foo&T[]=http%3A%2F%2Fexample.org%2F%23Foo2&T[]=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> <
> http://example.org/?T[]=http%3A%2F%2Fexample.org%2F%23Foo&T[]=http%3A%2F%2Fexample.org%2F%23Foo2&T[]=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> >>
> >>> and the following:
> >>>
> >>> ex:Widget^^(("p1" ex:Foo) ("p2" ex:Foo2) ("p3" ex:Foo3))
> >>> maps with:
> >>>
> >>>
> http://example.org?p1=http%3A%2F%2Fexample.org%2F%23Foo&p2=http%3A%2F%2Fexample.org%2F%23Foo2&p3=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> <
> http://example.org?p1=http%3A%2F%2Fexample.org%2F%23Foo&p2=http%3A%2F%2Fexample.org%2F%23Foo2&p3=http%3A%2F%2Fexample.org%2F%23Foo3#Widget>
> <
> http://example.org?p1=http%3A%2F%2Fexample.org%2F%23Foo&p2=http%3A%2F%2Fexample.org%2F%23Foo2&p3=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> <
> http://example.org?p1=http%3A%2F%2Fexample.org%2F%23Foo&p2=http%3A%2F%2Fexample.org%2F%23Foo2&p3=http%3A%2F%2Fexample.org%2F%23Foo3#Widget
> >>
> >>> .
> >>>
> >>> This mapping technique is recursive; templates' arguments can be
> >>> templates.
> >>>
> >>> This mapping technique is generally useful across Semantic Web
> >>> languages and enables a number of interesting and useful features.
> >>> Some of these envisioned features are powered by additional
> >>> technologies, e.g., PHP and N3.
> >>>
> >>> Pertaining to N3 specifically, while one could model templates and
> >>> their parameters as you have indicated, the proposed solution enables
> >>> N3 "named graph templates", with a rather nice syntactic sugar, as
> >>> prototyped
> >>> here: https://github.com/w3c-cg/planning/discussions/27#discussioncom
> > <https://github.com/w3c-cg/planning/discussions/27#discussioncom>
> >> <https://github.com/w3c-cg/planning/discussions/27#discussioncom
> > <https://github.com/w3c-cg/planning/discussions/27#discussioncom>>
> >>> ment-4388356 .
> >>>
> >>> While it's a work in progress, I'm excited about this one. Comments,
> >>> questions, and feedback are welcomed!
> >>>
> >>>
> >>> Best regards,
> >>> Adam
> >>>
> >>> From: William Van Woensel <william.vanwoensel@gmail.com>
> >>> Sent: Tuesday, December 13, 2022 6:48 AM
> >>> To: Adam Sobieski <adamsobieski@hotmail.com>
> >>> Cc: Doerthe Arndt <doerthe.arndt@tu-dresden.de>; semantic-web@w3.org
> >>> <semantic-web@w3.org>
> >>> Subject: Re: Templates, Generics, and Parametric Polymorphism in
> >>> Semantic Web Languages [Was Re: Syntactic Options for Probabilistic
> >>> Semantics]
> >>>
> >>> Hi Adam
> >>>
> >>> Why introduce a new syntax (I believe you had a similar discussion
> >>> before with Doerthe before on probabilities :-)
> >>>
> >>> Unsure whether I fully understand your proposal - so feel free to
> >>> criticize - but an option could just easily be:
> >>> ex:Widget tpl:parameters ( ex:Foo ex:Foo2 ex:Foo3 ) .
> >>> Or
> >>> ex:Widget tpl:parameters ( [
> >>> tpl:label “param1” ;
> >>> tpl:value ex:Foo
> >>> ] [
> >>> tpl:label “param2” ;
> >>> tpl:value ex:Foo2
> >>> ] [
> >>> tpl:label “param3” ;
> >>> tpl:value ex:Foo3
> >>> ] ) .
> >>>
> >>> A set of N3 rules could then directly operate on these parameters (as
> >>> they are also written in N3) to instantiate the template.
> >>>
> >>>
> >>> W
> >>>
> >>> > On Dec 12, 2022, at 10:58 PM, Adam Sobieski
> >>> > <adamsobieski@hotmail.com> wrote:
> >>> >
> >>> > With respect to syntactic possibilities for templates, generics,
> >>> > and parametric polymorphism in Semantic Web languages, it occurs
> >>> > that all the brackets are already in use...
> >>> > How, then, might we represent templates and generics? One
> >>> > possibility is to utilize a list-like syntax for arguments and some
> >>> > sort of connector, like:
> >>> > <http://www.example.org/#Widget
> >> <http://www.example.org/#Widget
> > <http://www.example.org/#Widget>>>^^(ex:Foo ex:Foo2 ex:Foo3)
> >>> > ex:Widget^^(ex:Foo ex:Foo2 ex:Foo3) Here is how it would look with
> >>> > recursive structure:
> >>> >
> >>> > <http://www.example.org/#Widget
> >> <http://www.example.org/#Widget
> > <http://www.example.org/#Widget>>>^^(ex:Foo ex:Foo2^^(xsd:integer)
> >>> > ex:Foo3) ex:Widget^^(ex:Foo ex:Foo2^^(xsd:integer) ex:Foo3) Do any
> >>> > other syntactic possibilities come to mind?
> >>> > Best regards,
> >>> > Adam
> >>> > From: Adam Sobieski <adamsobieski@hotmail.com>
> >>> > Sent: Monday, December 12, 2022 2:37 PM
> >>> > To: William Van Woensel <william.vanwoensel@gmail.com>
> >>> > Cc: Doerthe Arndt <doerthe.arndt@tu-dresden.de>;
> >>> > semantic-web@w3.org <semantic-web@w3.org>
> >>> > Subject: Re: Syntactic Options for Probabilistic Semantics
> >>> > William,
> >>> > All,
> >>> >
> >>> > Thank you for the useful example. I've been recently thinking about
> >>> > "graph reification" which is showcased in your
> >>> > example:http://ppr.cs.dal.ca:3002/n3/editor/s/ztVCkf2R .
> >>> >
> >>> > N3 Syntactic Sugar
> >>> > As interesting, here are some more rough-draft syntactic sketches:
> >>> >
> >>> > @foreach(rdf:Statement ?stmt in example:graph1 insert
> >>> > example:graph2)
> >>> > {
> >>> > ...
> >>> > }
> >>> > @foreach(ext:Graph ?g in example:dataset1 insert example:graph2)
> >>> > {
> >>> > ...
> >>> > }
> >>> > @foreach(ext:Graph ?g in example:dataset1)
> >>> > {
> >>> > @foreach(rdf:Statement ?stmt in ?g insert example:graph2)
> >>> > {
> >>> > ...
> >>> > }
> >>> > }
> >>> > N3, Client-side Preprocessing, Templates and Generics
> >>> >
> >>> > In addition to client-side PHP [2], I am also thinking about N3 as
> >>> > a potential "semantic preprocessing" technology. With client-side
> >>> > preprocessing [1], runtime arguments – including entire graphs or
> >>> > knowledgebases – can be provided to preprocessors which can then
> >>> > access the graphs or knowledgebases to utilize program logic to
> >>> > vary output contents, e.g., TriG content. As envisioned, graphs or
> >>> > knowledgebases would be provided to preprocessing environments as
> >>> > implicit arguments alongside possible explicit arguments which
> >>> > could be URIs or data types, e.g., boolean values, strings, or
> >>> > numerical values.
> >>> > Towards using N3 in a semantic preprocessing capacity, one could
> >>> > define a reserved input graph name, e.g., “urn:reserved:input”, for
> >>> > an input graph or knowledgebase to be provided at runtime. There
> >>> > would, then, be a matter of how one might best express other input
> >>> > parameters (e.g., T, or T1, T2, T3) which would, similarly, be
> >>> > bound to argument values when invoking the preprocessor.
> >>> > Scenarios considered include, broadly, templates and generics. For
> >>> > a concrete example, “ex:Widget<ex:Dog>” and “ex:Widget<ex:Person>”
> >>> > might result in output content which differs based on facts
> >>> > asserted in the provided graph or knowledgebase about dogs and
> >>> > people, e.g., a dog has four legs and a person two. The
> >>> > preprocessing logic which would produce these generic types would
> >>> > receive an implicit argument, a graph or knowledgebase, and an
> >>> > explicit argument value, in this case a URI, for a template
> >>> > parameter T, e.g., "ex:Dog" or "ex:Person".
> >>> > As envisioned, output content from semantic preprocessing could be
> >>> > semantic graphs. In the running example, the output content might
> >>> > represent a type or class. Resultant types or classes might have
> >>> > URIs resembling:
> >>> > “http://www.example.org/?T=http%3A%2F%2Fwww.example.org%2F%23Dog#Wi
> >>> > dget” and
> >>> > “http://www.example.org/?T=http%3A%2F%2Fwww.example.org%2F%23Person
> >>> > #Widget”.
> >>> > While I’m looking at these preprocessing scenarios towards
> >>> > advancing expressiveness for planning domain definitions, other
> >>> > applications of interest to me include machine lexicons. For
> >>> > instance, “verb:Walk<ex:Dog>” and “verb:Walk<ex:Person>” might have
> >>> > similar but differing semantic content, e.g., definitions differing
> >>> > as dogs have four legs and people have two.
> >>> >
> >>> >
> >>> > Best regards,
> >>> > Adam
> >>> >
> >>> > [1] https://github.com/w3c-cg/planning/discussions/21
> > <https://github.com/w3c-cg/planning/discussions/21>
> >> <https://github.com/w3c-cg/planning/discussions/21
> > <https://github.com/w3c-cg/planning/discussions/21>> [2]
> >>> > https://github.com/seanmorris/php-wasm
> > <https://github.com/seanmorris/php-wasm>
> >> <https://github.com/seanmorris/php-wasm
> > <https://github.com/seanmorris/php-wasm>>
> >>> > From: William Van Woensel <william.vanwoensel@gmail.com>
> >>> > Sent: Monday, December 12, 2022 9:35 AM
> >>> > To: Adam Sobieski <adamsobieski@hotmail.com>
> >>> > Cc: Doerthe Arndt <doerthe.arndt@tu-dresden.de>;
> >>> > semantic-web@w3.org <semantic-web@w3.org>
> >>> > Subject: Re: Syntactic Options for Probabilistic Semantics
> >>> > Hi Adam
> >>> >
> >>> > See here for some examples on how you can infer new statements
> >>> > based on the contents of a graph:
> >>> > http://ppr.cs.dal.ca:3002/n3/editor/s/ztVCkf2R
> > <http://ppr.cs.dal.ca:3002/n3/editor/s/ztVCkf2R>
> >> <http://ppr.cs.dal.ca:3002/n3/editor/s/ztVCkf2R
> > <http://ppr.cs.dal.ca:3002/n3/editor/s/ztVCkf2R>>
> >>> >
> >>> > (These are arbitrary examples; if you had something concrete in
> >>> > mind, I can try to write a better example.)
> >>> >
> >>> > I think the syntactic sugar you propose could be intuitive for this
> >>> > kind of use case (a more imperative style of programming).
> >>> >
> >>> >
> >>> > W
> >>> >
> >>> > > On Dec 11, 2022, at 3:37 AM, Adam Sobieski
> >>> > > <adamsobieski@hotmail.com> wrote:
> >>> > >
> >>> > > Dörthe,
> >>> > > All,
> >>> > >
> >>> > > With respect to syntactic options for probabilistic logic and
> >>> > > semantics, I recently created a GitHub discussion
> >>> > > thread:https://github.com/w3c-cg/planning/discussions/26#discussi
> >>> > > oncomment-4369123 . The most recent comment, there, broaches some
> >>> > > syntactic options inc
>
Received on Saturday, 17 December 2022 13:42:48 UTC