## Combining bracketopes and toratopes

Discussion of shapes with curves and holes in various dimensions.

### Combining bracketopes and toratopes

Recently, I came across a new class of shapes that merge together the ideas of bracketopes and toratopes which I call bracketoratopes (if anyone can think of a better name, I'd be happy to hear it). To show you what some of these shapes look like, here's one of my favorites: the orthotiger.

To start, let's take a step back and look at the definitions for bracketopes and toratopes. The bracketopes are constructed from three products:

max(|x|,|y|) : creates hypercubes; Cartesian product
sqrt(x^2+y^2) : creates hyperspheres
|x|+|y| : creates tegums
Toratopes are defined (or equivalent to) the use of three products:

Cartesian product
sqrt(x^2+y^2) : creates hyperspheres
sqrt(x^2+y^2)-r : creates tori
For example, the tiger has an equation of (sqrt(x^2+y^2)-r1)^2 + (sqrt(z^2+w^2)-r2)^2 - r3 = 0.
You may see some connections between the two groups under this definition. What if we generalize the use of sqrt(x^2+y^2)-r to any of the three bracketopic products? We can simplify this to get 4 different products:

max(|x|,|y|) : creates hypercubes; Cartesian product
sqrt(x^2+y^2) : creates hyperspheres
|x|+|y| : creates tegums
x - r : creates tori
I call the collection of polytopes formed from finding the roots of equations formed by these operations "bracketoratotopes".
It turns out that this generalization works pretty well to merge the ideas of toratopes and bracketopes together in a mathematically precise way.

Notation
Extending the notation used for bracketopes is usually more helpful for bracketoratopes than attempting it with toratopes. Like usual, an I represents a free variable in an equation, [] represents the Cartesian product, () represents the circular product, <> represents the tegmal product, and redundant brackets are removed because of associativity (e.g. [[(II)I]I] = [(II)[II]] = [(II)II] ). The additional operator we add is the torus operation, which simply subtracts a constant. I represent it with an asterisk *. Because every shape needs at least 1 value for a radius at its outermost brackets, we remove the asterisk from our representation. For example, the torus is represented as ((II)*I) in our notation, because it has an equation of sqrt( sqrt(x^2+y^2) - r1 + z^2 ) - r2 = 0. Note that because <II> and [II] are both squares, we can always default to [II] in our notation.

Bracketopes look the same in this notation as they did in their original notation, but toratopes look different and can take some time to get used to. I've compiled a short list of some small closed toratopes and their new representations:
(III) : Sphere
((II)*I) : Torus
[((II)*I)I] : Torinder
(IIII) : Glome
((II)*II) : Spheritorus
((III)*I) : Torisphere
((II)*(II)*) : Tiger
(((II)*I)*I) : Ditorus
(((II)*(II)*)*I) : Toratiger
(((II)*I)*(II)*) : Cyltorintigroid
((((II)*I)*I)*I) : Tritorus
Generally, we can add an asterisk to any pair of brackets within brackets and use square brackets for a Cartesian product.

Finding toratope types
Look at this list of bracketoratopes:
[[III]*I] , ((III)*I) , <<[II]I>*I> , <<(II)I>*I> , <[III]*I> , [[(II)I]*I] , (([II]I)*I) , <[(II)I]*I> , [([II]I)*I] , [(III)*I] , [<III>*I] , [<(II)I>*I] , ([III]*I) , ([(II)I]*I) , (<III>*I) , (<(II)I>*I) , <[(II)I]*I> , <([II]I)*I> , <(III)*I>
Although they are all different shapes, they are similar in a way to the torisphere ((III)*I). They have different products applied to them, but the location of the torus operation remains the same and the brackets themselves stay in the same location. Because of this, these bracketoratopes are all part of the same toratope type, that of the torisphere. Toratope types can be helpful to fit bracketoratopes into categories, and every closed toratope has one.

However, it's not just the closed toratopes that have types. Take these two bracketoratopes:
<[II]*(II)> , (<[II]*I>I)
At first, it seems like these should be the same toratope type, however look at the underlying bracket structures of these two shapes: {{II}*{II}} versus {{{II}*I}I}. If we only use closed toratopes, we cannot distinguish the two because ((II)*(II)) = (((II)*I)I).
However, we can distinguish between these two if we allow certain open toratopes. Take the torinder [((II)*I)I]. It has the same structure as our second shape {{{II}*I}I}, but unlike before [((II)*I)I] ≠ [(II)*[II]], and so this toratope does distinguish the two. Because of this, (<[II]*I>I)'s type is the torinder, and <[II]*(II)>'s type is the spheritorus. Toratopes that we use to distinguish different shapes that we otherwise wouldn't also have their own types. If a toratope t has a type, then we call the set of bracketoratopes with type t t-like. We give the convex shapes a single type for simplicity, because these are just the bracketopes.

Naming scheme
We name the bracketoratopes in the following way:
Convex bracketoratopes are already named, they're just the bracketopes.
Non-convex bracketoratopes are either a toratope and already have a name, or are part of a toratope type. If the latter is true, we remove all torus operations from the bracketoratope, and then take the resulting bracketope and combine it with its type.
For example, the previously mentioned (<[II]*I>I)'s name is the octahedral crind torinder, because (<[II]I>I) is the octahedral crind and (<[II]*I>I)'s toratope type is the torinder.

3D bracketoratopes
Here is an enumeration of all 12 3D bracketorapes. These are a lot easier to understand with some images, so here they are:

Convex:
[III] : Cube

<III> : Octahedron

(III) : Sphere

[(II)I] : Cylinder

([II]I) : Crind

<(II)I> : Bicone

Torus-like:
((II)*I) : Torus

[[II]*I] : Cubic torus

<[II]*I> : Octahedral torus

([II]*I): Crindal torus

<(II)*I> : Biconic torus

[(II)*I] : Cylindrical torus

4D bracketoratopes
There are too many 4D bracketoratopes for me to render them all here. However, to showcase the similarities of toratope types and to give an idea of what 4D bracketopes actually look like, I created a video for the tiger-like bracketoratopes here.

Convex:
[IIII] : Tesseract
(IIII) : Glome
<IIII> : Hexadecachoron
[(II)II] : Cubinder
([II]II) : Dicrind
<(II)II> : Dibicone
[(II)(II)] : Duocylinder
([II][II]) : Duocrind
<(II)(II)> : Duocircular tegum
[([II]I)I] : Crindal prism
[(III)I] : Spherinder
[<III>I] : Octahedral prism
[<(II)I>I] : Biconic prism
([III]I) : Cubic crind
([(II)I]I) : Cylindrical crind
(<III>I) : Octahedral crind
(<(II)I>I) : Biconic crind
<[(II)I]I> : Bicylindrone
<([II]I)I> : Crindal bipyramid
<[III]I> : Cubic bipyramid
<(III)I> : Bisphone

Torinder-like:
[((II)*I)I] : Torinder
[([II]*I)I] : Crindal prism torinder
[<[II]*I>I] : Octahedral prism torinder
[<(II)*I>I] : Biconic prism torinder
([[II]*I]I) : Cubic crind torinder
([(II)*I]I) : Cylindrical crind torinder
(<[II]*I>I) : Octahedral crind torinder
(<(II)*I>I) : Biconic crind torinder
<[(II)*I]I> : Bicylindrone torinder
<([II]*I)I> : Crindal bipyramid torinder
<((II)*I)I> : Bisphone torinder
<[[II]*I]I> : Cubic bipyramid torinder

Torisphere-like:
[[III]*I] : Tesseract torisphere
((III)*I) : Torisphere
<<[II]I>*I> : Hexadecachoron torisphere
<<(II)I>*I> : Dibicone torisphere
<[III]*I> : Cubic bipyramid torisphere
[[(II)I]*I] : Cubinder torisphere
(([II]I)*I) : Dicrind torisphere
<[(II)I]*I> : Bicylindrone torisphere
[([II]I)*I] : Crindal prism torisphere
[(III)*I] : Spherinder torisphere
[<III>*I] : Octahedron prism torisphere
[<(II)I>*I] : Biconic prism torisphere
([III]*I) : Cubic crind torisphere
([(II)I]*I) : Cylindrical crind torisphere
(<III>*I) : Octahedral crind torisphere
(<(II)I>*I) : Biconic crind torisphere
<[(II)I]*I> : Bicylindrone torisphere
<([II]I)*I> : Crindal bipyramid torisphere
<(III)*I> : Bisphone torisphere

Ditorus-like:
[[[II]*I]*I] : Tesseract ditorus
(((II)*I)*I) : Ditorus
<<[II]*I>*I> : Hexadecachoron ditorus
<<(II)*I>*I> : Dibicone ditorus
<[[II]*I]*I> : Cubic bipyramid ditorus
[[(II)*I]*I] : Cubinder ditorus
(([II]*I)*I) : Dicrind ditorus
<[(II)*I]*I> : Bicylindrone ditorus
[([II]*I)*I] : Crindal prism ditorus
[((II)*I)*I] : Spherinder ditorus
[<[II]*I>*I] : Octahedron prism ditorus
[<(II)*I>*I] : Biconic prism ditorus
([[II]*I]*I) : Cubic crind ditorus
([(II)*I]*I) : Cylindrical crind ditorus
(<[II]*I>*I) : Octahedral crind ditorus
(<(II)*I>*I) : Biconic crind ditorus
<[(II)*I]*I> : Bicylindrone ditorus
<([II]*I)*I> : Crindal bipyramid ditorus
<((II)*I)*I> : Bisphone ditorus

Spheritorus-like:
[[II]*II] : Tesseract spheritorus
((II)*II) : Spheritorus
<[II]*II> : Hexadecachoron spheritorus
[(II)*II] : Cubinder spheritorus
[[II]*(II)] : Cubinder antispheritorus
([II]*II) : Dicrind spheritorus
((II)*[II]) : Dicrind antispheritorus
<(II)*II> : Dibicone spheritorus
<[II]*(II)> : Dibicone antispheritorus
[(II)*(II)] : Duocylinder spheritorus
([II]*[II]) : Duocrind spheritorus
<(II)*(II)> : Duocircular tegum spheritorus

Tiger-like:

The tesseract tiger and hexadecachoron tiger both are interesting enough that I thought they deserved their own names, the tigeract and orthotiger.
((II)*(II)*) : Tiger
([II]*(II)*) : Dicrind tiger
([II]*[II]*) : Duocrind tiger
[(II)*(II)*] : Duocylinder tiger
[[II]*(II)*] : Cubinder tiger
[[II]*[II]*] : Tesseract tiger (Tigeract)
<(II)*(II)*> : Duocircular tegum tiger
<[II]*(II)*> : Dibicone tiger
<[II]*[II]*> : Hexadecachoron tiger (Orthotiger)

Generalizations
In bracketoratopes, we have three products for three shapes: circles, squares, and diamonds. Can we generalize this to other shapes, like triangles, hexagons, and octagons? It turns out we can! Here's a way to create an equation for any polygon:
Let L((a,b),(c,d)) be the equation of the line Ax+By=0 that passes through the points (a-c,b-d) , (0,0).
Then if p1, p2, p3, ... , pn-1, pn are the points of our polygon, our final equation for our polygon will be
max(L(p1,p2), L(p2,p3), ... L(pn-1,pn), L(pn,p1)).
A nice property about these equations is that subtracting a radius r will scale like normal, where a radius of 1 aligns with the points of the polygon, a radius of 2 is double the size of radius 1, a radius of 3 is triple that of radius 1, etc.
For example, we can create a triangle product using the vertices for an equilateral triangle. Simplifying this out we get tri(x,y) = max(-2y , y-x*sqrt(3) , y+x*sqrt(3)). Here's a desmos link where you can see the equations for any triangle.

More generally, if we have any function F(x,y) from reals to reals, it creates a product. The only problem with this is that you can never be sure if adjusting a radius will scale the function or not.

In particular, further investigation into the regular triangle, hexagon, and octagon products could be interesting.

Code used
In case anyone wants to try creating some visualizations themselves, I used a slightly modified version of this code to create these images and animations, with the addition of three functions:
Code: Select all
`#declare T = function { sqrt(pow(x,2)+pow(y,2)) - z }#declare O = function { abs(x)+abs(y) - z }  #declare H = function { max(abs(x),abs(y)) - z }`

These have the torus operation built into them, so you just need to set the third input to zero when rendering. I should note that the max function is pretty slow in POV-Ray, so rendering bracketoratopes containing Cartesian products will take a longer amount of time (also just a reminder to set a .ini file before rendering!).
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

It looks pretty good. I invented the bracketope notation.

The essential difference between <ii> and [ii], is that the first is presented vertex first, while the second is presented edge first. This allows for (<ii>*i) which is a diamond-shape torus, against ([ii]*i) the stone-wheel shape or anular prism. For example, your 'octahedral torus' would be <<ii>*i>.

In 4d, the bipyramid and bicone can variously mean an X-point-point pyramid, or an X-line tegum. This is why 'bipyramid' and kindred terms are depreciated in that space and higher. There is as you will probably notice, a good deal of problem, in that the various products can nest, and there is no good way of telling them apart, unless one decides on some RPN logic, and giving the composite products names which indicate the number of elements therein.

One of the problems with the comb product is that something like decagon-dodecahedron torus and dodecahedron-decagon torus are different shapes, and these can not be rendered into each other topologically. The torotope notation was invented largely to investigate the effects of the different products. The tiger, for example, has two holes, each torus-shaped, but this can be rendered into four holes, two internal and two external handles.

Of course, this notation does no justice to non-product torii, some of which are quite easy to construct. For example, one can convert {5,3,3} into a hollow sphere, and twelve interlocked holes, each one running the length of the circles of ten dodecahedra. Such things are 'clifford torii', these can have any number of mutually interlocking holes.
The dream you dream alone is only a dream
the dream we dream together is reality.

\ ( \(\LaTeX\ \) \ ) [no spaces] at https://greasyfork.org/en/users/188714-wendy-krieger

wendy
Pentonian

Posts: 1981
Joined: Tue Jan 18, 2005 12:42 pm
Location: Brisbane, Australia

### Re: Combining bracketopes and toratopes

This is neat, right on man. You use the [] brackets in a similar way as I did a while back. If ((II)(II)) is the tiger, then (II)(II) is the clifford torus, and [(II)(II)] would be the duocylinder.

Plasmath wrote: I should note that the max function is pretty slow in POV-Ray, so rendering bracketoratopes containing Cartesian products will take a longer amount of time (also just a reminder to set a .ini file before rendering!).

You can convert the max function into the implicit form, if that makes POVray render any quicker:

---For cartesian product with f(x,y,...) and an interval along z-axis (prism-making function):

|f(x,y,...) -a*z| + |f(x,y,...) +a*z| = 10

a = some constant, changes the height of the prism along z-axis

---For cart. product of two ortho 2d shapes f(x,y) and g(z,w) :

|f(x,y) - g(z,w)| + |f(x,y) + g(z,w)| = 10

You can extend this to f(x,y,z,w,...) and use the same equation as above for ANY 2 shapes.

Also, there is a workaround for slow POVray rendering and making animations. I found a very useful trick while making the music videos. You do have to sign up and buy the license for Adobe products, which is ab \$53 a month. If you soon cancel the subscription after buying, they will counteroffer you with a 50% off email. Take it, that's a pretty good deal.

If you're interested, you will need to use Photoshop, After Effects, and Media Encoder, along with POVray.

Step 1: In POVray: render a very small image, like 320x240 output. It will shell these thumbnail pics out super fast, with no crashes. This part is key.

Step 2: Load up your frames into Photoshop, make an mp4, or quicktime movie to use the alpha channel (transparency). This is a quick 3-step process, which I can detail if serious.

Step 3: Load up the animation(s) into After Effects. When all is set, you want to use what's called the "Detail Preserving Upscale" transformation. It re-sizes animations back up to whatever you want. Does a fantastic job at putting all of the detail back into a full-size moving image. You can't even tell it was a 320x240. That's what I did for tiger and ditorus.

Step 4: Use adobe Media Encoder to render after effects file into mp4.

DONE!

The time you save in POVray is made up waiting for media encoder, but it's barely anything. Especially if you make single animations at a time. It's super efficient, a little labor intensive, but eliminates all the waiting and crashing that povray loves to do with realistic image sizes.
It is by will alone, I set my donuts in motion
ICN5D
Pentonian

Posts: 1130
Joined: Mon Jul 28, 2008 4:25 am
Location: Orlando, FL

### Re: Combining bracketopes and toratopes

I wonder if tapertopes could be incorporated into this as well. For example, <||> could be understood as a Bi-triangle, and if you take only one side (positive x-values) then you would get just a triangle. So maybe <|'|> would be a way to describe it? And then a square pyramid would be <[||]'|> and a tetrahedron would be <<|'|>'|>?
ndl
Trionian

Posts: 81
Joined: Tue Nov 27, 2018 2:13 pm
Location: Louisville, KY

### Re: Combining bracketopes and toratopes

Plasmath wrote:
3D bracketoratopes
Here is an enumeration of all 12 3D bracketorapes. These are a lot easier to understand with some images, so here they are:

Convex:
[III] : Cube

<III> : Octahedron

(III) : Sphere

[(II)I] : Cylinder

([II]I) : Crind

<(II)I> : Bicone

Torus-like:
((II)*I) : Torus

[[II]*I] : Cubic torus

<[II]*I> : Octahedral torus

([II]*I): Crindal torus

<(II)*I> : Biconic torus

[(II)*I] : Cylindrical torus

Aren't there some more torus-like baracketoratopes if you start with the tegum <||>?

<<||>*|> is different than <[||]*|> because the position of the square you start with is on a 45deg angle.
ndl
Trionian

Posts: 81
Joined: Tue Nov 27, 2018 2:13 pm
Location: Louisville, KY

### Re: Combining bracketopes and toratopes

ndl wrote:Aren't there some more torus-like baracketoratopes if you start with the tegum <||>?

<<||>*|> is different than <[||]*|> because the position of the square you start with is on a 45deg angle.

I thought about this, and on the surface it seems like they should be different. But as it turns out, because all variables are independent from each other and <||> is always a rotated [||], we can rotate in that plane only to get the other bracketoratope. Here's an example with <<||>*I> and <[||]*|>:

ndl wrote:I wonder if tapertopes could be incorporated into this as well. For example, <||> could be understood as a Bi-triangle, and if you take only one side (positive x-values) then you would get just a triangle. So maybe <|'|> would be a way to describe it? And then a square pyramid would be <[||]'|> and a tetrahedron would be <<|'|>'|>?

After experimenting some, I believe that the triangle product mentioned in my original post is actually a pyramid operation like you mentioned! For example, tri((II)I) = <(II)’I> is the cone, and here's tri((II)*I) = <(II)*’I>:

It's a bit hard to see, but this is actually just the upper half of <(II)*I>. I guess it's a cone torus?
This makes some sense now that I think about it. A triangle is just half of a diamond, so its product should work the same.

ICN5D wrote:You can convert the max function into the implicit form, if that makes POVray render any quicker:

---For cartesian product with f(x,y,...) and an interval along z-axis (prism-making function):

|f(x,y,...) -a*z| + |f(x,y,...) +a*z| = 10

a = some constant, changes the height of the prism along z-axis

This is really cool! I'm planning to render the tiger of the triangle product I mentioned above, so I'll try using this when I render it.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

Like I promised, here's a link to some cross sections of the triangle product tiger, which I like to call the "Triger":
https://youtu.be/sOYwtzwol94
Not much else to note, although I think some of the Triger's rotations look very interesting.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

Plasmath wrote:
ndl wrote:Aren't there some more torus-like baracketoratopes if you start with the tegum <||>?

<<||>*|> is different than <[||]*|> because the position of the square you start with is on a 45deg angle.

I thought about this, and on the surface it seems like they should be different. But as it turns out, because all variables are independent from each other and <||> is always a rotated [||], we can rotate in that plane only to get the other bracketoratope. Here's an example with <<||>*I> and <[||]*|>:

Did not anticipate that, but you are correct.

Plasmath wrote:
ndl wrote:I wonder if tapertopes could be incorporated into this as well. For example, <||> could be understood as a Bi-triangle, and if you take only one side (positive x-values) then you would get just a triangle. So maybe <|'|> would be a way to describe it? And then a square pyramid would be <[||]'|> and a tetrahedron would be <<|'|>'|>?

After experimenting some, I believe that the triangle product mentioned in my original post is actually a pyramid operation like you mentioned! For example, tri((II)I) = <(II)’I> is the cone, and here's tri((II)*I) = <(II)*’I>:

It's a bit hard to see, but this is actually just the upper half of <(II)*I>. I guess it's a cone torus?
This makes some sense now that I think about it. A triangle is just half of a diamond, so its product should work the same.

If you are using a different operation for creating a triangle (not tegum), then I wouldn't suggest using the notation I proposed - rather another type of bracket like {||} or something. I was thinking more similar to a torus which adds a constant and can be appended to any operation, here we are taking half the result and can similarly apply that to any of the three operations.

However, after further thought, tapertopes are probably better represented by your method of the tri() operation.
ndl
Trionian

Posts: 81
Joined: Tue Nov 27, 2018 2:13 pm
Location: Louisville, KY

### Re: Combining bracketopes and toratopes

ndl wrote:If you are using a different operation for creating a triangle (not tegum), then I wouldn't suggest using the notation I proposed - rather another type of bracket like {||} or something. I was thinking more similar to a torus which adds a constant and can be appended to any operation, here we are taking half the result and can similarly apply that to any of the three operations.

However, after further thought, tapertopes are probably better represented by your method of the tri() operation.
I thought about this too, and I only used tri() for the lack of a better bracket (I used {} as a placeholder bracket to show the structure of bracketopes, so I decided against it). I also used tri() because it’s thec function I used for the initial triangle equation:
Plasmath wrote:For example, we can create the triangle product using the vertices of an equilateral triangle. Simplifying this out we get tri(x,y) = max(-2y, y-x*sqrt(3), y+x*sqrt(3)).
However, I think I have a more general notation which should work better than using tri. We define {}n to be the product of a regular n-sided polygon that has one of its sides intersecting the negative x axis, and {}n’ to be the product of a regular n-sided polygon that has one of its vertices intersecting the negative x axis. Then [] is the same as {}4, <> is the same as {}4’, and tri() is the same as {}3. This notation can define any regular polygon, so the Triger is now defined as {{II}3{II}3}3.
Does this idea seem good? What should we call these new shapes, as they seem much more general than bracketopes or toratopes. Still bracketoratopes, or something else?

One last note: A single input halving operation like you mentioned may still exist and be useful. We still don’t have a way of representing a semicircle, hemisphere, hemitorus, etc. Maybe the product x’ = max(x,0) will work? I’ll have to do some more experimenting.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

Plasmath wrote:
ndl wrote:If you are using a different operation for creating a triangle (not tegum), then I wouldn't suggest using the notation I proposed - rather another type of bracket like {||} or something. I was thinking more similar to a torus which adds a constant and can be appended to any operation, here we are taking half the result and can similarly apply that to any of the three operations.

However, after further thought, tapertopes are probably better represented by your method of the tri() operation.
I thought about this too, and I only used tri() for the lack of a better bracket (I used {} as a placeholder bracket to show the structure of bracketopes, so I decided against it). I also used tri() because it’s thec function I used for the initial triangle equation:
Plasmath wrote:For example, we can create the triangle product using the vertices of an equilateral triangle. Simplifying this out we get tri(x,y) = max(-2y, y-x*sqrt(3), y+x*sqrt(3)).
However, I think I have a more general notation which should work better than using tri. We define {}n to be the product of a regular n-sided polygon that has one of its sides intersecting the negative x axis, and {}n’ to be the product of a regular n-sided polygon that has one of its vertices intersecting the negative x axis. Then [] is the same as {}4, <> is the same as {}4’, and tri() is the same as {}3. This notation can define any regular polygon, so the Triger is now defined as {{II}3{II}3}3.
Does this idea seem good? What should we call these new shapes, as they seem much more general than bracketopes or toratopes. Still bracketoratopes, or something else?

I like the notation you proposed, however it doesn't then differentiate between squares and tegums - that would still need the the original angled brackets.
In terms of naming them: bracketopes were always just "shapes that can be defined by these brackets", so why not still call them bracketopes? It can include more shapes now due to your innovations.

Plasmath wrote:One last note: A single input halving operation like you mentioned may still exist and be useful. We still don’t have a way of representing a semicircle, hemisphere, hemitorus, etc. Maybe the product x’ = max(x,0) will work? I’ll have to do some more experimenting.

That equation doesn't seem to work. I'm actually not sure how to accomplish it.
ndl
Trionian

Posts: 81
Joined: Tue Nov 27, 2018 2:13 pm
Location: Louisville, KY

### Re: Combining bracketopes and toratopes

ndl wrote:I like the notation you proposed, however it doesn't then differentiate between squares and tegums - that would still need the the original angled brackets.

Note the subtle but important difference between {}n and {}n’. n will always have a side intersecting the x axis, but n’ will always have a vertex intersecting. This means that {}4 is the same as [], however {}4’ is going to be <>, because a side of the square intersects the x axis, but for the diamond a corner intersects instead.

ndl wrote:
Plasmath wrote:One last note: A single input halving operation like you mentioned may still exist and be useful. We still don’t have a way of representing a semicircle, hemisphere, hemitorus, etc. Maybe the product x’ = max(x,0) will work? I’ll have to do some more experimenting.

That equation doesn't seem to work. I'm actually not sure how to accomplish it.

I believe instead of having a halving operation on numbers, instead we need a halving operation on products.
For a product {xy}, we define the prime halving {xy}’ of it to be max({xy}-r,-y) (r is a radius).
We also define the weak halving {xy}° as max({xy},-y). Although I’m sure that the prime halving does work and create halved shapes like we wanted, the weak halving operation I’ll have too look more into. More info (and hopefully renders!) coming soon.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

Plasmath wrote:I believe instead of having a halving operation on numbers, instead we need a halving operation on products.

I did some work on this a little while back. It's my "hemi-torus" function, and it is extendable.

See Here

To recap the important stuff:

if " (sqrt(x^2 + y^2) -3)^2 + z^2 = 1 " a torus equation, then,

abs((sqrt(x^2 + y^2) -3)^2 + z^2 +x/6 -1) + (sqrt(x^2 + y^2) -3)^2 + z^2 = 1

is the hemi-torus, which slices into a C-shaped thing. Want it sliced another way? Swap the variables around, while leaving the x/6 term intact. You will need to adjust the value away from 6, to something that makes a nice surface without too many jagged edges.

More generally, the function should read:

for f(x,y,z) = (sqrt(x^2 + y^2) -3)^2 + z^2 - 1

abs(f(x,y,z) +x/6) + f(x,y,z) = 0

where you change the x/6 to maybe x/4 or x/8 for other shapes/orientations.
It is by will alone, I set my donuts in motion
ICN5D
Pentonian

Posts: 1130
Joined: Mon Jul 28, 2008 4:25 am
Location: Orlando, FL

### Re: Combining bracketopes and toratopes

Plasmath wrote:Like I promised, here's a link to some cross sections of the triangle product tiger, which I like to call the "Triger":
https://youtu.be/sOYwtzwol94
Not much else to note, although I think some of the Triger's rotations look very interesting.

Ah, I see what you did here. It's a small triangle stretched over the 2-frame of the cartesian product of two triangles. A completely triangular version of the tiger, lol. I'm all about naming shapes whatever you want, however if your notation takes off, it might confuse people, since we already use the name triger for the 6D ((II)(II)(II)). I almost want to call this thing the "triangular duotrianglintigroid" or something like that. It's a tiger-like shape based on a hollowed out 3,3-duoprism (duotrianglinder), but with infinite triangles embedded over the 2-d edge. I think you can define it implicitly as:

if triangle is

f(x,y) = ||x|+2y| + |x| -2

then, triangle over triangle frame in 3D is:

x --> ||x|+2z|+|x|-4

f(x,y,z) = ||||x|+2z|+|x|-4|+2y| + |||x|+2z|+|x|-4| -2

and finally, triangle over duotrianglinder frame in 4D:

y --> (||y|+2w|+|y|-4)

f(x,y,z,w) = ||||x|+2z|+|x|-4|+2(||y|+2w|+|y|-4)| + |||x|+2z|+|x|-4| -2

f(x,y,z,w) = ||||x|+2z|+|x|-4| +2||y|+2w|+2|y|-8| + |||x|+2z|+|x|-4| -2

Haven't tested it, but it should be the one.

Also, since povray is tedious and slow, you can always test your equations in Graphing Calculator 3D as well. You just use the 2 adjustable parameters a,b in place of the clock variable. Having those sliders to play with will make things way faster, compared to creating a full animation.
It is by will alone, I set my donuts in motion
ICN5D
Pentonian

Posts: 1130
Joined: Mon Jul 28, 2008 4:25 am
Location: Orlando, FL

### Re: Combining bracketopes and toratopes

ICN5D wrote:I'm all about naming shapes whatever you want, however if your notation takes off, it might confuse people, since we already use the name triger for the 6D ((II)(II)(II)). I almost want to call this thing the "triangular duotrianglintigroid" or something like that. It's a tiger-like shape based on a hollowed out 3,3-duoprism (duotrianglinder), but with infinite triangles embedded over the 2-d edge.

Hmm. I didn't know about the 6D triger. Maybe we can call the triangle product triger simply just the 'product triger'? I feel like 'triangular duotrianglintigroid' masks how it relates to the tiger too much, because they're essentially the same shape. I do think that ((II)(II)(II)) is definitely a more fitting title for the Triger than what's been found here.

ICN5D wrote:Want [the hemi torus] sliced another way? Swap the variables around, while leaving the x/6 term intact. You will need to adjust the value away from 6, to something that makes a nice surface without too many jagged edges.

More generally, the function should read:

for f(x,y,z) = (sqrt(x^2 + y^2) -3)^2 + z^2 - 1

abs(f(x,y,z) +x/6) + f(x,y,z) = 0

where you change the x/6 to maybe x/4 or x/8 for other shapes/orientations.

Do you know why the x/6 is necessary? It makes some sense to me why the equation |x|+x works (because for negatives |x|+x=0 and never 1), but I wonder how the x/6 plays a factor here.

Plasmath wrote:For a product {xy}, we define the prime halving {xy}’ of it to be max({xy}-r,-y) (r is a radius).

I think I may also have found a way to halve any object using the max function instead of the |x|+x-like strategy. The max({xy}-r,-y) operation does work to halve bracketoratopes in some cases, but it also breaks down at most other places, for example creating semicircle-based torii, and it doesn't even include all of the different halvings! This strategy works using a more general notation that does not require operations on functions. I call it the 'n-halving operation'. Let's take a look.

The n-halving operation
To start, let's take a function F whose roots define a shape: e.g. F(x1,x2,x3,...) = 0, where the parameters are the different dimensions of the equation, and don't include radii (we assume radii to be constants in the function and not variables). For example, the equation for a crind is CR(x1,x2,x3) = sqrt(max(|x1|,|x2|)^2+x3^2)-r.
Now here comes the time that we actually halve the equation. For an N-parameter equation F, F will have n halvings F~1, F~2, F~3, ... F~n, where F~a is defined as F~a(x1,x2,...xa,...xn) = max( F(x1,x2...xa,...xn) , -xa). This essentially just cuts the shape through the xa hyperplane and takes the upper half. The bottom half is obtained when the -xa is swapped to be just xa.

Hemitoratopes
If we only use n-halving on the very outside of a bracketoratope, it will always cut it in half instead of creating strange semicircle tigers and other strange shapes. I call the set of toratopes with n-halving applied to the very outside non-square brackets hemitoratopes. I decided to render some of these in POV-Ray, and I will probably experiment with ICN5D's equations there soon. Here are all of the 2D, 3D, and 4D hemitoratopes: (Sorry for the weird image dimensions, BBcode doesn't like to resize them)

