private static List <EdgeAggregator> InstantiateFromRectangle(Rectangle rectangle, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
//
// Determine the parallel opposing sides and output that.
//
List <Strengthened> newRightAngles = new List <Strengthened>();
foreach (Angle rectAngle in rectangle.angles)
{
Angle figureAngle = Angle.AcquireFigureAngle(rectAngle);
newRightAngles.Add(new Strengthened(figureAngle, new RightAngle(figureAngle)));
}
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
foreach (Strengthened rightAngle in newRightAngles)
{
newGrounded.Add(new EdgeAggregator(antecedent, rightAngle, annotation));
}
return(newGrounded);
}
//
// Intersect(X, Segment(A, B), Segment(C, D)) -> Congruent(Angle(A, X, C), Angle(B, X, D)),
// Congruent(Angle(A, X, D), Angle(C, X, B))
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.VERTICAL_ANGLES;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
Intersection inter = c as Intersection;
if (inter == null)
{
return(newGrounded);
}
//
// Verify that this intersection is composed of two overlapping segments
// That is, we do not allow a segment to stand on another:
// \
// \
// \
// ______\_______
//
if (inter.StandsOn())
{
return(newGrounded);
}
//
// Congruent(Angle(A, X, C), Angle(B, X, D))
//
List <GroundedClause> antecedent1 = Utilities.MakeList <GroundedClause>(inter);
Angle ang1Set1 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point1, inter.intersect, inter.rhs.Point1));
Angle ang2Set1 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point2, inter.intersect, inter.rhs.Point2));
antecedent1.Add(ang1Set1);
antecedent1.Add(ang2Set1);
GeometricCongruentAngles cca1 = new GeometricCongruentAngles(ang1Set1, ang2Set1);
cca1.MakeIntrinsic(); // This is an 'obvious' notion so it should be intrinsic to any figure
newGrounded.Add(new EdgeAggregator(antecedent1, cca1, annotation));
//
// Congruent(Angle(A, X, D), Angle(C, X, B))
//
List <GroundedClause> antecedent2 = Utilities.MakeList <GroundedClause>(inter);
Angle ang1Set2 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point1, inter.intersect, inter.rhs.Point2));
Angle ang2Set2 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point2, inter.intersect, inter.rhs.Point1));
antecedent2.Add(ang1Set2);
antecedent2.Add(ang2Set2);
GeometricCongruentAngles cca2 = new GeometricCongruentAngles(ang1Set2, ang2Set2);
cca2.MakeIntrinsic(); // This is an 'obvious' notion so it should be intrinsic to any figure
newGrounded.Add(new EdgeAggregator(antecedent2, cca2, annotation));
return(newGrounded);
}
// A
// /)
// / )
// / )
// center: O )
// \ )
// \ )
// \)
// C
//
// D
// /)
// / )
// / )
// center: Q )
// \ )
// \ )
// \)
// F
//
// Congruent(Arc(A, C), Arc(D, F)) -> Congruent(Angle(AOC), Angle(DQF))
//
private static List <EdgeAggregator> InstantiateConversePartOfTheorem(CongruentArcs cas)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
//
// Get the radii (and determine if the exist in the figure)
//
Segment radius11;
Segment radius12;
cas.ca1.GetRadii(out radius11, out radius12);
if (radius11 == null || radius12 == null)
{
return(newGrounded);
}
Segment radius21;
Segment radius22;
cas.ca2.GetRadii(out radius21, out radius22);
if (radius21 == null || radius22 == null)
{
return(newGrounded);
}
//
// Acquire the central angles from the respoitory
//
Angle central1 = Angle.AcquireFigureAngle(new Angle(radius11, radius12));
Angle central2 = Angle.AcquireFigureAngle(new Angle(radius21, radius22));
if (central1 == null || central2 == null)
{
return(newGrounded);
}
GeometricCongruentAngles gcas = new GeometricCongruentAngles(central1, central2);
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(central1);
antecedent.Add(central2);
antecedent.Add(cas);
newGrounded.Add(new EdgeAggregator(antecedent, gcas, converseAnnotation));
return(newGrounded);
}
// A B
// \ /
// \ /
// \/
// /\ X
// / \
// / \
// C D
//
// Intersection(X, Segment(A, D), Segment(B, C)) -> Supplementary(Angle(A, X, B), Angle(B, X, D))
// Supplementary(Angle(B, X, D), Angle(D, X, C))
// Supplementary(Angle(D, X, C), Angle(C, X, A))
// Supplementary(Angle(C, X, A), Angle(A, X, B))
//
public static List <EdgeAggregator> InstantiateToSupplementary(Intersection inter)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// The situation looks like this:
// |
// |
// |_______
//
if (inter.StandsOnEndpoint())
{
return(newGrounded);
}
// The situation looks like this:
// |
// |
// _____|_______
//
if (inter.StandsOn())
{
Point up = null;
Point left = null;
Point right = null;
if (inter.lhs.HasPoint(inter.intersect))
{
up = inter.lhs.OtherPoint(inter.intersect);
left = inter.rhs.Point1;
right = inter.rhs.Point2;
}
else
{
up = inter.rhs.OtherPoint(inter.intersect);
left = inter.lhs.Point1;
right = inter.lhs.Point2;
}
// Gets the single angle object from the original figure
Angle newAngle1 = Angle.AcquireFigureAngle(new Angle(left, inter.intersect, up));
Angle newAngle2 = Angle.AcquireFigureAngle(new Angle(right, inter.intersect, up));
Supplementary supp = new Supplementary(newAngle1, newAngle2);
supp.SetNotASourceNode();
supp.SetNotAGoalNode();
supp.SetClearDefinition();
newGrounded.Add(new EdgeAggregator(MakeAntecedent(inter, supp.angle1, supp.angle2), supp, annotation));
}
//
// The situation is standard and results in 4 supplementary relationships
//
else
{
Angle newAngle1 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point1, inter.intersect, inter.rhs.Point1));
Angle newAngle2 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point1, inter.intersect, inter.rhs.Point2));
Angle newAngle3 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point2, inter.intersect, inter.rhs.Point1));
Angle newAngle4 = Angle.AcquireFigureAngle(new Angle(inter.lhs.Point2, inter.intersect, inter.rhs.Point2));
List <Supplementary> newSupps = new List <Supplementary>();
newSupps.Add(new Supplementary(newAngle1, newAngle2));
newSupps.Add(new Supplementary(newAngle2, newAngle4));
newSupps.Add(new Supplementary(newAngle3, newAngle4));
newSupps.Add(new Supplementary(newAngle3, newAngle1));
foreach (Supplementary supp in newSupps)
{
supp.SetNotASourceNode();
supp.SetNotAGoalNode();
supp.SetClearDefinition();
newGrounded.Add(new EdgeAggregator(MakeAntecedent(inter, supp.angle1, supp.angle2), supp, annotation));
}
}
return(newGrounded);
}
//
// A \
// \ B
// \ /
// O \/ X
// /\
// / \
// C / D
//
// One Secant, One Tangent
// Intersection(X, AD, BC), Tangent(Circle(O), BC) -> 2 * Angle(AXC) = MajorArc(AC) - MinorArc(AC)
//
public static List <EdgeAggregator> InstantiateOneSecantOneTangentTheorem(Intersection inter, Tangent tangent, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
CircleSegmentIntersection tan = tangent.intersection as CircleSegmentIntersection;
// Is the tangent segment part of the intersection?
if (!inter.HasSegment(tan.segment))
{
return(newGrounded);
}
// Acquire the chord that the intersection creates.
Segment secant = inter.OtherSegment(tan.segment);
Circle circle = tan.theCircle;
Segment chord = circle.ContainsChord(secant);
// Check if this segment never intersects the circle or doesn't create a chord.
if (chord == null)
{
return(newGrounded);
}
//
// Get the near / far points out of the chord
//
Point closeChordPt = null;
Point farChordPt = null;
if (Segment.Between(chord.Point1, chord.Point2, inter.intersect))
{
closeChordPt = chord.Point1;
farChordPt = chord.Point2;
}
else
{
closeChordPt = chord.Point2;
farChordPt = chord.Point1;
}
//
// Acquire the arcs
//
// Get the close arc first which we know exactly how it is constructed AND that it's a minor arc.
Arc closeArc = Arc.GetFigureMinorArc(circle, closeChordPt, tan.intersect);
// The far arc MAY be a major arc; if it is, the first candidate arc will contain the close arc.
Arc farArc = Arc.GetFigureMinorArc(circle, farChordPt, tan.intersect);
if (farArc.HasMinorSubArc(closeArc))
{
farArc = Arc.GetFigureMajorArc(circle, farChordPt, tan.intersect);
}
Angle theAngle = Angle.AcquireFigureAngle(new Angle(closeChordPt, inter.intersect, tan.intersect));
//
// Construct the new relationship
//
NumericValue two = new NumericValue(2);
GeometricAngleArcEquation gaaeq = new GeometricAngleArcEquation(new Multiplication(two, theAngle), new Subtraction(farArc, closeArc));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
antecedent.Add(inter);
antecedent.Add(closeArc);
antecedent.Add(farArc);
newGrounded.Add(new EdgeAggregator(antecedent, gaaeq, annotation));
return(newGrounded);
}
//
// A \
// \ B
// \ /
// O \/ X
// /\
// / \
// C / D
//
// Two Secants
// Intersection(X, AD, BC) -> 2 * Angle(AXC) = MajorArc(AC) - MinorArc(AC)
//
public static List <EdgeAggregator> InstantiateTwoSecantsTheorem(Intersection inter, Circle circle)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Is this intersection explicitly outside the circle? That is, the point of intersection exterior?
if (!circle.PointIsExterior(inter.intersect))
{
return(newGrounded);
}
//
// Get the chords
//
Segment chord1 = circle.ContainsChord(inter.lhs);
Segment chord2 = circle.ContainsChord(inter.rhs);
if (chord1 == null || chord2 == null)
{
return(newGrounded);
}
Point closeChord1Pt = null;
Point closeChord2Pt = null;
Point farChord1Pt = null;
Point farChord2Pt = null;
if (Segment.Between(chord1.Point1, chord1.Point2, inter.intersect))
{
closeChord1Pt = chord1.Point1;
farChord1Pt = chord1.Point2;
}
else
{
closeChord1Pt = chord1.Point2;
farChord1Pt = chord1.Point1;
}
if (Segment.Between(chord2.Point1, chord2.Point2, inter.intersect))
{
closeChord2Pt = chord2.Point1;
farChord2Pt = chord2.Point2;
}
else
{
closeChord2Pt = chord2.Point2;
farChord2Pt = chord2.Point1;
}
//
// Get the arcs
//
Arc closeArc = Arc.GetFigureMinorArc(circle, closeChord1Pt, closeChord2Pt);
Arc farArc = Arc.GetFigureMinorArc(circle, farChord1Pt, farChord2Pt);
Angle theAngle = Angle.AcquireFigureAngle(new Angle(closeChord1Pt, inter.intersect, closeChord2Pt));
//
// Construct the new relationship
//
NumericValue two = new NumericValue(2);
//GeometricAngleEquation gaeq = new GeometricAngleEquation(new Multiplication(two, theAngle), new Subtraction(farArc, closeArc));
GeometricAngleArcEquation gaaeq = new GeometricAngleArcEquation(new Multiplication(two, theAngle), new Subtraction(farArc, closeArc));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(inter);
antecedent.Add(circle);
antecedent.Add(closeArc);
antecedent.Add(farArc);
newGrounded.Add(new EdgeAggregator(antecedent, gaaeq, annotation));
return(newGrounded);
}
//
// A \ / B
// \ /
// \ /
// O \/ X
// /\
// / \
// C / \ D
//
// Intersection(Segment(AD), Segment(BC)) -> 2 * Angle(CXA) = Arc(A, C) + Arc(B, D),
// 2 * Angle(BXD) = Arc(A, C) + Arc(B, D),
// 2 * Angle(AXB) = Arc(A, B) + Arc(C, D),
// 2 * Angle(CXD) = Arc(A, B) + Arc(C, D)
//
public static List <EdgeAggregator> InstantiateTheorem(Intersection inter, Circle circle)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Is this intersection explicitly inside the circle? That is, the point of intersection interior?
if (!circle.PointIsInterior(inter.intersect))
{
return(newGrounded);
}
//
// Get the chords
//
Segment chord1 = circle.GetChord(inter.lhs);
Segment chord2 = circle.GetChord(inter.rhs);
if (chord1 == null || chord2 == null)
{
return(newGrounded);
}
//
// Group 1
//
Arc arc1 = Arc.GetFigureMinorArc(circle, chord1.Point1, chord2.Point1);
Angle angle1 = Angle.AcquireFigureAngle(new Angle(chord1.Point1, inter.intersect, chord2.Point1));
Arc oppArc1 = Arc.GetFigureMinorArc(circle, chord1.Point2, chord2.Point2);
Angle oppAngle1 = Angle.AcquireFigureAngle(new Angle(chord1.Point2, inter.intersect, chord2.Point2));
//
// Group 2
//
Arc arc2 = Arc.GetFigureMinorArc(circle, chord1.Point1, chord2.Point2);
Angle angle2 = Angle.AcquireFigureAngle(new Angle(chord1.Point1, inter.intersect, chord2.Point2));
Arc oppArc2 = Arc.GetFigureMinorArc(circle, chord1.Point2, chord2.Point1);
Angle oppAngle2 = Angle.AcquireFigureAngle(new Angle(chord1.Point2, inter.intersect, chord2.Point1));
//
// Construct each of the 4 equations.
//
NumericValue two = new NumericValue(2);
GeometricAngleArcEquation gaeq1 = new GeometricAngleArcEquation(new Multiplication(two, angle1), new Addition(arc1, oppArc1));
GeometricAngleArcEquation gaeq2 = new GeometricAngleArcEquation(new Multiplication(two, oppAngle1), new Addition(arc1, oppArc1));
GeometricAngleArcEquation gaeq3 = new GeometricAngleArcEquation(new Multiplication(two, angle2), new Addition(arc2, oppArc2));
GeometricAngleArcEquation gaeq4 = new GeometricAngleArcEquation(new Multiplication(two, oppAngle2), new Addition(arc2, oppArc2));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(inter);
antecedent.Add(circle);
newGrounded.Add(new EdgeAggregator(antecedent, gaeq1, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, gaeq2, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, gaeq3, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, gaeq4, annotation));
return(newGrounded);
}
