RE: Semantic Domain Driven Development

Sebastián,

Thank you for the information about the model. I will take a closer look at it. It looks like you’re exploring an interesting area involving functional programming and formal semantics.

Some searching on those topics found Swish (http://www.ninebynine.org/RDFNotes/Swish/Intro.html). Have you encountered Swish? If so, what do you think of it?

I was broaching, for discussion, relationships between lambda calculus, set theory, constraint logic programming, the modeling of first-class variables, and unification. As enjoyable, one could consider a Prolog/λProlog variant where one could define first-class sets, and where first-class variables could be created from the first-class sets. One could consider that unifying variables would intersect the sets of the variables.

Also, updating the example syntax for N-ary relations and predicate calculus:

@namespace ns1 url(http://www.example.org/namespace1#<http://www.example.org/namespace1>);
@namespace ns2 url(http://www.example.org/namespace2#<http://www.example.org/namespace2>);

ns1:f(ns2:x, ns2:y, ns2:z).

Others have probably already explored such convenience syntaxes and their mappings to and from RDF-based semantics.

Thank you again for the information about the model.


Best regards,
Adam

From: Sebastian Samaruga<mailto:ssamarug@gmail.com>
Sent: Wednesday, February 3, 2021 6:32 PM
To: Adam Sobieski<mailto:adamsobieski@hotmail.com>
Cc: semantic-web at W3C<mailto:semantic-web@w3c.org>
Subject: Re: Semantic Domain Driven Development

Adam, I'm copying this response to the list, trying to make things clearer. I'll start by attaching a diagram about the set related stuff.

Sets depicts categories which are feed later into a functional style of transforms / traversal (Monads). CSPOs are in the Resources category while Kinds category renders a basic aggregation type inference. Then the three sets intersection comprehends data (Statements), schema (Mappings) and behavior (Transforms) categories.

Set membership is given from the Resources / Occurrences complying set attributes of interfaces definitions (quad signatures). Occurrences quads are aggregated by Resource quads and identified by their URN. A Resource can have multiple occurrences and all sets definitions have their own resources reifying their occurrences.

The interfaces for the diagram sets so far (with their hierarchy and quads signatures) are:


  *   Interfaces (sets / roles):
  *   IQuad : (IContext, ISubject, IPredicate, IObject)
  *   IResource : (ResourceURN Resources, Occurrences, Kinds Bindings) : IQuad
  *   IContext : IResource
  *   ISubject : IResource : (ISubjectKind, ISubject, IPredicateKind, IObjectKind)
  *   IPredicate : IResource : (IPredicateKind, ISubjectKind, IPredicate, IObjectKind)
  *   IObject : IResource : (ISubjectKind, ISubject, IPredicateKind, IObjectKind)
  *   IKind : IContext
  *   ISubjectKind : IKind, IPredicate, IObject : (IState, ISubjectKind, IPredicate, IObject)
  *   IPredicateKind : IKind, ISubject, IObject : (IState, ISubject, IPredicateKind, IObject)
  *   IObjectKind : IKind, ISubject, IPredicate : (IState, ISubject, IPredicate, IObjectKind)
  *   IStatement : ISubjectKind, IPredicateKind, IObjectKind :  (IStatementKind, IPredicate, ISubject, IObject)
  *   IStatementKind : IKind, ISubjectKind, IPredicateKind, IObjectKind : (IState, PK of SK, OK: Relation, SK, OK)
  *   IMapping : ISubjectKind, IPredicateKind, IObjectKind : (IMappingKind, IStatementKind, ISubject, IPredicate)
  *   IMappingKind : IKind, ISubjectKind, IPredicateKind, IObjectKind : (IState, SK of PK, OK: Schema, PK, OK)
  *   ITransform : ISubjectKind, IPredicateKind, IObjectKind : (ITransformKind, IMappingKind, IPredicate, IObject)
  *   ITransformKind : IKind, ISubjectKind, IPredicateKind, IObjectKind : (IState, OK of SK, PK: Behavior, SK, PK);
  *   IState : ISubjectKind, IPredicateKind, IObjectKind
  *   IStateKind : IKind, ISubjectKind, IPredicateKind, IObjectKind
  *   IQuad : CSPO Resource Interfaces classes quad. Builder fluent API.
  *   (IContext, ISubject, IPredicate, IObject);
  *   In an occurrence (Quad) CSPO Resources URNs are wrapped in their respective Resource roles. Occurrence Monad wraps specific Quad types (CSPOs, Kinds, Statements, etc.).
  *   Kinds interfaces differentiate in their CSPOs return value types.

And have their corresponding implementing classes:


  *   SubjectResourceQuad : ISubject
  *   SubjectOccurrenceQuad : ISubject
  *   SubjectKind : ISubjectKind
  *   PredicateResourceQuad : IPredicate
  *   PredicateOccurrenceQuad : IPredicate
  *   PredicateKind : IPredicateKind
  *   ObjectResourceQuad : IObject
  *   ObjectOccurrenceQuad : IObject
  *   ObjectKind : IObjectKind
  *   StatementResourceQuad : IStatement
  *   StatementOccurrenceQuad : IStatement
  *   StatementKind : IStatementKind
  *   MappingResourceQuad : IMapping
  *   MappingOccurrenceQuad : IMapping
  *   MappingKind : IMappingKind
  *   TransformResource : ITransform
  *   Transform : ITransform
  *   TransformKind :  ITransformKind
  *   StateResource : IState
  *   State : (Relationship, Relation, Entity, Value) : DCI Model I/O.
  *   StateKind : (PK of SK / OK: Dataflow domain / range)

Functional Features:


  *   APIs. Traversal. State aggregate Kinds, Kinds aggregate Occurrences, Occurrences aggregate Resources (roles). Perform Mappings Transforms. Layers dataflows.


  *   ResourceMonad<ResourceClass : IResource / ResourceURN, etc.>
  *   KindMonad<KindClass : SubjectKind, etc.> Monad
  *   ResourceQuadMonad<ResourceQuadClass : SubjectResourceQuad, etc.> Monad
  *   OccurrenceQuadMonad<OccurrenceQuadClass : SubjectOccurrenceQuad, etc.> Monad


  *   Augmentations:
  *   Incremental / Feedback.
  *   Aggregations: ResourceURNs Source IRIs Sets / Layers streams / events (Resources, Occurrences, Kinds) parse / Occurrences population.
  *   Alignments: Aggregation traversal: ResourceURN URN IDs Model population. Merge / Matching, order / relations / contexts. Encoding (methods).
  *   Activations: Relationship Models I/O (DCI Layers / expanded SPO Aggregations feedback). DIDs URN hashing / generation (HATEOAS Endpoints). Data Flow.

Sorry for this fuzzy set of statements. I'll be trying to clean up my notes (raw notes for now only).

Best Regards,
Sebastián.
https://github.com/sebxama/scrapbook


On Tue, Feb 2, 2021, 10:15 PM Adam Sobieski <adamsobieski@hotmail.com<mailto:adamsobieski@hotmail.com>> wrote:
Sebastian,

You mentioned set theory. For discussion, I wonder what you think of the relationship between a set and the its set membership function’s expression (in conjunctive normal form)? Also, what do you think of the relationship between a set’s set membership function (in conjunctive normal form) and constraints on variables defined to be of said set, e.g. constraints with respect to unification?

Also, as useful, on the topic of N-ary relations (https://www.w3.org/TR/swbp-n-aryRelations/<https://www..w3.org/TR/swbp-n-aryRelations/>), one could always create a new syntax:

@namespace ns1 http://www.example.org/namespace1

@namespace ns2 http://www.example.org/namespace2


ns1:f(ns2:x, ns2:y, ns2:z).

which could be processed to and from RDF while presenting humans and some software applications with convenient predicate calculus expressions.

Automatically-generated user interface elements and layouts is also an interesting topic.


Best regards,
Adam

From: Sebastian Samaruga<mailto:ssamarug@gmail.com>
Sent: Sunday, January 24, 2021 7:56 PM
To: semantic-web at W3C<mailto:semantic-web@w3c.org>
Subject: Semantic Domain Driven Development


Had time lastly and I'm using it in the outline of a "Semantic" framework that I'd like to build for so long. Always "in paper" but I think I've had made progress and came to something. I'd like to have some feedback to start working on this.


I'll use the description of the most fundamental use case that I'm trying to solve that recently I've tried to explain to a friend to see if someone sees a chance of something on this:


By now, I have a draft of the data structures (Statements classes) for the inferences / APIs I need (Functional Programming) expresed in terms of Sets Theory to match, aggregate and sort hierarchies of classes instances, statements, resources (URNs).


Features / Problems to solve:


Type inference, ontology (data, schema, behavior) matching, aggregation, order. Not finding clearly defined how to aggregate or sort quads / triples.


N-ary Relations: Implement how are descripted in: https://www.w3.org/TR/swbp-n-aryRelations/<https://www..w3.org/TR/swbp-n-aryRelations/> (ISO15926) in a DCI pattern.


What I'd like to do / have now is a kind of "semantic hashing" that allows to obtain the relationships between identifiers embedded in the URNs: https://www.w3.org/TR/did-core/ (Semantic Hashing).


Then, the use case is to do Domain Driven Development (isis.apache.org<http://isis.apache.org> is a good example) but in base (declaratively based) upon, for example, a database dump or the description of a serie of services or application to integrate APIs.


From the metadata embedded, for example, in the dump's data and schema or APIs it could be "discovered" what is "about" the application to integrate in its domain (forms, workflows, etc.) and expose it as services to consume in a synchronized manner with the original application.


Upon this, instances of differents "learnt" domains are able to be "merged" and to contemplate integration of schema and functional in a single platform and uniform API in a single facade / client with a REST HATEOAS pattern (MVC / DCI).


https://en.m.wikipedia.org/wiki/HATEOAS


https://spring.io/projects/spring-hateoas


https://dci.github.io/



Example: Semantic Web Alignment Theory.

http://xml.govwebs.net/stratml/references/SemanticWebAlignmentTheory.<http://xml.govwebs.net/stratml/references/SemanticWebAlignmentTheory.pdf>


https://github.com/sebxama/scrapbook


Regards,
Sebastián.