2D
The only 2D possibility is the semicircle, which isn't that interesting.

3D
Sphere-based
Hemisphere - (III)~1

Cylinder-based
Hemicylinder - [(II)~1I]

Torus-based
The torus has two ways of halving it instead of one. There's the way that you would cut a bagel, and there is the other way that looks like a macaroni noodle. We'll look more at these later.
Hemitorus type A - ((II)*I)~1

Hemitorus type B - ((II)*I)~3

4D
Glome-based
Hemiglome - (IIII)~1 (I accidentially rendered this at an incorrect angle)

Spherinder-based
Hemispherinder - [(III)~1I]

Duocylinder-based
Hemiduocylinder - [(II)~1(II)]. This is the Cartesian product of a circle and a semicircle instead of two circles.

Cubinder-based
Hemicubinder - [(II)~1II]. This is the Cartesian product of a square and a semicircle.

Torinder-based
Hemitorinder type A - [((II)*I)~1I]

Hemitorinder type B - [((II)*I)~3I]

Spheritorus-based
Hemispheritorus type A - ((III)*I)~1

Hemispheritorus type B - ((III)*I)~4

Torisphere-based
Hemitorisphere type A - ((II)*II)~1

Hemitorisphere type B - ((II)*II)~3

Ditorus-based
Because the ditorus has three unique radii, it also has three different halvings.
Hemiditorus A - (((II)*I)*I)~1

