// ) | 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); }
// 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); }