Documentation
  • Introduction
  • Why Ampersand?
    • The Business Rules Manifesto and Ampersand
  • Tutorial
    • Example system: Enrollment
    • Conceptual Model: Enrollment
    • Your tool: RAP4
    • Making your first Ampersand script
  • Reactive programming
  • The language Ampersand
    • How to read syntax statements
    • Truth
    • Atoms
    • The CONCEPT statement
    • The RELATION statement
    • The MEANING statement
    • The PURPOSE statement
    • The CLASSIFY statement
    • The RULE statement
    • Terms
      • Semantics
      • Semantics in logic
        • Primitive terms
        • Boolean operators
        • Relational operators
        • Residual operators
      • Semantics in natural language
        • Primitive terms in natural language
        • Boolean operators in natural language
        • Relational operators in natural language
        • Residual operators in natural language
      • Semantics in sets
        • Primitive terms in set theory
        • Boolean operators in set theory
        • Relational operators in set theory
      • Semantics of terms, defined algebraically
        • Boolean operators in algebra
        • Relational operators in algebra
      • Semantics visualized
        • Semantics of boolean operators visualized
        • Semantics of relational operators visualized
        • Semantics of residuals visualized
    • Context
    • Module
    • Best Practices
    • Syntactical Conventions
      • The CONCEPT statement
      • The RELATION statement
      • The RULE statement
      • The CONTEXT statement
      • The INCLUDE statement
      • Explanation
      • Patterns
      • Population
        • Population in spreadsheets
      • The PURPOSE statement
      • The IDENT statement
      • The TABLE statement
      • Language support
    • The INCLUDE statement
    • Patterns
    • Services
      • Example: Client
      • Example: Login
      • Syntax and meaning
      • Explanation
      • Layout of user interfaces
        • Your own widgets (HTML and CSS)
      • CRUD
    • Population
      • Population in spreadsheets
    • The ENFORCE statement
    • The IDENT statement
    • The TABLE statement
    • Language support
    • Current date
    • The Preprocessor
    • Design considerations
  • Running the Ampersand compiler
    • Configuration
    • Commands (vs. 4.0.0 and later)
    • Options (up to vs. 3.17.4)
  • Architecture of an Ampersand Application
    • Backend framework
    • Hooks
    • Extensions
      • The ExecEngine
  • Deploying your Ampersand script
    • Compiler
    • Deploy your own web application on your laptop
    • Prototype multi-stage build
    • Prototype database
  • Reusing Available Modules
    • Modules
    • Security
    • SIAM (Sessions, Identity and Access Management) Module
  • Exercises
    • Delivery
    • VOG (in Dutch)
  • Installing Ampersand
    • Deploying your Prototype
    • Installing the tools manually
  • Modeling
    • Domain Driven Design
    • Data modeling
    • Legal modeling
    • Architecture modeling
    • Metamodeling
    • Limitations of Ampersand
  • Configuring your application
  • The Excel Importer
  • Plans
    • Current State
    • NoSQL storage
    • API documentation
    • OWL and RDFS input
    • Refactor the front-end
  • Research
Powered by GitBook
On this page
  • Purpose of relational operators
  • Converse
  • Composition
  • How to type relational operators in your script
  • Other explanation
Export as PDF
  1. The language Ampersand
  2. Terms
  3. Semantics of terms, defined algebraically

Relational operators in algebra

Purpose of relational operators

To say things such as "the name of the owner", we want to string together multiple relations (viz. name and owner). Relational operators allow us to make such statements.

There are two relational operators: the converse (⌣\smallsmile⌣) and the composition (semicolon ;;; ). This page discusses the most important laws about these operators.

Converse

There are two things you should know about the converse operator. The first is that the converse of the converse gives you the relation itself, whatever that relation may be:

r⌣⌣ = r{r\smallsmile}\smallsmile\ =\ rr⌣⌣ = r

The second thing you should know is that arguments switch places if the converse is brought outside (or inside) brackets

r⌣;s⌣ = (s;r)⌣r\smallsmile ; s\smallsmile\ =\ (s;r)\smallsmiler⌣;s⌣ = (s;r)⌣

Composition

The composition operator is denoted by a semicolon (;) between two terms. It is pronounced as 'composed with', in this case: rrr composed with sss.

Composition is associative, which means:

r;(s;t) = (r;s);tr;(s;t)\ =\ (r;s);tr;(s;t) = (r;s);t

The meaning stays the same, no matter how you place the brackets. So Ampersand lets you omit brackets entirely. You may write r;s;tr;s;tr;s;t instead of r;(s;t)r;(s;t)r;(s;t) or (r;s);t(r;s);t(r;s);t.

Composition has a left and a right identity. Let r[A×B]r_{[A\times B]}r[A×B]​ be a relation, then

IA;r = r   and   r;IB = rI_A;r\ =\ r\ \ \ \text{and}\ \ \ r;I_B\ =\ rIA​;r = r   and   r;IB​ = r

How to type relational operators in your script

Other explanation

PreviousBoolean operators in algebraNextSemantics visualized

Last updated 5 years ago

shows how you can write these things in your Ampersand script.

Would you like a different explanation of the semantics of the relational operators? for an explanation in sets. explains them in natural language. explains the relational operators in logic.

Click here
This page
This page
This page