Hemiditorus B - (((II)*I)*I)~3

Hemiditorus C - (((II)*I)*I)~4

Tiger-based
Hemitiger - ((II)*(II)*)~1

The hemitiger is especially interesting because it is the smallest torus with only one orthogonal cut. Maybe this could be used to construct the mantis?
I also decided to look at an oblique cross section of the hemitiger, and I think it was worth it:

Bagel and macaroni cuts
Before I end this post, I first want to look a little more into two special types of cuts: bagel cuts and macaroni cuts. Let's call the solid flat shape formed from cutting the toratope with the n-halving operation its hemisurface (so the hemisurface of the type B hemitorus is an annulus). The definition of a macaroni cut is simple: its hemisurface can be separated into at least two separate parts. The list of macaroni cuts found above are:

Hemitorus type A
Hemitorinder type B
Hemitorisphere type A
Hemiditorus type A
Hemiditorus type B

The definition of the bagel cut is a bit more complex. Its definition is as follows: For any point in the shape, there is a point in the hemisurface where the line formed between the two points is perpendicular to the hemisurface. Here's the list of bagel cuts listed above (not counting convex hemitoratopes because these will automatically be bagel cuts):

Hemitorus type B
Hemitorinder type B
Hemispheritorus type B
Hemitorisphere type B
Hemiditorus type C

