WOLFRAM

Wolfram Language & System Documentation Center

RegionEqual[reg1,reg2]

returns True if the regions reg1 and reg2 are equal.

RegionEqual[reg1,reg2,reg3,…]

returns True if the regions reg1, reg2, reg3, … are all equal.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Basic Regions  
Formula Regions  
Mesh Regions  
Derived Regions  
Options  
Assumptions  
GenerateConditions  
Applications  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

RegionEqual

RegionEqual[reg1,reg2]

returns True if the regions reg1 and reg2 are equal.

RegionEqual[reg1,reg2,reg3,…]

returns True if the regions reg1, reg2, reg3, … are all equal.

Details and Options

  • The regions reg1 and reg2 are equal if all points in reg1 are points in reg2 and vice versa.
  • If all regi are parameter-free regions, i.e. ConstantRegionQ[regi] is True, the regions are point sets, and typically True or False is returned.
  • If some regi depend on parameters, i.e. ConstantRegionQ[regi] is False, then regi represents a family of regions, and RegionEqual will attempt to compute conditions on parameters such that the regions are equal.
  • The following options can be given:
  • Assumptions $Assumptionsassumptions to make about parameters
    GenerateConditions Falsewhether to generate conditions on parameters

Examples

open all close all

Basic Examples  (2)

