public override bool StructurallyEquals(Object obj)
{
Strengthened s = obj as Strengthened;
if (s == null)
{
return(false);
}
return(this.original.StructurallyEquals(s.original) && this.strengthened.StructurallyEquals(s.strengthened));
}
public override bool Equals(Object obj)
{
Strengthened thatS = obj as Strengthened;
if (thatS == null)
{
return(false);
}
return(this.original.Equals(thatS.original) && this.strengthened.GetType() == thatS.strengthened.GetType());
}
private static void InstantiateRightTriangle(Strengthened right, Strengthened iso)
{
Triangle rightTri = right.strengthened as Triangle;
Triangle isoTri = iso.strengthened as Triangle;
if (!rightTri.StructurallyEquals(isoTri)) return;
rightTri.SetProvenToBeIsosceles();
rightTri.SetProvenToBeRight();
isoTri.SetProvenToBeRight();
isoTri.SetProvenToBeIsosceles();
}
public static List<EdgeAggregator> InstantiateFromPerpendicularBisector(GroundedClause original, PerpendicularBisector pb)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
Strengthened streng1 = new Strengthened(pb.originalInter, new Perpendicular(pb.originalInter));
Strengthened streng2 = new Strengthened(pb.originalInter, new SegmentBisector(pb.originalInter, pb.bisector));
newGrounded.Add(new EdgeAggregator(antecedent, streng1, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, streng2, annotation));
return newGrounded;
}
private static List<EdgeAggregator> InstantiateToTheorem(Rhombus rhombus, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// Instantiate this rhombus diagonals ONLY if the original figure has the diagonals drawn.
if (rhombus.diagonalIntersection == null) return newGrounded;
// Determine the CongruentSegments opposing sides and output that.
Strengthened newPerpendicular = new Strengthened(rhombus.diagonalIntersection, new Perpendicular(rhombus.diagonalIntersection));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, newPerpendicular, annotation));
return newGrounded;
}
//
// Modify the given information to account for redundancy in stated nodes
// That is, does given information strengthen a figure node?
//
private List <ConcreteAST.GroundedClause> DoGivensStrengthenFigure()
{
List <ConcreteAST.GroundedClause> modifiedGivens = new List <ConcreteAST.GroundedClause>();
ConcreteAST.GroundedClause currentGiven = null;
foreach (ConcreteAST.GroundedClause given in givens)
{
currentGiven = given;
foreach (ConcreteAST.GroundedClause component in figure)
{
if (component.CanBeStrengthenedTo(given))
{
currentGiven = new ConcreteAST.Strengthened(component, given);
break;
}
}
modifiedGivens.Add(currentGiven);
}
return(modifiedGivens);
}
public static List<GenericInstantiator.EdgeAggregator> GeneratePerpendicularBisector(GroundedClause tri, AngleBisector ab, Intersection inter)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
IsoscelesTriangle isoTri = (tri is Strengthened ? (tri as Strengthened).strengthened : tri) as IsoscelesTriangle;
if (tri is EquilateralTriangle)
{
}
// Does the Angle Bisector occur at the vertex angle (non-base angles) of the Isosceles triangle?
try
{
if (!ab.angle.GetVertex().Equals(isoTri.GetVertexAngle().GetVertex())) return newGrounded;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
// Is the intersection point between the endpoints of the base of the triangle?
if (!Segment.Between(inter.intersect, isoTri.baseSegment.Point1, isoTri.baseSegment.Point2)) return newGrounded;
// Does this intersection define this angle bisector situation? That is, the bisector and base must align with the intersection
if (!inter.ImpliesRay(ab.bisector)) return newGrounded;
if (!inter.HasSegment(isoTri.baseSegment)) return newGrounded;
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(tri);
antecedent.Add(ab);
antecedent.Add(inter);
// PerpendicularBisector(M, Segment(M, C), Segment(A, B))
Strengthened newPerpB = new Strengthened(inter, new PerpendicularBisector(inter, ab.bisector));
newGrounded.Add(new EdgeAggregator(antecedent, newPerpB, annotation));
return newGrounded;
}
// Acquire the index of the clause in the hypergraph based only on structure
public static int StructuralIndex(Hypergraph.Hypergraph <ConcreteAST.GroundedClause, Hypergraph.EdgeAnnotation> graph, ConcreteAST.GroundedClause g)
{
//
// Handle general case
//
List <Hypergraph.HyperNode <ConcreteAST.GroundedClause, Hypergraph.EdgeAnnotation> > vertices = graph.vertices;
for (int v = 0; v < vertices.Count; v++)
{
if (vertices[v].data.StructurallyEquals(g))
{
return(v);
}
if (vertices[v].data is ConcreteAST.Strengthened)
{
if ((vertices[v].data as ConcreteAST.Strengthened).strengthened.StructurallyEquals(g))
{
return(v);
}
}
}
//
// Handle strengthening by seeing if the clause is found without a 'strengthening' component
//
ConcreteAST.Strengthened streng = g as ConcreteAST.Strengthened;
if (streng != null)
{
int index = StructuralIndex(graph, streng.strengthened);
if (index != -1)
{
return(index);
}
}
return(-1);
}
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;
}
// A _________________ B
// / /
// / \/ /
// / /\ /
// D /________________/ C
//
// Quadrilateral(A, B, C, D), SegmentBisector(Segment(A, C), Segment(B, D)),
// SegmentBisector(Segment(B, D), Segment(A, C)) -> Parallelogram(A, B, C, D)
//
private static List<EdgeAggregator> InstantiateToTheorem(Quadrilateral quad, SegmentBisector sb1, SegmentBisector sb2, GroundedClause originalSB1, GroundedClause originalSB2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The two segment bisectors must intersect at the same point
if (!sb1.bisected.intersect.StructurallyEquals(sb2.bisected.intersect)) return newGrounded;
// The bisectors must be part of the other segment bisector.
if (!sb1.bisected.HasSegment(sb2.bisector)) return newGrounded;
if (!sb2.bisected.HasSegment(sb1.bisector)) return newGrounded;
// Do these segment bisectors define the diagonals of the quadrilateral?
if (!sb1.bisector.HasSubSegment(quad.topLeftBottomRightDiagonal) && !sb2.bisector.HasSubSegment(quad.topLeftBottomRightDiagonal)) return newGrounded;
if (!sb1.bisector.HasSubSegment(quad.bottomLeftTopRightDiagonal) && !sb2.bisector.HasSubSegment(quad.bottomLeftTopRightDiagonal)) return newGrounded;
// Determine the CongruentSegments opposing sides and output that.
Strengthened newParallelogram = new Strengthened(quad, new Parallelogram(quad));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(quad);
antecedent.Add(originalSB1);
antecedent.Add(originalSB2);
newGrounded.Add(new EdgeAggregator(antecedent, newParallelogram, annotation));
return newGrounded;
}
private static List<EdgeAggregator> InstantiateFromAltitude(Intersection inter, Altitude altitude)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The intersection should contain the altitude segment
if (!inter.HasSegment(altitude.segment)) return newGrounded;
// The triangle should contain the other segment in the intersection
Segment triangleSide = altitude.triangle.CoincidesWithASide(inter.OtherSegment(altitude.segment));
if (triangleSide == null) return newGrounded;
if (!inter.OtherSegment(altitude.segment).HasSubSegment(triangleSide)) return newGrounded;
//
// Create the Perpendicular relationship
//
Strengthened streng = new Strengthened(inter, new Perpendicular(inter));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(inter);
antecedent.Add(altitude);
newGrounded.Add(new EdgeAggregator(antecedent, streng, annotation));
return newGrounded;
}
private static List<EdgeAggregator> CheckAndGeneratePerpendicular(Perpendicular perp, Parallel parallel, Intersection inter, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The perpendicular intersection must refer to one of the parallel segments
Segment shared = perp.CommonSegment(parallel);
if (shared == null) return newGrounded;
// The other intersection must refer to a segment in the parallel pair
Segment otherShared = inter.CommonSegment(parallel);
if (otherShared == null) return newGrounded;
// The two shared segments must be distinct
if (shared.Equals(otherShared)) return newGrounded;
// Transversals must align
if (!inter.OtherSegment(otherShared).Equals(perp.OtherSegment(shared))) return newGrounded;
// Strengthen the old intersection to be perpendicular
Strengthened strengthenedPerp = new Strengthened(inter, new Perpendicular(inter));
// Construct hyperedge
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
antecedent.Add(parallel);
antecedent.Add(inter);
newGrounded.Add(new EdgeAggregator(antecedent, strengthenedPerp, annotation));
return newGrounded;
}
//
// Implements 'transitivity' with right angles; that is, we may know two angles are congruent and if one is a right angle, the other is well
//
// Congruent(Angle(A, B, C), Angle(D, E, F), RightAngle(A, B, C) -> RightAngle(D, E, F)
//
public static List<EdgeAggregator> InstantiateToRightAngle(RightAngle ra, CongruentAngles cas, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The congruent must have the given angle in order to generate
if (!cas.HasAngle(ra)) return newGrounded;
Angle toBeRight = cas.OtherAngle(ra);
Strengthened newRightAngle = new Strengthened(toBeRight, new RightAngle(toBeRight));
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(original);
antecedent.Add(cas);
newGrounded.Add(new EdgeAggregator(antecedent, newRightAngle, transAnnotation));
return newGrounded;
}
private static List<EdgeAggregator> InstantiateToKite(Quadrilateral quad, CongruentSegments cs1, CongruentSegments cs2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The congruences should not share a side.
if (cs1.SharedSegment(cs2) != null) return newGrounded;
// The congruent pairs should not also be congruent to each other
if (cs1.cs1.CoordinateCongruent(cs2.cs1)) return newGrounded;
// Does both set of congruent segments apply to the quadrilateral?
if (!quad.HasAdjacentCongruentSides(cs1)) return newGrounded;
if (!quad.HasAdjacentCongruentSides(cs2)) return newGrounded;
//
// Create the new Kite object
//
Strengthened newKite = new Strengthened(quad, new Kite(quad));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(quad);
antecedent.Add(cs1);
antecedent.Add(cs2);
newGrounded.Add(new EdgeAggregator(antecedent, newKite, annotation));
return newGrounded;
}
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;
}
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;
}
//
// 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;
}
// ) | B
// ) |
// O )| S
// ) |
// ) |
// ) | A
// Tangent(Circle(O, R), Segment(A, B)), Intersection(OS, AB) -> Perpendicular(Segment(A,B), Segment(O, S))
//
private static List<EdgeAggregator> InstantiateTheorem(CircleSegmentIntersection inter, Perpendicular perp, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The intersection points must be the same.
if (!inter.intersect.StructurallyEquals(perp.intersect)) return newGrounded;
// Get the radius - if it exists
Segment radius = null;
Segment garbage = null;
inter.GetRadii(out radius, out garbage);
if (radius == null) return newGrounded;
// Two intersections, not a tangent situation.
if (garbage != null) return newGrounded;
// The radius can't be the same as the Circ-Inter segment.
if (inter.segment.HasSubSegment(radius)) return newGrounded;
// Does this perpendicular apply to this Arc intersection?
if (!perp.HasSegment(radius) || !perp.HasSegment(inter.segment)) return newGrounded;
Strengthened newTangent = new Strengthened(inter, new Tangent(inter));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
antecedent.Add(inter);
newGrounded.Add(new EdgeAggregator(antecedent, newTangent, annotation));
return newGrounded;
}
private static List<EdgeAggregator> MakeTrapezoid(Quadrilateral quad, Parallel parallel)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// Create the new Trapezoid object
//
Strengthened newTrapezoid = new Strengthened(quad, new Trapezoid(quad));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(quad);
antecedent.Add(parallel);
newGrounded.Add(new EdgeAggregator(antecedent, newTrapezoid, 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;
}
// A
// |)
// | )
// | )
// Q------- O---X---) D
// | )
// | )
// |)
// C
//
// Perpendicular(Segment(Q, D), Segment(A, C)) -> Congruent(Arc(A, D), Arc(D, C)) -> Congruent(Segment(AX), Segment(XC))
//
private static List<EdgeAggregator> InstantiateTheorem(Intersection inter, CircleSegmentIntersection arcInter, Perpendicular perp, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// Does this intersection apply to this perpendicular?
//
if (!inter.intersect.StructurallyEquals(perp.intersect)) return newGrounded;
// Is this too restrictive?
if (!((inter.HasSegment(perp.lhs) && inter.HasSegment(perp.rhs)) && (perp.HasSegment(inter.lhs) && perp.HasSegment(inter.rhs)))) return newGrounded;
//
// Does this perpendicular intersection apply to a given circle?
//
// Acquire the circles for which the segments are secants.
List<Circle> secantCircles1 = Circle.GetSecantCircles(perp.lhs);
List<Circle> secantCircles2 = Circle.GetSecantCircles(perp.rhs);
List<Circle> intersection = Utilities.Intersection<Circle>(secantCircles1, secantCircles2);
if (!intersection.Any()) return newGrounded;
//
// Find the single, unique circle that has as chords the components of the perpendicular intersection
//
Circle theCircle = null;
Segment chord1 = null;
Segment chord2 = null;
foreach (Circle circle in intersection)
{
chord1 = circle.GetChord(perp.lhs);
chord2 = circle.GetChord(perp.rhs);
if (chord1 != null && chord2 != null)
{
theCircle = circle;
break;
}
}
Segment diameter = chord1.Length > chord2.Length ? chord1 : chord2;
Segment chord = chord1.Length < chord2.Length ? chord1 : chord2;
//
// Does the arc intersection apply?
//
if (!arcInter.HasSegment(diameter)) return newGrounded;
if (!theCircle.StructurallyEquals(arcInter.theCircle)) return newGrounded;
//
// Create the bisector
//
Strengthened sb = new Strengthened(inter, new SegmentBisector(inter, diameter));
Strengthened ab = new Strengthened(arcInter, new ArcSegmentBisector(arcInter));
// For hypergraph
List<GroundedClause> antecedentArc = new List<GroundedClause>();
antecedentArc.Add(arcInter);
antecedentArc.Add(original);
antecedentArc.Add(theCircle);
newGrounded.Add(new EdgeAggregator(antecedentArc, ab, annotation));
List<GroundedClause> antecedentSegment = new List<GroundedClause>();
antecedentSegment.Add(inter);
antecedentSegment.Add(original);
antecedentSegment.Add(theCircle);
newGrounded.Add(new EdgeAggregator(antecedentSegment, sb, annotation));
return newGrounded;
}
private static List<EdgeAggregator> InstantiateToRhombus(Quadrilateral quad, CongruentSegments cs1, CongruentSegments cs2, CongruentSegments cs3)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// The 3 congruent segments pairs must relate; one pair must link the two others.
// Determine the link segments as well as the opposite sides.
//
CongruentSegments link = null;
CongruentSegments opp1 = null;
CongruentSegments opp2 = null;
if (cs1.SharedSegment(cs2) != null && cs1.SharedSegment(cs3) != null)
{
link = cs1;
opp1 = cs2;
opp2 = cs3;
}
else if (cs2.SharedSegment(cs1) != null && cs2.SharedSegment(cs3) != null)
{
link = cs2;
opp1 = cs1;
opp2 = cs3;
}
else if (cs3.SharedSegment(cs1) != null && cs3.SharedSegment(cs2) != null)
{
link = cs3;
opp1 = cs1;
opp2 = cs2;
}
else return newGrounded;
// Are the pairs on the opposite side of this quadrilateral?
if (!quad.HasOppositeCongruentSides(opp1)) return newGrounded;
if (!quad.HasOppositeCongruentSides(opp2)) return newGrounded;
//
// Create the new Rhombus object
//
Strengthened newRhombus = new Strengthened(quad, new Rhombus(quad));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(quad);
antecedent.Add(cs1);
antecedent.Add(cs2);
antecedent.Add(cs3);
newGrounded.Add(new EdgeAggregator(antecedent, newRhombus, annotation));
return newGrounded;
}
public static List<EdgeAggregator> InstantiateToRightAngle(GroundedClause clause)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
if (clause is AngleEquation)
{
AngleEquation eq = clause as AngleEquation;
//Filter for acceptable equations - both sides atomic
int atomicity = eq.GetAtomicity();
if (atomicity != Equation.BOTH_ATOMIC) return newGrounded;
//Check that the terms equate an angle to a measure
List<GroundedClause> lhs = eq.lhs.CollectTerms();
List<GroundedClause> rhs = eq.rhs.CollectTerms();
Angle angle = null;
NumericValue value = null;
if (lhs[0] is Angle && rhs[0] is NumericValue)
{
angle = lhs[0] as Angle;
value = rhs[0] as NumericValue;
}
else if (rhs[0] is Angle && lhs[0] is NumericValue)
{
angle = rhs[0] as Angle;
value = lhs[0] as NumericValue;
}
else
return newGrounded;
//Verify that the angle is a right angle
if (!Utilities.CompareValues(value.DoubleValue, 90.0)) return newGrounded;
Strengthened newRightAngle = new Strengthened(angle, new RightAngle(angle));
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(clause);
newGrounded.Add(new EdgeAggregator(antecedent, newRightAngle, defAnnotation));
return newGrounded;
}
else if (clause is CongruentAngles)
{
CongruentAngles cas = clause as CongruentAngles;
// Not interested in reflexive relationships in this case
if (cas.IsReflexive()) return newGrounded;
foreach (RightAngle ra in candidateRightAngles)
{
newGrounded.AddRange(InstantiateToRightAngle(ra, cas, ra));
}
foreach (Strengthened streng in candidateStrengthened)
{
newGrounded.AddRange(InstantiateToRightAngle(streng.strengthened as RightAngle, cas, streng));
}
candidateCongruentAngles.Add(clause as CongruentAngles);
}
else if (clause is RightAngle)
{
RightAngle ra = clause as RightAngle;
foreach (CongruentAngles oldCas in candidateCongruentAngles)
{
newGrounded.AddRange(InstantiateToRightAngle(ra, oldCas, ra));
}
candidateRightAngles.Add(ra);
}
else if (clause is Strengthened)
{
Strengthened streng = clause as Strengthened;
// Only intrerested in right angles
if (!(streng.strengthened is RightAngle)) return newGrounded;
foreach (CongruentAngles oldCas in candidateCongruentAngles)
{
newGrounded.AddRange(InstantiateToRightAngle(streng.strengthened as RightAngle, oldCas, streng));
}
candidateStrengthened.Add(streng);
}
return newGrounded;
}
//
// Modify the given information to account for redundancy in stated nodes
// That is, does given information strengthen a figure node?
//
private List<ConcreteAST.GroundedClause> DoGivensStrengthenFigure()
{
List<ConcreteAST.GroundedClause> modifiedGivens = new List<ConcreteAST.GroundedClause>();
ConcreteAST.GroundedClause currentGiven = null;
foreach (ConcreteAST.GroundedClause given in givens)
{
currentGiven = given;
foreach (ConcreteAST.GroundedClause component in figure)
{
if (component.CanBeStrengthenedTo(given))
{
currentGiven = new ConcreteAST.Strengthened(component, given);
break;
}
}
modifiedGivens.Add(currentGiven);
}
return modifiedGivens;
}
private static List<EdgeAggregator> InstantiateFromMedian(InMiddle im, Median median)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// Which point is on the side of the triangle?
Point vertexOnTriangle = median.theTriangle.GetVertexOn(median.medianSegment);
Segment segmentCutByMedian = median.theTriangle.GetOppositeSide(vertexOnTriangle);
Point midpt = segmentCutByMedian.FindIntersection(median.medianSegment);
// This is to acquire the name of the midpoint, nothing more.
if (midpt.Equals(median.medianSegment.Point1)) midpt = median.medianSegment.Point1;
else if (midpt.Equals(median.medianSegment.Point2)) midpt = median.medianSegment.Point2;
// Does this median apply to this InMiddle? Point check ...
if (!im.point.StructurallyEquals(midpt)) return newGrounded;
// Segment check
if (!im.segment.StructurallyEquals(segmentCutByMedian)) return newGrounded;
// Create the midpoint
Strengthened newMidpoint = new Strengthened(im, new Midpoint(im));
// For hypergraph
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(median);
antecedent.Add(im);
newGrounded.Add(new EdgeAggregator(antecedent, newMidpoint, annotation));
return newGrounded;
}
private static List<EdgeAggregator> InstantiateFromRightTriangle(RightTriangle rightTri, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// Strengthen the old triangle to a right triangle
Strengthened newStrengthened = new Strengthened(rightTri.rightAngle, new RightAngle(rightTri.rightAngle));
// Hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, newStrengthened, annotation));
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;
}
//
// 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;
}
private static List<EdgeAggregator> ReconfigureAndCheck(Strengthened streng1, Strengthened streng2, CongruentSegments css1, CongruentSegments css2)
{
return CollectAndCheckHL(streng1.strengthened as RightTriangle, streng2.strengthened as RightTriangle, css1, css2, streng1, streng2);
}
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;
}
//
// 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;
}
// ) | B
// ) |
// O )| S
// ) |
// ) |
// ) | A
// Tangent(Circle(O, R), Segment(A, B)), Intersection(OS, AB) -> Perpendicular(Segment(A,B), Segment(O, S))
//
private static List<EdgeAggregator> InstantiateTheorem(Tangent tangent, Intersection inter, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
CircleSegmentIntersection tanInter = tangent.intersection as CircleSegmentIntersection;
// Does this tangent segment apply to this intersection?
if (!inter.HasSegment(tanInter.segment)) return newGrounded;
// Get the radius--if it exists
Segment radius = null;
Segment garbage = null;
tanInter.GetRadii(out radius, out garbage);
if (radius == null) return newGrounded;
// Does this radius apply to this intersection?
if (!inter.HasSubSegment(radius)) return newGrounded;
Strengthened newPerp = new Strengthened(inter, new Perpendicular(inter));
// For hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
antecedent.Add(inter);
newGrounded.Add(new EdgeAggregator(antecedent, newPerp, 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;
}
//
// 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);
}
