//
// DO NOT generate a new clause, instead, report the result and generate all applicable
//
private static List <EdgeAggregator> StrengthenToRightTriangle(Triangle tri, RightAngle ra, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// This angle must belong to this triangle.
if (!tri.HasAngle(ra))
{
return(newGrounded);
}
// Strengthen the old triangle to a right triangle
Strengthened newStrengthened = new Strengthened(tri, new RightTriangle(tri));
tri.SetProvenToBeRight();
// Hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(tri);
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, newStrengthened, annotation));
return(newGrounded);
}
private static List <EdgeAggregator> InstantiateToIsoscelesTrapezoid(Trapezoid trapezoid, CongruentSegments css, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Does this paralle set apply to this triangle?
if (!trapezoid.CreatesCongruentLegs(css))
{
return(newGrounded);
}
//
// Create the new IsoscelesTrapezoid object
//
Strengthened newIsoscelesTrapezoid = new Strengthened(trapezoid, new IsoscelesTrapezoid(trapezoid));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
antecedent.Add(css);
newGrounded.Add(new EdgeAggregator(antecedent, newIsoscelesTrapezoid, annotation));
return(newGrounded);
}
// A __________ B
// / \
// / \
// / \
// D /________________\ C
//
// Trapezoid(A, B, C, D) -> Parallel(Segment(A, B), Segment(C, D))
//
private static List <EdgeAggregator> InstantiateFromIsoscelesTrapezoid(GroundedClause clause)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is IsoscelesTrapezoid)
{
IsoscelesTrapezoid trapezoid = clause as IsoscelesTrapezoid;
newGrounded.AddRange(InstantiateFromIsoscelesTrapezoid(trapezoid, trapezoid));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
// Only interested in strenghthened intersection -> perpendicular or -> perpendicular bisector
if (!(streng.strengthened is IsoscelesTrapezoid))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateFromIsoscelesTrapezoid(streng.strengthened as IsoscelesTrapezoid, streng));
}
return(newGrounded);
}
// A _________________ B
// / /
// / \/ /
// / /\ /
// D /________________/ C
//
// Parallelogram(A, B, C, D) -> SegmentBisector(Segment(A, C), Segment(B, D)), SegmentBisector(Segment(B, D), Segment(A, C)),
//
private static List <EdgeAggregator> InstantiateTheorem(Parallelogram parallelogram, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Generate only if the diagonals are a part of the original figure.
if (parallelogram.diagonalIntersection == null)
{
return(newGrounded);
}
// Determine the CongruentSegments opposing sides and output that.
Intersection diagInter = parallelogram.diagonalIntersection;
Strengthened sb1 = new Strengthened(diagInter, new SegmentBisector(diagInter, diagInter.lhs));
Strengthened sb2 = new Strengthened(diagInter, new SegmentBisector(diagInter, diagInter.rhs));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, sb1, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, sb2, annotation));
return(newGrounded);
}
/// <summary>
/// Figure out what possible segment combinations are before showing the window.
/// </summary>
protected override void OnShow()
{
var options = new List <Midpoint>();
List <GroundedClause> current = new List <GroundedClause>();
//Populate current midpoint givens.
foreach (GroundedClause gc in currentGivens)
{
Midpoint m = gc as Midpoint;
if (m != null)
{
current.Add(m);
}
}
//Each inmiddle that can be strengthened to a midpoint that is not already a given is an option.
foreach (InMiddle im in parser.backendParser.implied.inMiddles)
{
Strengthened s = im.CanBeStrengthened();
if (s != null)
{
Midpoint m = s.strengthened as Midpoint;
if (!StructurallyContains(current, m))
{
options.Add(m);
}
}
}
optionsBox.ItemsSource = null; //Makes sure the box is graphically updated.
optionsBox.ItemsSource = options;
}
//
// This implements forward and Backward instantiation
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.PERPENDICULAR_DEFINITION;
// FROM Perpendicular
if (clause is Perpendicular)
{
return(InstantiateFromPerpendicular(clause, clause as Perpendicular));
}
// TO Perpendicular
if (clause is RightAngle || clause is Intersection)
{
return(InstantiateToPerpendicular(clause));
}
// Handle Strengthening; may be a Perpendicular (FROM) or Right Angle (TO)
Strengthened streng = clause as Strengthened;
if (streng != null)
{
if (streng.strengthened is Perpendicular && !(streng.strengthened is PerpendicularBisector))
{
return(InstantiateFromPerpendicular(clause, streng.strengthened as Perpendicular));
}
else if (streng.strengthened is RightAngle)
{
return(InstantiateToPerpendicular(clause));
}
}
return(new List <EdgeAggregator>());
}
// A _________________ B
// / /
// / /
// / /
// D /________________/ C
//
// Parallelogram(A, B, C, D) -> SegmentBisector(Segment(A, C), Segment(B, D)), SegmentBisector(Segment(B, D), Segment(A, C)),
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.DIAGONALS_PARALLELOGRAM_BISECT_EACH_OTHER;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Parallelogram)
{
Parallelogram newPara = clause as Parallelogram;
newGrounded.AddRange(InstantiateTheorem(newPara, newPara));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Parallelogram))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateTheorem(streng.strengthened as Parallelogram, streng));
}
return(newGrounded);
}
//
// Congruent(Segment(A, M), Segment(M, B)) -> Midpoint(M, Segment(A, B))
//
private static List <EdgeAggregator> InstantiateToMidpoint(InMiddle im, CongruentSegments css)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
Point midpoint = css.cs1.SharedVertex(css.cs2);
// Does this InMiddle relate to the congruent segments?
if (!im.point.StructurallyEquals(midpoint))
{
return(newGrounded);
}
// Do the congruent segments combine into a single segment equating to the InMiddle?
Segment overallSegment = new Segment(css.cs1.OtherPoint(midpoint), css.cs2.OtherPoint(midpoint));
if (!im.segment.StructurallyEquals(overallSegment))
{
return(newGrounded);
}
Strengthened newMidpoint = new Strengthened(im, new Midpoint(im));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(im);
antecedent.Add(css);
newGrounded.Add(new EdgeAggregator(antecedent, newMidpoint, annotation));
return(newGrounded);
}
//
// C
// |\
// | \
// | \
// | O
// | \
// |_ \
// A |_|____\ B
//
// SemiCircle(O, BC), Angle(BAC) -> RightAngle(BAC)
//
public static List <EdgeAggregator> InstantiateTheorem(Semicircle semi, Angle angle, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// The angle needs to be inscribed in the given semicircle
// Note: Previously this was checked indirectly by verifying that the angle intercepts a semicircle, but since semicircles now
// require 3 points to be defined, it is safer to directly verify that the angle is inscribed in the semicircle.
// (There may not have been any points defined on the other side of the diameter,
// meaning there would not actually be any defined semicircles which the angle intercepts).
if (!semi.AngleIsInscribed(angle))
{
return(newGrounded);
}
Strengthened newRight = new Strengthened(angle, new RightAngle(angle));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
antecedent.Add(angle);
newGrounded.Add(new EdgeAggregator(antecedent, newRight, annotation));
return(newGrounded);
}
private bool StronglyRelated(GroundedClause firstNode, GroundedClause secondNode)
{
if (firstNode is SegmentRatio && secondNode is SegmentRatio)
{
return(true);
}
if (firstNode is ProportionalAngles && secondNode is ProportionalAngles)
{
return(true);
}
if (firstNode is Congruent && secondNode is Congruent)
{
if (firstNode is CongruentAngles && secondNode is CongruentAngles)
{
return(true);
}
if (firstNode is CongruentSegments && secondNode is CongruentSegments)
{
return(true);
}
if (firstNode is CongruentTriangles && secondNode is CongruentTriangles)
{
return(true);
}
return(false);
}
if (firstNode is Equation && secondNode is Equation)
{
if (firstNode is AngleEquation && secondNode is AngleEquation)
{
return(true);
}
if (firstNode is SegmentEquation && secondNode is SegmentEquation)
{
return(true);
}
return(false);
}
//
// We may strenghthen for many reasons (right triangle, isosceles triangle as well as perpendicular bisector)
// Compare those strengthened values for a relationship
//
if (firstNode is Strengthened && secondNode is Strengthened)
{
Strengthened streng1 = firstNode as Strengthened;
Strengthened streng2 = secondNode as Strengthened;
return(StronglyRelated(streng1.strengthened, streng2.strengthened));
}
//if (firstNode is Similar)
//{
// return secondNode is Similar;
//}
return(firstNode.GetType() == secondNode.GetType());
}
private static List <EdgeAggregator> CheckAndGenerateSupplementaryCongruentImplyRightAngles(Supplementary supplementary, CongruentAngles conAngles)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
//The given pairs must contain the same angles (i.e., the angles must be both supplementary AND congruent)
if (!((supplementary.angle1.Equals(conAngles.ca1) && supplementary.angle2.Equals(conAngles.ca2)) ||
(supplementary.angle2.Equals(conAngles.ca1) && supplementary.angle1.Equals(conAngles.ca2))))
{
return(newGrounded);
}
//if (!(supplementary.StructurallyEquals(conAngles))) return newGrounded;
//
// Now we have two supplementary and congruent angles, which must be right angles
//
Strengthened streng = new Strengthened(supplementary.angle1, new RightAngle(supplementary.angle1));
Strengthened streng2 = new Strengthened(supplementary.angle2, new RightAngle(supplementary.angle2));
// Construct hyperedges
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(supplementary);
antecedent.Add(conAngles);
newGrounded.Add(new EdgeAggregator(antecedent, streng, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, streng2, annotation));
return(newGrounded);
}
public static void Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.RIGHT_TRIANGLE_DEFINITION;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
//
// Instantiating FROM a right triangle
//
Strengthened streng = clause as Strengthened;
if (streng == null)
{
return;
}
if (streng.strengthened is RightTriangle)
{
candidateRight.Add(streng);
foreach (Strengthened iso in candidateIsosceles)
{
InstantiateRightTriangle(streng, iso);
}
}
else if (streng.strengthened is IsoscelesTriangle)
{
candidateIsosceles.Add(streng);
foreach (Strengthened right in candidateRight)
{
InstantiateRightTriangle(right, streng);
}
}
}
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.RIGHT_TRIANGLE_DEFINITION;
//
// Instantiating FROM a right triangle
//
Strengthened streng = clause as Strengthened;
if (clause is RightTriangle)
{
return(InstantiateFromRightTriangle(clause as RightTriangle, clause));
}
if (streng != null && streng.strengthened is RightTriangle)
{
return(InstantiateFromRightTriangle(streng.strengthened as RightTriangle, clause));
}
//
// Instantiating TO a right triangle
//
if (clause is RightAngle || clause is Strengthened || clause is Triangle)
{
return(InstantiateToRightTriangle(clause));
}
return(new List <EdgeAggregator>());
}
private static List <EdgeAggregator> InstantiateToSquare(Rhombus rhombus, RightAngle ra, GroundedClause originalRhom, GroundedClause originalRightAngle)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Does this right angle apply to this quadrilateral?
if (!rhombus.HasAngle(ra))
{
return(newGrounded);
}
//
// Create the new Square object
//
Strengthened newSquare = new Strengthened(rhombus, new Square(rhombus));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(originalRhom);
antecedent.Add(originalRightAngle);
newGrounded.Add(new EdgeAggregator(antecedent, newSquare, annotation));
return(newGrounded);
}
// A _________________ B
// / /
// / /
// / /
// D /________________/ C
//
// Parallelogram(A, B, C, D) -> Congruent(Angle(DAB), Angle(BCD)), Congruent(Angle(ADC), Angle(ABC))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.OPPOSITE_ANGLES_PARALLELOGRAM_ARE_CONGRUENT;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Parallelogram)
{
Parallelogram para = clause as Parallelogram;
newGrounded.AddRange(InstantiateTheorem(para, para));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Parallelogram))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateTheorem(streng.strengthened as Parallelogram, streng));
}
return(newGrounded);
}
// A ________________ B
// | |
// | |
// | |
// D |________________| C
//
// Rectangle(A, B, C, D) -> Congruent(Segment(A, C), Segment(B, D))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.DIAGONALS_OF_RECTANGLE_ARE_CONGRUENT;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Rectangle)
{
Rectangle rectangle = clause as Rectangle;
newGrounded.AddRange(InstantiateToTheorem(rectangle, rectangle));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Rectangle))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateToTheorem(streng.strengthened as Rectangle, streng));
}
return(newGrounded);
}
//
// In order for two triangles to be isosceles, we require the following:
// IsoscelesTriangle(A, B, C) -> \angle BAC \cong \angle BCA
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.ISOSCELES_TRIANGLE_THEOREM;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (c is EquilateralTriangle || (c as Strengthened).strengthened is EquilateralTriangle)
{
return(newGrounded);
}
if (c is IsoscelesTriangle)
{
return(InstantiateTheorem(c, c as IsoscelesTriangle));
}
Strengthened streng = c as Strengthened;
if (streng != null)
{
if (streng.strengthened is IsoscelesTriangle)
{
return(InstantiateTheorem(c, streng.strengthened as IsoscelesTriangle));
}
}
return(newGrounded);
}
public static List <EdgeAggregator> InstantiateFromSegmentBisector(InMiddle im, SegmentBisector sb, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Does this bisector apply to this InMiddle? Check point of intersection
if (!im.point.StructurallyEquals(sb.bisected.intersect))
{
return(newGrounded);
}
// Segments must equate
if (!im.segment.StructurallyEquals(sb.bisected.OtherSegment(sb.bisector)))
{
return(newGrounded);
}
// Create the midpoint
Strengthened newMidpoint = new Strengthened(im, new Midpoint(im));
// For hypergraph
List <GroundedClause> antecedent = Utilities.MakeList <GroundedClause>(original);
antecedent.Add(im);
newGrounded.Add(new EdgeAggregator(antecedent, newMidpoint, annotation));
return(newGrounded);
}
private static List <EdgeAggregator> CheckAndGenerateCongruentAdjacentImplyPerpendicular(Intersection intersection, CongruentAngles conAngles)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// The given angles must belong to the intersection. That is, the vertex must align and all rays must overlay the intersection.
if (!intersection.InducesBothAngles(conAngles))
{
return(newGrounded);
}
//
// Now we have perpendicular scenario
//
Strengthened streng = new Strengthened(intersection, new Perpendicular(intersection));
// Construct hyperedge
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(intersection);
antecedent.Add(conAngles);
newGrounded.Add(new EdgeAggregator(antecedent, streng, annotation));
return(newGrounded);
}
// A _______ B
// / \
// Y /_________\ Z
// / \
// D /_____________\ C
//
// Trapezoid(A, B, C, D), Median(Y, Z) -> Parallel(Segment(A, B), Segment(Y, Z)), Parallel(Segment(C, D), Segment(Y, Z))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.MEDIAN_TRAPEZOID_PARALLEL_TO_BASE;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Trapezoid)
{
Trapezoid trapezoid = clause as Trapezoid;
newGrounded.AddRange(InstantiateToTheorem(trapezoid, trapezoid));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Trapezoid))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateToTheorem(streng.strengthened as Trapezoid, streng));
}
return(newGrounded);
}
// A _______ B
// / \
// / \
// / \
// D /_____________\ C
//
// IsoscelesTrapezoid(A, B, C, D) -> Congruent(Angle(A, D, C), Angle(B, C, D)), Congruent(Angle(D, A, B), Angle(C, B, A))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.BASE_ANGLES_OF_ISOSCELES_TRAPEZOID_CONGRUENT;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is IsoscelesTrapezoid)
{
IsoscelesTrapezoid trapezoid = clause as IsoscelesTrapezoid;
newGrounded.AddRange(InstantiateToTheorem(trapezoid, trapezoid));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is IsoscelesTrapezoid))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateToTheorem(streng.strengthened as IsoscelesTrapezoid, streng));
}
return(newGrounded);
}
//
// Kite(A, B, C, D) -> Perpendicular(Intersection(Segment(A, C), Segment(B, D))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.DIAGONALS_OF_KITE_ARE_PERPENDICULAR;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Kite)
{
Kite kite = clause as Kite;
newGrounded.AddRange(InstantiateToTheorem(kite, kite));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Kite))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateToTheorem(streng.strengthened as Kite, streng));
}
return(newGrounded);
}
private static List <EdgeAggregator> InstantiateToTheorem(Quadrilateral quad, CongruentSegments cs1, CongruentSegments cs2)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Are the pairs on the opposite side of this quadrilateral?
if (!quad.HasOppositeCongruentSides(cs1))
{
return(newGrounded);
}
if (!quad.HasOppositeCongruentSides(cs2))
{
return(newGrounded);
}
//
// Create the new Rhombus object
//
Strengthened newParallelogram = new Strengthened(quad, new Parallelogram(quad));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(quad);
antecedent.Add(cs1);
antecedent.Add(cs2);
newGrounded.Add(new EdgeAggregator(antecedent, newParallelogram, annotation));
return(newGrounded);
}
private static List <EdgeAggregator> InstantiateToParallelogram(Quadrilateral quad, Parallel parallel1, Parallel parallel2)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Does this paralle set apply to this triangle?
if (!quad.HasOppositeParallelSides(parallel1))
{
return(newGrounded);
}
if (!quad.HasOppositeParallelSides(parallel2))
{
return(newGrounded);
}
//
// Create the new Parallelogram object
//
Strengthened newParallelogram = new Strengthened(quad, new Parallelogram(quad));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(quad);
antecedent.Add(parallel1);
antecedent.Add(parallel2);
newGrounded.Add(new EdgeAggregator(antecedent, newParallelogram, annotation));
return(newGrounded);
}
// A __________ B
// | |
// | |
// | |
// D |__________| C
//
// Rhombus(A, B, C, D) -> AngleBisector(Angle(A, B, C), Segment(B, D))
// AngleBisector(Angle(A, D, C), Segment(B, D))
// AngleBisector(Angle(B, A, D), Segment(A, C))
// AngleBisector(Angle(B, C, D), Segment(A, C))
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.DIAGONALS_OF_RHOMBUS_BISECT_ANGLES_OF_RHOMBUS;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Rhombus)
{
Rhombus rhombus = clause as Rhombus;
newGrounded.AddRange(InstantiateToTheorem(rhombus, rhombus));
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Rhombus))
{
return(newGrounded);
}
newGrounded.AddRange(InstantiateToTheorem(streng.strengthened as Rhombus, streng));
}
return(newGrounded);
}
private static List <EdgeAggregator> InstantiateToRectangle(Parallelogram parallelogram, RightAngle ra, GroundedClause originalPara, GroundedClause originalRightAngle)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Does this right angle apply to this quadrilateral?
if (!parallelogram.HasAngle(ra))
{
return(newGrounded);
}
//
// Create the new Rectangle object
//
Strengthened newRectangle = new Strengthened(parallelogram, new Rectangle(parallelogram));
// For hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(originalPara);
antecedent.Add(originalRightAngle);
newGrounded.Add(new EdgeAggregator(antecedent, newRectangle, annotation));
return(newGrounded);
}
private static List <EdgeAggregator> InstantiateToDefinition(Triangle tri, CongruentSegments cs1, CongruentSegments cs2)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Do these congruences relate one common segment?
Segment shared = cs1.SharedSegment(cs2);
if (shared == null)
{
return(newGrounded);
}
//
// Do these congruences apply to this triangle?
//
if (!tri.HasSegment(cs1.cs1) || !tri.HasSegment(cs1.cs2))
{
return(newGrounded);
}
if (!tri.HasSegment(cs2.cs1) || !tri.HasSegment(cs2.cs2))
{
return(newGrounded);
}
//
// These cannot be reflexive congruences.
//
if (cs1.IsReflexive() || cs2.IsReflexive())
{
return(newGrounded);
}
//
// Are the non-shared segments unique?
//
Segment other1 = cs1.OtherSegment(shared);
Segment other2 = cs2.OtherSegment(shared);
if (other1.StructurallyEquals(other2))
{
return(newGrounded);
}
//
// Generate the new equialteral clause
//
Strengthened newStrengthened = new Strengthened(tri, new EquilateralTriangle(tri));
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(cs1);
antecedent.Add(cs2);
antecedent.Add(tri);
newGrounded.Add(new EdgeAggregator(antecedent, newStrengthened, annotation));
return(newGrounded);
}
//
// C
// /)
// / )
// / )
// / )
// A /)_________ B
//
// Tangent(Circle(O), Segment(AB)), Intersection(Segment(AC), Segment(AB)) -> 2 * Angle(CAB) = Arc(C, B)
//
public static List <EdgeAggregator> Instantiate(GroundedClause clause)
{
annotation.active = EngineUIBridge.JustificationSwitch.CHORD_AND_TANGENT_ANGLE_IS_HALF_INTERCEPTED_ARC;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is Intersection)
{
Intersection newInter = clause as Intersection;
foreach (Tangent tangent in candidateTangent)
{
newGrounded.AddRange(InstantiateTheorem(newInter, tangent, tangent));
}
foreach (Strengthened streng in candidateStrengthened)
{
newGrounded.AddRange(InstantiateTheorem(newInter, streng.strengthened as Tangent, streng));
}
candidateIntersection.Add(newInter);
}
else if (clause is Tangent)
{
Tangent tangent = clause as Tangent;
if (!(tangent.intersection is CircleSegmentIntersection))
{
return(newGrounded);
}
foreach (Intersection oldInter in candidateIntersection)
{
newGrounded.AddRange(InstantiateTheorem(oldInter, tangent, tangent));
}
candidateTangent.Add(tangent);
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
if (!(streng.strengthened is Tangent))
{
return(newGrounded);
}
foreach (Intersection oldInter in candidateIntersection)
{
newGrounded.AddRange(InstantiateTheorem(oldInter, streng.strengthened as Tangent, streng));
}
candidateStrengthened.Add(streng);
}
return(newGrounded);
}
//
// T
// |\
// | \
// | \ N <-----------Right Angle
// | / \
// |/___\
// U S
//
// Altitude(Segment(U, N), Triangle(S, U, T)), RightTriangle(S, U, T) -> Similar(RightTriangle(S, U, T), RightTriangle(S, N, U)),
// Similar(RightTriangle(S, N, U), RightTriangle(U, N, T))
// Similar(RightTriangle(U, N, T), RightTriangle(S, U, T))
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.ALTITUDE_OF_RIGHT_TRIANGLES_IMPLIES_SIMILAR;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (!(c is Altitude) && !(c is RightTriangle) && !(c is Strengthened))
{
return(newGrounded);
}
if (c is Strengthened)
{
Strengthened streng = c as Strengthened;
if (!(streng.strengthened is RightTriangle))
{
return(newGrounded);
}
foreach (Altitude altitude in candidateAltitudes)
{
newGrounded.AddRange(InstantiateRight(streng.strengthened as RightTriangle, altitude, streng));
}
candidateStrengthened.Add(streng);
}
else if (c is RightTriangle)
{
RightTriangle rt = c as RightTriangle;
foreach (Altitude altitude in candidateAltitudes)
{
newGrounded.AddRange(InstantiateRight(rt, altitude, rt));
}
candRightTriangles.Add(rt);
}
else if (c is Altitude)
{
Altitude altitude = c as Altitude;
foreach (RightTriangle rt in candRightTriangles)
{
newGrounded.AddRange(InstantiateRight(rt, altitude, rt));
}
foreach (Strengthened stren in candidateStrengthened)
{
newGrounded.AddRange(InstantiateRight(stren.strengthened as RightTriangle, altitude, stren));
}
candidateAltitudes.Add(altitude);
}
return(newGrounded);
}
//
// DO NOT generate a new clause, instead, report the result and generate all applicable
// clauses attributed to this strengthening of a triangle from scalene to isosceles
//
private static EdgeAggregator StrengthenToIsosceles(Triangle tri, CongruentSegments ccss)
{
Strengthened newStrengthened = new Strengthened(tri, new IsoscelesTriangle(tri));
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(ccss);
antecedent.Add(tri);
return(new EdgeAggregator(antecedent, newStrengthened, annotation));
}