Test whether two regions are equal:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[]; Subscript[ℛ, 2] = Polygon[{{0, 0}, {1, 0}, {1, 1}, {0, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Generate conditions for which two regions are equal:

Wolfram Language code: Subscript[ℛ, 1] = Circle[]; Subscript[ℛ, 2] = ImplicitRegion[x^2 + y^2 == r, {x, y}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Scope  (16)

Basic Uses  (4)

Test for equality:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[{0, 0}, {2, 1}]; Subscript[ℛ, 2] = ImplicitRegion[0 ≤ x ≤ 2 && 0 ≤ y ≤ 1, {x, y}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Show two regions are not equal:

Wolfram Language code: Subscript[ℛ, 1] = Line[{{0, 0}, {1, 1}}]; Subscript[ℛ, 2] = Line[{{0, 0}, {-1, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Find conditions that make regions equal:

Wolfram Language code: Subscript[ℛ, 1] = Disk[]; Subscript[ℛ, 2] = Disk[{x, y}, r, {0, θ}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Compare three regions at once:

Wolfram Language code: Subscript[ℛ, 1] = Interval[{0, 1}]; Subscript[ℛ, 2] = MeshRegion[{{0}, {1}}, Line[{1, 2}]]; Subscript[ℛ, 3] = ImplicitRegion[0 ≤ x ≤ 1, x];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2], Subscript[ℛ, 3]]

Basic Regions  (4)

Regions in including Line and Interval:

Wolfram Language code: RegionEqual[Line[{{0}, {1}}], Interval[{0, 1}]]

Point:

Wolfram Language code: RegionEqual[Point[{2}], Interval[{2, 2}]]

Ball:

Wolfram Language code: RegionEqual[Ball[1], Interval[{-1, 1}]]

InfiniteLine:

Wolfram Language code: RegionEqual[InfiniteLine[{0}, {1}], FullRegion[1]]

Regions in including Point:

Wolfram Language code: Subscript[ℛ, 1] = Point[Tuples[Range[3], 2]]; Subscript[ℛ, 2] = Point[Join@@Table[{i, j}, {j, 3}, {i, 3}]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Line:

Wolfram Language code: Subscript[ℛ, 1] = Line[{{0, 0}, {3, 3}, {5, -1}, {7, -1}}]; Subscript[ℛ, 2] = Line[{{7, -1}, {6, -1}, {5, -1}, {3, 3}, {1, 1}, {0, 0}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Polygon:

Wolfram Language code: Subscript[ℛ, 1] = Polygon[{{0, 0}, {1, 0}, {1, 1}, {0, 1}}]; Subscript[ℛ, 2] = Rectangle[];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]
Wolfram Language code: Subscript[ℛ, 1] = Polygon[CirclePoints[5]]; Subscript[ℛ, 2] = RegularPolygon[5];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Disk, Ball and Ellipsoid:

Wolfram Language code: Subscript[ℛ, 1] = Disk[]; Subscript[ℛ, 2] = Ball[2]; Subscript[ℛ, 3] = Ellipsoid[{0, 0}, {1, 1}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2], Subscript[ℛ, 3]]

Rectangle and RegularPolygon:

Wolfram Language code: RegionEqual[Rectangle[{x1, y1}, {x2, y2}], RegularPolygon[r, n]]

Regions in including Point:

Wolfram Language code: Subscript[ℛ, 1] = Point[Tuples[Range[5], 3]]; Subscript[ℛ, 2] = Point[Flatten[Table[{i, j, k}, {j, 5}, {k, 5}, {i, 5}], 2]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Line:

Wolfram Language code: Subscript[ℛ, 1] = Line[{{0, 0, 0}, {3, 3, 3}, {5, -1, 0}, {7, -1, 1}}]; Subscript[ℛ, 2] = Line[{{7, -1, 1}, {5, -1, 0}, {3, 3, 3}, {1, 1, 1}, {0, 0, 0}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Polygon:

Wolfram Language code: Subscript[ℛ, 1] = Polygon[{{1, 0, 0}, {0, 0, 1}, {0, 1, 1}, {1, 1, 0}}]; Subscript[ℛ, 2] = Triangle[{{{1, 0, 0}, {0, 0, 1}, {0, 1, 1}}, {{1, 0, 0}, {0, 1, 1}, {1, 1, 0}}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Cuboid and Hexahedron:

Wolfram Language code: Subscript[ℛ, 1] = Cuboid[]; Subscript[ℛ, 2] = Hexahedron[{{0, 0, 0}, {1, 0, 0}, {2, 1, 0}, {1, 1, 0}, {0, 0, 1}, {1, 0, 1}, {2, 1, 1}, {1, 1, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Ball and Ellipsoid:

Wolfram Language code: Subscript[ℛ, 1] = Ball[3]; Subscript[ℛ, 2] = Ellipsoid[{0, 0, 0}, {3, 2, 1}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Tetrahedron and Simplex:

Wolfram Language code: Subscript[ℛ, 1] = Tetrahedron[{{1, 0, 0}, {1, 0, 1}, {1, 1, 1}, {0, 0, 1}}]; Subscript[ℛ, 2] = Simplex[{{1, 0, 1}, {1, 0, 0}, {0, 0, 1}, {1, 1, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Regions in including Cuboid and Parallelepiped in :

Wolfram Language code: Subscript[ℛ, 1] = Cuboid[{0, 0, 0, 0}, {1, 1, 1, 1}]; Subscript[ℛ, 2] = Parallelepiped[{0, 0, 0, 0}, IdentityMatrix[4]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Ellipsoid and Ball in :

Wolfram Language code: Subscript[ℛ, 1] = Ellipsoid[Table[0, 10], Table[1, 10]]; Subscript[ℛ, 2] = Ball[10];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Formula Regions  (4)

Implicit regions:

Wolfram Language code: Subscript[ℛ, 1] = ImplicitRegion[x^2 + y^2 == 1, {x, y}]; Subscript[ℛ, 2] = ImplicitRegion[y == Sqrt[1 - x^2] || y == -Sqrt[1 - x^2], {x, y}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Parametric regions:

Wolfram Language code: Subscript[ℛ, 1] = ParametricRegion[{Cos[t], Sin[t]}, t]; Subscript[ℛ, 2] = ParametricRegion[{Cos[2t + π / 5], Sin[2t + π / 5]}, t];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Compare two formula regions:

Wolfram Language code: Subscript[ℛ, 1] = ImplicitRegion[-1 ≤ x ≤ 1 && y^2 ≤ x^4 - 2x^2 + 1, {x, y}]; Subscript[ℛ, 2] = ParametricRegion[{t, s (1 - t^2)}, {{s, -1, 1}, {t, -1, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Nonconstant formula regions:

Wolfram Language code: RegionEqual[Annulus[], ImplicitRegion[r1 ≤ x^2 + y^2 ≤ r2, {x, y}]]

Mesh Regions  (3)

Compare MeshRegion in :

Wolfram Language code: Subscript[ℛ, 1] = MeshRegion[{{0}, {1}}, Line[{1, 2}]]; Subscript[ℛ, 2] = MeshRegion[{{0}, {1 / 2}, {1}}, Line[{3, 2, 1}]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

In :

Wolfram Language code: Subscript[ℛ, 1] = MeshRegion[{{0, 0}, {1, 0}, {1, 1}, {0, 1}}, Polygon[{1, 2, 3, 4}]]; Subscript[ℛ, 2] = TriangulateMesh[Subscript[ℛ, 1]];
Wolfram Language code: {Subscript[ℛ, 1], Subscript[ℛ, 2]}
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

In :

Wolfram Language code: Subscript[ℛ, 1] = DiscretizeGraphics[Cuboid[{0, 0, 0}, {1, 1, 1}]]; Subscript[ℛ, 2] = DiscretizeGraphics[Ball[]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Compare BoundaryMeshRegion in :

Wolfram Language code: Subscript[ℛ, 1] = BoundaryMeshRegion[{{0}, {1}}, Point[{1, 2}]]; Subscript[ℛ, 2] = BoundaryMeshRegion[{{0}, {1}}, Point[{2, 1}]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

In :

Wolfram Language code: Subscript[ℛ, 1] = BoundaryMeshRegion[{{0, 0}, {2, 0}, {2, 2}, {0, 2}}, Line[{1, 2, 3, 4, 1}]]; Subscript[ℛ, 2] = BoundaryMeshRegion[{{0, 0}, {1, 0}, {2, 0}, {2, 2}, {0, 2}}, Line[{1, 2, 3, 4, 5, 1}]];
Wolfram Language code: {Subscript[ℛ, 1], Subscript[ℛ, 2]}
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

In :

Wolfram Language code: Subscript[ℛ, 1] = BoundaryDiscretizeGraphics[Cuboid[{0, 0, 0}, {1, 1, 1}]]; Subscript[ℛ, 2] = BoundaryDiscretizeGraphics[Ball[]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Compare MeshRegion with BoundaryMeshRegion in :

Wolfram Language code: Subscript[ℛ, 1] = DelaunayMesh[RandomReal[{-1, 1}, {25, 2}]]; Subscript[ℛ, 2] = BoundaryMesh[Subscript[ℛ, 1]];
Wolfram Language code: {Subscript[ℛ, 1], Subscript[ℛ, 2]}
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

In :

Wolfram Language code: Subscript[ℛ, 1] = DelaunayMesh[RandomReal[{-1, 1}, {25, 3}]]; Subscript[ℛ, 2] = BoundaryMesh[Subscript[ℛ, 1]];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Derived Regions  (1)

Compare BooleanRegion:

Wolfram Language code: Subscript[ℛ, 1] = BooleanRegion[Xnor, {Disk[], Disk[{1, 0}]}]; Subscript[ℛ, 2] = BooleanRegion[(!#1 || #2) && (#1 || !#2)&, {Disk[], Disk[{1, 0}]}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Options  (2)

Assumptions  (1)

Find all radii that describe the unit circle:

Wolfram Language code: Subscript[ℛ, 1] = Circle[]; Subscript[ℛ, 2] = ImplicitRegion[x^2 + y^2 == r^2, {x, y}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Find only the positive radii:

Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2], Assumptions -> r > 0]

GenerateConditions  (1)

Find when the unit disk is equal to an implicitly described annulus:

Wolfram Language code: Subscript[ℛ, 1] = Disk[]; Subscript[ℛ, 2] = ImplicitRegion[Subscript[r, 1] ≤ x^2 + y^2 ≤ Subscript[r, 2], {x, y}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Show the conditions for which the result is valid:

Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2], GenerateConditions -> True]

Explicitly allow for degenerate cases:

Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2], Assumptions -> Subscript[r, 1]∈Reals]

Applications  (6)

Find when two lamina are equal:

Wolfram Language code: Subscript[ℛ, 1] = Entity["Lamina", "FilledDiamond"][EntityProperty["Lamina", "Region"]][a, b]
Wolfram Language code: Subscript[ℛ, 2] = Entity["Lamina", "FilledKite"][EntityProperty["Lamina", "Region"]][2, 2, 1]
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Create the unit disk by covering the hole of an annulus with a disk. Find all possible radii:

Wolfram Language code: RegionEqual[RegionUnion[Annulus[], Disk[{0, 0}, r]], Disk[]]

Show an instance of this:

Wolfram Language code: Subscript[r, 0] = RandomReal[{1 / 2, 1}]
Wolfram Language code: Graphics[{Opacity[0.4], {Red, Annulus[]}, {Green, Disk[{0, 0}, Subscript[r, 0]]}}]

Create the unit disk by covering the hole of an annulus with a square. Find all possible side lengths:

Wolfram Language code: RegionEqual[RegionUnion[Annulus[], Rectangle[{-r, -r}, {r, r}]], Disk[]]

Show an instance of this:

Wolfram Language code: Subscript[r, 0] = RandomReal[{1 / 2, 1 / Sqrt[2]}]
Wolfram Language code: Graphics[{Opacity[0.4], {Red, Annulus[]}, {Green, Rectangle[{-Subscript[r, 0], -Subscript[r, 0]}, {Subscript[r, 0], Subscript[r, 0]}]}}]

Find all ways to express the unit rectangle in terms of Parallelogram:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[]; Subscript[ℛ, 2] = Parallelogram[{x, y}, {{a1, a2}, {b1, b2}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]
Wolfram Language code: Subscript[ℛ, 2] /. Solve[%]

Verify the results:

Wolfram Language code: RegionEqual@@Prepend[%, Subscript[ℛ, 1]]

Express an implicitly defined ellipse through Ellipsoid:

Wolfram Language code: ℛ = ImplicitRegion[x ^ 2 - x y + 3y ^ 2 ≤ 1, {x, y}];
Wolfram Language code: RegionEqual[ℛ, Ellipsoid[{0, 0}, {{a, b}, {c, d}}]]

Find a value for each parameter:

Wolfram Language code: Ellipsoid[{0, 0}, {{a, b}, {c, d}}] /. FindInstance[%, {a, b, c, d}]

Visualize both representations:

Wolfram Language code: {RegionPlot[ℛ], Graphics[%, Frame -> True, AspectRatio -> 1]}

Demonstrate De Morgan's law, :

Wolfram Language code: Subscript[ℛ, 1] = Disk[{0, 0}, 1]; Subscript[ℛ, 2] = Disk[{1, 0}, 1];
Wolfram Language code: complement[reg_] := BooleanRegion[Not, {reg}]
Wolfram Language code: dr1 = RegionIntersection[Subscript[ℛ, 1], Subscript[ℛ, 2]]; dr2 = complement[RegionUnion[complement[Subscript[ℛ, 1]], complement[Subscript[ℛ, 2]]]];
Wolfram Language code: RegionEqual[dr1, dr2]
Wolfram Language code: BoundaryDiscretizeRegion /@ {dr1, dr2}

Properties & Relations  (4)

Equivalent regions have all points in common:

Wolfram Language code: Subscript[ℛ, 1] = Disk[]; Subscript[ℛ, 2] = ImplicitRegion[x^2 + y^2 ≤ 1, {x, y}];
Wolfram Language code: Resolve[ForAll[{x, y}, {x, y}∈Subscript[ℛ, 1]⧦{x, y}∈Subscript[ℛ, 2]], Reals]
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]

RegionEqual can be expressed with RegionWithin:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[]; Subscript[ℛ, 2] = Parallelogram[{0, 0}, {{1, 0}, {0, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]
Wolfram Language code: RegionWithin[Subscript[ℛ, 1], Subscript[ℛ, 2]] && RegionWithin[Subscript[ℛ, 2], Subscript[ℛ, 1]]

For non‐empty regions, RegionDisjoint returns False when RegionEqual returns True:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[]; Subscript[ℛ, 2] = Parallelogram[{0, 0}, {{1, 0}, {0, 1}}];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]
Wolfram Language code: RegionDisjoint[Subscript[ℛ, 1], Subscript[ℛ, 2]]

Use FindInstance to find points that lie in one region but not the other:

Wolfram Language code: Subscript[ℛ, 1] = Rectangle[]; Subscript[ℛ, 2] = Parallelogram[];
Wolfram Language code: RegionEqual[Subscript[ℛ, 1], Subscript[ℛ, 2]]
Wolfram Language code: pts = {x, y} /. FindInstance[{x, y}∈Subscript[ℛ, 1]⊻{x, y}∈Subscript[ℛ, 2], {x, y}, 100];
Wolfram Language code: Graphics[{Point[pts], Opacity[0.5], {Red, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}}]

Use RandomPoint to find a uniform sampling of points that lie in one region but not the other:

Wolfram Language code: pts = RandomPoint[BooleanRegion[Xor, {Subscript[ℛ, 1], Subscript[ℛ, 2]}], 100];
Wolfram Language code: Graphics[{Point[pts], Opacity[0.5], {Red, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}}]

Use Reduce to find where two regions differ:

Wolfram Language code: Reduce[{x, y}∈Subscript[ℛ, 1]⊻{x, y}∈Subscript[ℛ, 2], {x, y}]
Wolfram Language code: RegionPlot[%, {x, -1, 3}, {y, -3 / 2, 5 / 2}, PlotPoints -> 60]
Wolfram Research (2017), RegionEqual, Wolfram Language function, https://reference.wolfram.com/language/ref/RegionEqual.html.

Text

Wolfram Research (2017), RegionEqual, Wolfram Language function, https://reference.wolfram.com/language/ref/RegionEqual.html.

CMS

Wolfram Language. 2017. "RegionEqual." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/RegionEqual.html.

APA

Wolfram Language. (2017). RegionEqual. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/RegionEqual.html

BibTeX

@misc{reference.wolfram_2026_regionequal, author="Wolfram Research", title="{RegionEqual}", year="2017", howpublished="\url{https://reference.wolfram.com/language/ref/RegionEqual.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_regionequal, organization={Wolfram Research}, title={RegionEqual}, year={2017}, url={https://reference.wolfram.com/language/ref/RegionEqual.html}, note=[Accessed: 13-June-2026]}