In conclusion: there are 5 types of 4D macaroni and 5 types of 4D bagels.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

### Re: Combining bracketopes and toratopes

ICN5D wrote:if " (sqrt(x^2 + y^2) -3)^2 + z^2 = 1 " a torus equation, then,

abs((sqrt(x^2 + y^2) -3)^2 + z^2 +x/6 -1) + (sqrt(x^2 + y^2) -3)^2 + z^2 = 1

is the hemi-torus, which slices into a C-shaped thing. Want it sliced another way? Swap the variables around, while leaving the x/6 term intact. You will need to adjust the value away from 6, to something that makes a nice surface without too many jagged edges.

More generally, the function should read:

for f(x,y,z) = (sqrt(x^2 + y^2) -3)^2 + z^2 - 1

abs(f(x,y,z) +x/6) + f(x,y,z) = 0

where you change the x/6 to maybe x/4 or x/8 for other shapes/orientations.

Plasmath wrote:I decided to render some of [the hemitoratopes] in POV-Ray, and I will probably experiment with ICN5D's equations there soon.

As promised, I experimented in CalcPlot3D and then POV-Ray to see why the x/6 is needed, but I believe I've found something else instead. I think that the hemitorus equation using the absolute value function and the hemitorus equation using the max function are actually very slightly different shapes. Here I've shown the max hemitorus in red and the abs hemitorus in blue, where the x/n in the equation ranges from 0 to 12 in the animation.
abs hemitorus vs max hemitorus.gif (617.34 KiB) Viewed 79 times

The larger we make the n value in the x/n, the closer we get to the max hemitorus. Here's what it looks like at n=100:
x100.png
(151.89 KiB) Not downloaded yet

The equation seems to really not like removing the x/n part entirely, however x/6 seems to be an extremely accurate approximation of a halved torus anyway and should work just as well for pretty much any purpose we use it for.
Plasmath
Dionian

Posts: 28
Joined: Mon Feb 08, 2021 10:57 pm

Return to Toratopes

### Who is online

Users browsing this forum: No registered users and 2 guests