---

Definition: geo-point
Point ==  g."Point"

Definition: geo-primitives
GeometryPrimitives ==  "Point":Type"O":Point ⟶ Point ⟶ Point ⟶ Point ⟶ ℙ"L":Point ⟶ Point ⟶ Point ⟶ ℙ

Lemma: geo-primitives_wf
GeometryPrimitives ∈ 𝕌'

Definition: mk-eu-prim
Point=P O=O Left=L ==  λx.x["Point" := P]["O" := O]["L" := L]

Lemma: mk-eu-prim_wf
∀[P:Type]. ∀[O:P ⟶ P ⟶ P ⟶ P ⟶ ℙ]. ∀[L:P ⟶ P ⟶ P ⟶ ℙ].  (Point=P O=O Left=L ∈ GeometryPrimitives)

Lemma: geo-point_wf
∀[g:GeometryPrimitives]. (Point ∈ Type)

Definition: geo-gt-prim
ab>cd ==  g."O" a b c d

Lemma: geo-gt-prim_wf
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  (ab>cd ∈ ℙ)

Definition: geo-sep
a # b ==  ab>aa

Lemma: geo-sep_wf
∀[g:GeometryPrimitives]. ∀[a,b:Point].  (a # b ∈ ℙ)

Definition: geo-left
a leftof bc ==  g."L" a b c

Lemma: geo-left_wf
∀[g:GeometryPrimitives]. ∀[a,b,c:Point].  (a leftof bc ∈ ℙ)

Definition: geo-lsep
a # bc ==  a leftof bc ∨ a leftof cb

Lemma: geo-lsep_wf
∀[g:GeometryPrimitives]. ∀[a,b,c:Point].  (a # bc ∈ ℙ)

Definition: geo-between
B(abc) ==  ((¬ab>ac) ∧ (¬bc>ac)) ∧ (¬a # bc)

Lemma: geo-between_wf
∀[g:GeometryPrimitives]. ∀[a,b,c:Point].  (B(abc) ∈ ℙ)

Definition: geo-length-sep
ab # cd) ==  cd>ab ∨ ab>cd

Lemma: geo-length-sep_wf
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  (ab # cd) ∈ ℙ)

Definition: geo-congruent
ab ≅ cd ==  ¬ab # cd)

Lemma: geo-congruent_wf
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  (ab ≅ cd ∈ ℙ)

Definition: geo-eq
a ≡ b ==  ¬a # b

Lemma: geo-eq_wf
∀[g:GeometryPrimitives]. ∀[a,b:Point].  (a ≡ b ∈ ℙ)

Definition: geo-ge
ab ≥ cd ==  ¬cd>ab

Lemma: geo-ge_wf
∀[g:GeometryPrimitives]. ∀[c,d,a,b:Point].  (cd ≥ ab ∈ ℙ)

Lemma: stable__geo-ge
∀[g:GeometryPrimitives]. ∀[c,d,a,b:Point].  Stable{cd ≥ ab}

Lemma: sq_stable__geo-ge
∀[g:GeometryPrimitives]. ∀[c,d,a,b:Point].  SqStable(cd ≥ ab)

Definition: geo-gt
cd > ab ==  ↓∃w:Point. (B(cwd) ∧ cw ≅ ab ∧ w # d)

Lemma: geo-gt_wf
∀[g:GeometryPrimitives]. ∀[c,d,a,b:Point].  (cd > ab ∈ ℙ)

Lemma: sq_stable__geo-gt
∀[g:GeometryPrimitives]. ∀[c,d,a,b:Point].  SqStable(cd > ab)

Definition: geo-strict-between
a-b-c ==  B(abc) ∧ a # b ∧ b # c

Lemma: geo-strict-between_wf
∀[g:GeometryPrimitives]. ∀[a,b,c:Point].  (a-b-c ∈ ℙ)

Definition: geo-colinear
Colinear(a;b;c) ==  ¬a # bc

Lemma: geo-colinear_wf
∀[e:GeometryPrimitives]. ∀[a,b,c:Point].  (Colinear(a;b;c) ∈ ℙ)

Lemma: stable__colinear
∀e:GeometryPrimitives. ∀[a,b,c:Point].  Stable{Colinear(a;b;c)}

Lemma: sq_stable__colinear
∀e:GeometryPrimitives. ∀[a,b,c:Point].  SqStable(Colinear(a;b;c))

Definition: geo-midpoint
a=m=b ==  B(amb) ∧ am ≅ mb

Lemma: geo-midpoint_wf
∀[e:GeometryPrimitives]. ∀[m,a,b:Point].  (a=m=b ∈ ℙ)

Definition: right-angle
Rabc ==  ∀c':Point. (c'=b=c ⇒ ac ≅ ac')

Lemma: right-angle_wf
∀[e:GeometryPrimitives]. ∀[a,b,c:Point].  (Rabc ∈ ℙ)

Definition: acute-angle
Acute(a;b;c) ==  ∀c':Point. (c'=b=c ⇒ ac' > ac)

Lemma: acute-angle_wf
∀[e:GeometryPrimitives]. ∀[a,b,c:Point].  (Acute(a;b;c) ∈ ℙ)

Definition: obtuse-angle
Obtuse(a;b;c) ==  ∀c':Point. (c'=b=c ⇒ ac > ac')

Lemma: obtuse-angle_wf
∀[e:GeometryPrimitives]. ∀[a,b,c:Point].  (Obtuse(a;b;c) ∈ ℙ)

Definition: basic-geo-axioms
BasicGeometryAxioms(g) ==
  ((∀a,b,c,d:Point.  (ab>cd ⇒ ab ≥ cd)) ∧ (∀a,b,c:Point.  (ba>ac ⇒ b # c)) ∧ (∀a,b,c:Point.  bc ≥ aa))
  ∧ (∀a,b,c,d,e,f:Point.  (ab>cd ⇒ cd ≥ ef ⇒ ab>ef))
  ∧ (∀a,b,c,d,e,f:Point.  (ab ≥ cd ⇒ cd>ef ⇒ ab>ef))
  ∧ (∀a,b,c:Point.  (B(abc) ⇒ b # c ⇒ ac>ab))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b # c))
  ∧ (∀a,b,c,d:Point.  (B(abd) ⇒ B(bcd) ⇒ B(abc)))
  ∧ (∀a,b,c,d,A,B,C,D:Point.  (a # b ⇒ B(abc) ⇒ B(ABC) ⇒ ab ≅ AB ⇒ bc ≅ BC ⇒ ad ≅ AD ⇒ bd ≅ BD ⇒ cd ≅ CD))
  ∧ (∀a,b,c,x,y:Point.  (ax ≅ ay ⇒ bx ≅ by ⇒ cx ≅ cy ⇒ x # y ⇒ (¬a # bc)))
  ∧ (∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z leftof ab))
  ∧ (∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ (¬y # ab) ⇒ y # bc))

Lemma: basic-geo-axioms_wf
∀[g:GeometryPrimitives]. (BasicGeometryAxioms(g) ∈ ℙ)

Lemma: sq_stable-geo-axioms-if
∀[g:GeometryPrimitives]
  ((∀a,b,c:Point.  SqStable(B(abc)))
  ⇒ (∀a,b,c,d:Point.  SqStable(ab ≅ cd))
  ⇒ (∀a,b,c,d:Point.  SqStable(ab>cd))
  ⇒ (∀a,b,c:Point.  (SqStable(a # bc) ∧ (BasicGeometryAxioms(g) ⇒ a leftof bc ⇒ (¬a leftof cb))))
  ⇒ SqStable(BasicGeometryAxioms(g)))

Definition: geo-left-axioms
geo-left-axioms(g) ==
  (∀a,b,c:Point.  (¬a # bc ⇐⇒ Colinear(a;b;c)))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b # c))
  ∧ (∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z # ab))
  ∧ (∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ Colinear(y;a;b) ⇒ y # bc))

Lemma: geo-left-axioms_wf
∀[g:GeometryPrimitives]. (geo-left-axioms(g) ∈ ℙ)

Lemma: basic-geo-cong-preserves-gt-prim
∀e:GeometryPrimitives. (BasicGeometryAxioms(e) ⇒ (∀a,b,c,d,x,y:Point.  (ab ≅ cd ⇒ cd>xy ⇒ ab>xy)))

Lemma: basic-geo-cong-preserves-gt-prim2
∀g:GeometryPrimitives. (BasicGeometryAxioms(g) ⇒ (∀a,b,c,d,e,f:Point.  (ab>cd ⇒ cd ≅ ef ⇒ ab>ef)))

Lemma: geo-sep-irreflexive
∀e:GeometryPrimitives. (BasicGeometryAxioms(e) ⇒ (∀a:Point. (¬a # a)))

Lemma: geo-axiom-contrapositive
∀g:GeometryPrimitives. (BasicGeometryAxioms(g) ⇒ (∀a,b,c:Point.  ((¬b # c) ⇒ (¬ba>ac))))

Lemma: geo-gt-prim-irreflexive
∀e:GeometryPrimitives. (BasicGeometryAxioms(e) ⇒ (∀a,b:Point.  (¬ab>ba)))

Lemma: geo-congruent-flip
∀e:GeometryPrimitives. (BasicGeometryAxioms(e) ⇒ (∀[a,b:Point].  ab ≅ ba))

Lemma: basic-geo-sep-sym
∀e:GeometryPrimitives. (BasicGeometryAxioms(e) ⇒ (∀a,b:Point.  (a # b ⇒ b # a)))

Lemma: geo-axioms-imply
∀g:GeometryPrimitives
  (BasicGeometryAxioms(g)
  ⇒ ((∀a:Point. (¬a # a))
     ∧ (∀a,b,x,y:Point.  ((¬a # b) ⇒ B(xay) ⇒ B(xby)))
     ∧ (∀a,b,c:Point.  ((¬a # b) ⇒ ac ≅ cb))
     ∧ (∀a,b,c,d:Point.  ((¬¬(∃w:Point. (B(cwd) ∧ cw ≅ ab))) ⇒ a # b ⇒ c # d))
     ∧ (∀a,b,c:Point.  ((¬a # b) ⇒ B(abc)))
     ∧ (∀a,b,c:Point.  (B(abc) ⇒ B(cba)))
     ∧ (∀a,b,c,d:Point.  (B(abd) ⇒ B(bcd) ⇒ B(abc)))
     ∧ (∀a,b:Point.  aa ≅ bb)
     ∧ (∀a,b,p,q,r,s:Point.  (ab ≅ pq ⇒ ab ≅ rs ⇒ pq ≅ rs))
     ∧ (∀a,b,c,d,A,B,C,D:Point.  (a # b ⇒ B(abc) ⇒ B(ABC) ⇒ ab ≅ AB ⇒ bc ≅ BC ⇒ ad ≅ AD ⇒ bd ≅ BD ⇒ cd ≅ CD))
     ∧ (∀a,b,c,x,y:Point.  (ax ≅ ay ⇒ bx ≅ by ⇒ cx ≅ cy ⇒ x # y ⇒ (¬a # bc)))))

Lemma: geo-gt-prim-symmetry
∀g:GeometryPrimitives. (BasicGeometryAxioms(g) ⇒ (∀a,b,c,d:Point.  (ab>cd ⇒ (ba>cd ∧ ab>dc ∧ ba>dc))))

Lemma: stable_geo-eq
∀[e:GeometryPrimitives]. ∀[a,b:Point].  Stable{a ≡ b}

Lemma: sq_stable__geo-eq
∀[e:GeometryPrimitives]. ∀[a,b:Point].  SqStable(a ≡ b)

Definition: circle-overlap
Overlap(a;b;c;d) ==  ↓∃p,q:Point. ((ab ≅ ap ∧ cd ≥ cp) ∧ cd ≅ cq ∧ ab ≥ aq)

Lemma: circle-overlap_wf
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  (Overlap(a;b;c;d) ∈ ℙ)

Lemma: sq_stable__circle-overlap
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  SqStable(Overlap(a;b;c;d))

Definition: circle-strict-overlap
StrictOverlap(a;b;c;d) ==  ↓∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ ab>aq)

Lemma: circle-strict-overlap_wf
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  (StrictOverlap(a;b;c;d) ∈ ℙ)

Lemma: sq_stable__circle-strict-overlap
∀[g:GeometryPrimitives]. ∀[a,b,c,d:Point].  SqStable(StrictOverlap(a;b;c;d))

Definition: euclidean-plane-structure
EuclideanPlaneStructure ==
  GeometryPrimitives
  "Ssquashstable":∀a,b,c,d:Point.  SqStable(ab>cd)
  "Lorsquashstable":∀a,b,c:Point.  SqStable(a leftof bc ∨ a leftof cb)
  "SepOr":∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (a # c ∨ b # c)
  "nontrivial":∃a:Point. (∃b:Point [a # b])
  "SS":∀a,b:Point. ∀u:{u:Point| u leftof ab} . ∀v:{v:Point| v leftof ba} .  (∃x:Point [((¬a # bx) ∧ B(uxv))])
  "SC":∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  (∃u:Point [(cu ≅ cd ∧ B(abu) ∧ (b # d ⇒ b # u))])
  "CC":∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:{d:Point| StrictOverlap(a;b;c;d)} .
         (∃u:Point [(ab ≅ au ∧ cd ≅ cu ∧ u leftof ac)])

Lemma: euclidean-plane-structure_wf
EuclideanPlaneStructure ∈ 𝕌'

Comment: old-def-of-CC
This is the version we had.
But it seems we can at least simplify CC to construct just the point on the left.

⌜EuclideanPlaneStructure ==
   GeometryPrimitives
   "Bstable":∀[a,b,c:Point].  Stable{B(abc)}
   "Estable":∀[a,b,c,d:Point].  Stable{ab ≅ cd}
   "Ssquashstable":∀a,b:Point.  SqStable(a # b)
   "Lorsquashstable":∀a,b,c:Point.  SqStable(a leftof bc ∨ a leftof cb)
   "SepOr":∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (a # c ∨ b # c)
   "nontrivial":∃a:Point. (∃b:Point [a # b])
   "SS":∀a,b:Point. ∀u:{u:Point| u leftof ab} . ∀v:{v:Point| v leftof ba} .  (∃x:Point [(Colinear(a;b;x) ∧ B(uxv))])
   "SC":∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .
          ∃u:{u:Point| cu ≅ cd ∧ B(abu)} . (∃v:Point [(cv ≅ cd ∧ B(vbu) ∧ Colinear(a;b;v) ∧ (b # d ⇒ v # u))])
   "CC":∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:{d:Point| Overlap(a;b;c;d)} .
          ∃u:{u:Point| ab ≅ au ∧ cd ≅ cu} 
           (∃v:Point [((ab ≅ av ∧ cd ≅ cv) ∧ (StrictOverlap(a;b;c;d) ⇒ (u leftof ac ∧ v leftof ca)))])⌝
⋅

Lemma: euclidean-plane-structure-subtype
EuclideanPlaneStructure ⊆r GeometryPrimitives

Definition: geo-SS
geo-SS(g;a;b;u;v) ==  g."SS" a b u v

Lemma: geo-SS_wf
∀[g:EuclideanPlaneStructure]. ∀[a,b:Point]. ∀[u:{u:Point| u leftof ab} ]. ∀[v:{v:Point| v leftof ba} ].
  (geo-SS(g;a;b;u;v) ∈ {x:Point| Colinear(a;b;x) ∧ B(uxv)} )

Lemma: stable__geo-between
∀g:EuclideanPlaneStructure. ∀[a,b,c:Point].  Stable{B(abc)}

Lemma: sq_stable__geo-between
∀g:EuclideanPlaneStructure. ∀[a,b,c:Point].  SqStable(B(abc))

Lemma: use-plane-sep
∀g:EuclideanPlaneStructure. ∀a,b,u,v:Point.  (u leftof ab ⇒ v leftof ba ⇒ (∃x:Point. (Colinear(a;b;x) ∧ B(uxv))))

Lemma: stable__geo-congruent
∀g:EuclideanPlaneStructure. ∀[a,b,c,d:Point].  Stable{ab ≅ cd}

Lemma: sq_stable__geo-congruent
∀g:EuclideanPlaneStructure. ∀[a,b,c,d:Point].  SqStable(ab ≅ cd)

Lemma: sq_stable__midpoint
∀e:EuclideanPlaneStructure. ∀[a,b,c:Point].  SqStable(a=c=b)

Lemma: sq_stable__geo-gt-prim
∀g:EuclideanPlaneStructure. ∀a,b,c,d:Point.  SqStable(ab>cd)

Lemma: sq_stable__geo-sep
∀g:EuclideanPlaneStructure. ∀a,b:Point.  SqStable(a # b)

Lemma: geo-gt-prim-irrefl
∀g:EuclideanPlaneStructure. (BasicGeometryAxioms(g) ⇒ (∀a,b,c,d:Point.  (ab>cd ⇒ (¬cd>ab))))

Lemma: basic-geo-not-left-and-right
∀g:EuclideanPlaneStructure. (BasicGeometryAxioms(g) ⇒ (∀a,b,c:Point.  (a leftof bc ⇒ (¬a leftof cb))))

Lemma: sq_stable__geo-lsep
∀g:EuclideanPlaneStructure. ∀a,b,c:Point.  SqStable(a # bc)

Lemma: sq_stable__geo-strict-between
∀g:EuclideanPlaneStructure. ∀a,b,c:Point.  SqStable(a-b-c)

Lemma: sq_stable__geo-axioms
∀g:EuclideanPlaneStructure. SqStable(BasicGeometryAxioms(g))

Lemma: basic-geo-axioms-imply
∀g:EuclideanPlaneStructure
  (BasicGeometryAxioms(g) ⇒ ((∀a:Point. a ≡ a) ∧ (∀a,b:Point.  ab ≅ ba) ∧ (∀a,b,c:Point.  (a ≡ b ⇒ ac ≅ bc))))

Lemma: basic-axioms-imply_between1
∀e:EuclideanPlaneStructure. (BasicGeometryAxioms(e) ⇒ (∀a1,a2,b,c:Point.  (a1 ≡ a2 ⇒ B(a1bc) ⇒ B(a2bc))))

Lemma: basic-axioms-imply_between2
∀e:EuclideanPlaneStructure. (BasicGeometryAxioms(e) ⇒ (∀a,b1,b2,c:Point.  (b1 ≡ b2 ⇒ B(ab1c) ⇒ B(ab2c))))

Lemma: implies-geo-between_functionality
∀e:EuclideanPlaneStructure
  (BasicGeometryAxioms(e) ⇒ (∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (B(a1b1c1) ⇐⇒ B(a2b2c2)))))

Definition: geo-CC
CC(a;b;c;d) ==  e."CC" a b c d

Lemma: geo-CC_wf
∀[g:EuclideanPlaneStructure]. ∀[a,b:Point]. ∀[c:{c:Point| a # c} ]. ∀[d:{d:Point| StrictOverlap(a;b;c;d)} ].
  (CC(a;b;c;d) ∈ {u:Point| ab ≅ au ∧ cd ≅ cu ∧ u leftof ac} )

Definition: geo-SC
SC(a;b;c;d) ==  g."SC" c d a b

Lemma: geo-SC_wf
∀[g:EuclideanPlaneStructure]
  ∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  (SC(a;b;c;d) ∈ {u:Point| cu ≅ cd ∧ B(abu) ∧ (b # d ⇒ b # u)} )

Definition: geo-SCO
SCO(a;b;c;d) ==  SC(a;b;c;d)

Lemma: geo-SCO_wf
∀[g:EuclideanPlaneStructure]
  ∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  (SCO(a;b;c;d) ∈ {u:Point| cu ≅ cd ∧ B(abu) ∧ (b # d ⇒ b # u)} )

Lemma: circle-strict-overlap-implies-overlap
∀g:GeometryPrimitives. (BasicGeometryAxioms(g) ⇒ (∀a,b,c,d:Point.  (StrictOverlap(a;b;c;d) ⇒ Overlap(a;b;c;d))))

Definition: geo-CCL
CCL(a;b;c;d) ==  CC(a;b;c;d)

Lemma: geo-CCL_wf
∀[g:EuclideanPlaneStructure]
  (BasicGeometryAxioms(g)
  ⇒ (∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:Point.
        CCL(a;b;c;d) ∈ {u:Point| ab ≅ au ∧ cd ≅ cu ∧ u leftof ac}  supposing ∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ \000Cab>aq)))

Definition: geo-CCR
geo-CCR(g;a;b;c;d) ==  CC(c;d;a;b)

Lemma: geo-CCR_wf
∀[g:EuclideanPlaneStructure]
  ∀a,b:Point. ∀c:{c:Point| c # a} . ∀d:Point.
    geo-CCR(g;a;b;c;d) ∈ {v:Point| ab ≅ av ∧ cd ≅ cv ∧ v leftof ca}  supposing ∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq \000C∧ ab>aq)

Definition: extra-left-axiom
extra-left-axiom(g) ==  ∀a,b,c,a':Point.  (B(aba') ⇒ ab ≅ a'b ⇒ ab ≅ cb ⇒ c # a ⇒ c # a' ⇒ a # bc)

Lemma: extra-left-axiom_wf
∀[g:GeometryPrimitives]. (extra-left-axiom(g) ∈ ℙ)

Definition: right-angles-congruent-axiom
right-angles-congruent-axiom(e) ==
  ∀a,b,c,x,y,z:Point.  (((Rabc ∧ Rxyz) ∧ (x # y ∧ y # z) ∧ a # b ∧ b # c) ⇒ abc ≅a xyz)

Lemma: sq_stable__geo-left-1
∀g:EuclideanPlaneStructure
  (BasicGeometryAxioms(g) ⇒ (∀a,b,c:Point.  (a # bc ⇒ (¬Colinear(a;b;c)))) ⇒ (∀a,b,c:Point.  SqStable(a leftof bc)))

Lemma: sq_stable__geo-left-axioms-1
∀g:EuclideanPlaneStructure
  (BasicGeometryAxioms(g) ⇒ (∀a,b,c:Point.  (a # bc ⇒ (¬Colinear(a;b;c)))) ⇒ SqStable(geo-left-axioms(g)))

Definition: euclidean-plane
EuclideanPlane ==  {g:EuclideanPlaneStructure| BasicGeometryAxioms(g)} 

Lemma: euclidean-plane_wf
EuclideanPlane ∈ 𝕌'

Lemma: euclidean-plane-subtype
EuclideanPlane ⊆r EuclideanPlaneStructure

Lemma: use-basic-geo-axioms-lemma
∀g:EuclideanPlane
  (((∀a,b,c,d:Point.  (ab>cd ⇒ ab ≥ cd)) ∧ (∀a,b,c:Point.  (ba>ac ⇒ b # c)) ∧ (∀a,b,c:Point.  bc ≥ aa))
  ∧ (∀a,b,c,d,e,f:Point.  (ab>cd ⇒ cd ≥ ef ⇒ ab>ef))
  ∧ (∀a,b,c,d,e,f:Point.  (ab ≥ cd ⇒ cd>ef ⇒ ab>ef))
  ∧ (∀a,b,c:Point.  (B(abc) ⇒ b # c ⇒ ac>ab))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b # c))
  ∧ (∀a,b,c,d:Point.  (B(abd) ⇒ B(bcd) ⇒ B(abc)))
  ∧ (∀a,b,c,d,A,B,C,D:Point.  (a # b ⇒ B(abc) ⇒ B(ABC) ⇒ ab ≅ AB ⇒ bc ≅ BC ⇒ ad ≅ AD ⇒ bd ≅ BD ⇒ cd ≅ CD))
  ∧ (∀a,b,c,x,y:Point.  (ax ≅ ay ⇒ bx ≅ by ⇒ cx ≅ cy ⇒ x # y ⇒ (¬a # bc)))
  ∧ (∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z leftof ab))
  ∧ (∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ (¬y # ab) ⇒ y # bc)))

Lemma: euclidean-plane-axioms
∀g:EuclideanPlane
  (((∀a,b:Point.  (a # b ⇒ b # a))
   ∧ (∀a:Point. (¬a # a))
   ∧ (∀a,b,x,y:Point.  (a ≡ b ⇒ B(xay) ⇒ B(xby)))
   ∧ ((∀a,b,c:Point.  (a ≡ b ⇒ ac ≅ cb)) ∧ (∀a,b,c:Point.  (a ≡ b ⇒ ac ≅ bc)))
   ∧ (∀a,b,c,d:Point.  (cd ≥ ab ⇒ a # b ⇒ c # d))
   ∧ (∀a,b,c:Point.  (a ≡ b ⇒ B(abc)))
   ∧ (∀a,b,c:Point.  (B(abc) ⇒ B(cba)))
   ∧ (∀a,b,c,d:Point.  (B(abd) ⇒ B(bcd) ⇒ B(abc)))
   ∧ (∀a,b:Point.  ab ≅ ba)
   ∧ (∀a,b,p,q,r,s:Point.  (ab ≅ pq ⇒ ab ≅ rs ⇒ pq ≅ rs))
   ∧ (∀a,b:Point.  aa ≅ bb)
   ∧ (∀a,b,c,d,A,B,C,D:Point.  (a # b ⇒ B(abc) ⇒ B(ABC) ⇒ ab ≅ AB ⇒ bc ≅ BC ⇒ ad ≅ AD ⇒ bd ≅ BD ⇒ cd ≅ CD)))
  ∧ (∀a,b,c:Point.  (¬a # bc ⇐⇒ Colinear(a;b;c)))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b # c))
  ∧ (∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z # ab))
  ∧ (∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ Colinear(y;a;b) ⇒ y # bc)))

Lemma: geo-congruent-flip2
∀e:EuclideanPlane. ∀[a,b:Point].  ab ≅ ba

Lemma: geo-cong-preserves-gt-prim
∀e:EuclideanPlane. ∀a,b,c,d,x,y:Point.  (ab ≅ cd ⇒ cd>xy ⇒ ab>xy)

Lemma: geo-cong-preserves-gt-prim2
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (ab>cd ⇒ cd ≅ ef ⇒ ab>ef)

Lemma: geo-gt-prim-symmetry2
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (ab>cd ⇒ (ba>cd ∧ ab>dc ∧ ba>dc))

Lemma: upper-dimension-axiom
∀g:EuclideanPlane. ∀a,b,c,x,y:Point.  (ax ≅ ay ⇒ bx ≅ by ⇒ cx ≅ cy ⇒ x # y ⇒ Colinear(a;b;c))

Lemma: sq_stable__geo-left
∀g:EuclideanPlane. ∀a,b,c:Point.  SqStable(a leftof bc)

Lemma: sq_stable__geo-left-axioms
∀g:EuclideanPlane
  SqStable((∀a,b,c:Point.  (¬a # bc ⇐⇒ Colinear(a;b;c)))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca))
  ∧ (∀a,b,c:Point.  (a leftof bc ⇒ b # c))
  ∧ (∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z # ab))
  ∧ (∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ Colinear(y;a;b) ⇒ y # bc)))

Lemma: geo-CCL-left
∀g:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:Point.
  ((∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ ab>aq)) ⇒ CCL(a;b;c;d) leftof ac)

Lemma: geo-CCR-right
∀g:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:Point.
  ((∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ ab>aq)) ⇒ geo-CCR(g;a;b;c;d) leftof ca)

Lemma: geo-gt-prim-ge-trans
∀e:EuclideanPlane. ∀a,b,c,d,f,g:Point.  (ab>cd ⇒ cd ≥ fg ⇒ ab>fg)

Lemma: geo-gt-implies-geo-gt-prim
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ ab>cd)

Lemma: geo-eq_weakening
∀[e:EuclideanPlane]. ∀[a,b:Point].  a ≡ b supposing a = b ∈ Point

Lemma: geo-eq-self
∀[e:EuclideanPlane]. ∀[a:Point].  a ≡ a

Lemma: geo-eq_inversion
∀[e:EuclideanPlane]. ∀[a,b:Point].  a ≡ b supposing b ≡ a

Lemma: geo-ge-sep
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (cd ≥ ab ⇒ a # b ⇒ c # d)

Lemma: geo-congruence-identity
∀e:EuclideanPlane. ∀a,b,c:Point.  (cc ≅ ab ⇒ a ≡ b)

Lemma: geo-congruent-left-comm
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  ba ≅ cd supposing ab ≅ cd

Lemma: geo-congruent-refl
∀e:EuclideanPlane. ∀[a,b:Point].  ab ≅ ab

Lemma: geo-congruent-symmetry
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  cd ≅ ab supposing ab ≅ cd

Lemma: geo-congruent-transitivity
∀e:EuclideanPlane. ∀[a,b,c,d,x,y:Point].  (ab ≅ xy) supposing (cd ≅ xy and ab ≅ cd)

Lemma: geo-congruent-full-symmetry
∀e:EuclideanPlane
  ∀[a,b,c,d:Point].  {ba ≅ cd ∧ ab ≅ dc ∧ ba ≅ dc ∧ cd ≅ ab ∧ dc ≅ ab ∧ cd ≅ ba ∧ dc ≅ ba} supposing ab ≅ cd

Lemma: geo-congruent-functionality-lemma
∀g:EuclideanPlane
  ((∀a,b,c:Point.  (a ≡ b ⇒ ac ≅ bc))
  ⇒ (∀a1,a2,b1,b2,c1,c2,d1,d2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ a1b1 ≅ c1d1 ⇒ a2b2 ≅ c2d2)))

Lemma: geo-congruent_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2,d1,d2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ (a1b1 ≅ c1d1 ⇐⇒ a2b2 ≅ c2d2))

Lemma: geo-gt-implies-ge
∀[g:EuclideanPlane]. ∀[c,d,a,b:Point].  cd ≥ ab supposing cd>ab

Definition: geo-M
M(a;b;c) ==  e."SepOr" a b c

Lemma: geo-M_wf
∀e:EuclideanPlaneStructure. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (M(a;b;c) ∈ a # c ∨ b # c)

Lemma: geo-sep-or
∀e:EuclideanPlaneStructure. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (a # c ∨ b # c)

Lemma: geo-gt-prim_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2,d1,d2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ (a1b1>c1d1 ⇐⇒ a2b2>c2d2))

Lemma: geo-sep-irrefl_gt-prim
∀e:EuclideanPlane. ∀a,b,c:Point.  (¬aa>bc)

Lemma: geo-gt-prim-transitivity
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (ab>cd ⇒ cd>ef ⇒ ab>ef)

Lemma: geo-congruence-identity-sym
∀[e:EuclideanPlane]. ∀[a,b,c:Point].  a ≡ b supposing ab ≅ cc

Lemma: geo-sep-sym
∀e:EuclideanPlane. ∀a,b:Point.  (a # b ⇒ b # a)

Lemma: geo-between_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (B(a1b1c1) ⇐⇒ B(a2b2c2)))

Lemma: geo-between-symmetry
∀e:EuclideanPlane. ∀[a,b,c:Point].  B(cba) supposing B(abc)

Lemma: geo-between-trivial2
∀e:EuclideanPlane. ∀[a,b:Point].  B(aab)

Lemma: geo-between-trivial
∀e:EuclideanPlane. ∀[a,b:Point].  B(abb)

Lemma: geo-congruent-sep
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab ≅ cd ⇒ c # d ⇒ a # b)

Definition: geo-nontrivial
geo-nontrivial(e) ==  e."nontrivial"

Lemma: geo-nontrivial_wf
∀[g:EuclideanPlaneStructure]. (geo-nontrivial(g) ∈ ∃a:Point. (∃b:Point [a # b]))

Definition: geo-O
O ==  fst(geo-nontrivial(e))

Lemma: geo-O_wf
∀e:EuclideanPlaneStructure. (O ∈ Point)

Definition: geo-X
X ==  snd(geo-nontrivial(e))

Lemma: geo-X_wf
∀e:EuclideanPlaneStructure. (X ∈ Point)

Lemma: geo-sep-O-X
∀e:EuclideanPlaneStructure. O # X

Lemma: geo-sep-exists
∀e:EuclideanPlane. ∀A:Point.  ∃A':Point. A # A'

Lemma: geo-ge_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2,d1,d2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ (a1b1 ≥ c1d1 ⇐⇒ a2b2 ≥ c2d2))

Lemma: geo-congruent-right-comm
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  ab ≅ dc supposing ab ≅ cd

Lemma: geo-congruent-comm
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  ba ≅ dc supposing ab ≅ cd

Lemma: geo-five-segment
∀e:EuclideanPlane
  ∀[a,b,c,d,A,B,C,D:Point].
    (cd ≅ CD) supposing (bd ≅ BD and ad ≅ AD and bc ≅ BC and ab ≅ AB and B(ABC) and B(abc) and a # b)

Lemma: geo-five-segment'
∀e:EuclideanPlane
  ∀[a,b,c,A,B,C:Point].
    (∀d,D:Point.  (cd ≅ CD) supposing (bd ≅ BD and ad ≅ AD)) supposing 
       (bc ≅ BC and 
       ab ≅ AB and 
       B(ABC) and 
       B(abc) and 
       a # b)

Lemma: geo-between-implies-ge
∀[g:EuclideanPlane]. ∀[a,b,c:Point].  ac ≥ ab supposing B(abc)

Lemma: geo-between-sep
∀g:EuclideanPlane. ∀a,b,x:Point.  (B(axb) ⇒ a # x ⇒ a # b)

Lemma: geo-between-sep1
∀g:EuclideanPlane. ∀a,b:Point.  ∀[x:{x:Point| B(axb) ∧ a # x} ]. a # b

Lemma: geo-between-same
∀[e:EuclideanPlane]. ∀[a,b:Point].  a ≡ b supposing B(aba)

Lemma: geo-gt-sep
∀e:EuclideanPlane. ∀A,B,C,P:Point.  (AB > CP ⇒ A # B)

Definition: sympoint
SymmetricPoint(a;p) ==  SCO(p;a;a;p)

Lemma: sympoint_wf
∀[e:EuclideanPlane]. ∀[a:Point]. ∀[p:{p:Point| a # p} ].  (SymmetricPoint(a;p) ∈ {p':Point| p=a=p'} )

Lemma: geo-Op-sep
∀g:EuclideanPlane. ∀p:{p:Point| B(OXp)} .  O # p

Lemma: geo-CC-2
∀g:EuclideanPlane. ∀a,b,c,d:Point.
  (a # c
  ⇒ (∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ ab>aq))
  ⇒ (∃z1,z2:Point. (az1 ≅ ab ∧ az2 ≅ ab ∧ cz1 ≅ cd ∧ cz2 ≅ cd ∧ z1 leftof ac ∧ z2 leftof ca)))

Lemma: geo-CC-lsep
∀g:EuclideanPlane. ∀a,b,c,d:Point.
  (a # c ⇒ (∃p,q:Point. ((ab ≅ ap ∧ cd>cp) ∧ cd ≅ cq ∧ ab>aq)) ⇒ (∃z:Point. ((az ≅ ab ∧ cz ≅ cd) ∧ z # ac)))

Lemma: Euclid-Prop1-left
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃c:Point [(((cb ≅ ab ∧ ca ≅ ba) ∧ ca ≅ cb) ∧ c leftof ab)])

Definition: eqtri
Δ(a;b) ==  CCL(a;b;b;a)

Lemma: eqtri_wf
∀[e:EuclideanPlane]. ∀[a:Point]. ∀[b:{b:Point| a # b} ].
  (Δ(a;b) ∈ {c:Point| ((cb ≅ ab ∧ ca ≅ ba) ∧ ca ≅ cb) ∧ c leftof ab} )

Lemma: Euclid-Prop1-left-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃c:Point [(((cb ≅ ab ∧ ca ≅ ba) ∧ ca ≅ cb) ∧ c leftof ab)])

Lemma: not-lsep-iff-colinear
∀g:EuclideanPlane. ∀a,b,c:Point.  (¬a # bc ⇐⇒ Colinear(a;b;c))

Lemma: not-lsep-if-colinear
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ Colinear(a;b;c) ⇒ False)

Lemma: colinear-lsep
∀g:EuclideanPlane. ∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ Colinear(y;a;b) ⇒ y # bc)

Lemma: left-implies-sep
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ {a # b ∧ a # c ∧ b # c})

Lemma: lsep-implies-sep
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ {a # b ∧ a # c ∧ b # c})

Lemma: left-symmetry
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ b leftof ca)

Lemma: geo-left_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (a1 leftof b1c1 ⇐⇒ a2 leftof b2c2))

Lemma: left-all-symmetry
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ {b leftof ca ∧ c leftof ab})

Lemma: geo-lsep_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (a1 # b1c1 ⇐⇒ a2 # b2c2))

Lemma: lsep-symmetry
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ (c # ba ∧ c # ab))

Lemma: lsep-symmetry2
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ a # cb)

Lemma: lsep-all-sym
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ {b # ca ∧ c # ab ∧ a # cb ∧ b # ac ∧ c # ba})

Lemma: lsep-all-sym2
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ {a # bc ∧ b # ca ∧ c # ab ∧ a # cb ∧ b # ac ∧ c # ba})

Lemma: geo-colinear-transitivity
∀e:EuclideanPlane
  ∀[A,C,B,D:Point].  (Colinear(A;B;C) ⇒ Colinear(B;C;D) ⇒ B # C ⇒ {Colinear(A;C;D) ∧ Colinear(A;B;D)})

Lemma: geo-colinear-permute
∀e:EuclideanPlane. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(c;b;a))

Lemma: geo-colinear-cycle
∀e:EuclideanPlane. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(c;a;b))

Lemma: geo-colinear-swap
∀e:EuclideanPlane. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(b;a;c))

Definition: geo-colinear-set
geo-colinear-set(e; L) ==  (∀A∈L.(∀B∈L.(∀C∈L.Colinear(A;B;C))))

Lemma: geo-colinear-set_wf
∀[e:EuclideanPlaneStructure]. ∀[L:Point List].  (geo-colinear-set(e; L) ∈ ℙ)

Lemma: geo-colinear-is-colinear-set
∀e:EuclideanPlane. ∀A,B,C:Point.  (Colinear(A;B;C) ⇒ geo-colinear-set(e; [A; B; C]))

Lemma: geo-between-implies-colinear
∀e:EuclideanPlane. ∀[a,b,c:Point].  Colinear(a;b;c) supposing B(abc)

Lemma: geo-colinear_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (Colinear(a1;b1;c1) ⇐⇒ Colinear(a2;b2;c2)))

Lemma: geo-colinear-append
∀e:EuclideanPlane. ∀L1,L2:Point List.
  ((∃A,B:Point. (A # B ∧ ((A ∈ L1) ∧ (A ∈ L2)) ∧ (B ∈ L1) ∧ (B ∈ L2)))
  ⇒ geo-colinear-set(e; L1)
  ⇒ geo-colinear-set(e; L2)
  ⇒ geo-colinear-set(e; L1 @ L2))

Lemma: geo-between-inner-trans
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  (B(abc)) supposing (B(bcd) and B(abd))

Lemma: geo-sep-irrefl
∀e:EuclideanPlane. ∀[a,b:Point].  ¬a # b supposing a = b ∈ Point

Lemma: geo-sep-irrefl2
∀e:EuclideanPlane. ∀[a,b:Point].  ¬(a = b ∈ Point) supposing a # b

Lemma: geo-sep-irrefl'
∀e:EuclideanPlane. ∀[a:Point]. False supposing a # a

Lemma: left-convex
∀g:EuclideanPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ (B(bxy) ∨ (B(byx) ∧ y # b)) ⇒ y leftof ab)

Lemma: left-not-between
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof cb ⇒ (¬B(abc)))

Lemma: left-not-colinear
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof cb ⇒ (¬Colinear(a;b;c)))

Lemma: not-left-and-right
∀g:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ (¬a leftof cb))

Lemma: left-convex2
∀g:EuclideanPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ (B(axy) ∨ (B(ayx) ∧ y # a)) ⇒ y leftof ab)

Lemma: geo-sep_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ (a1 # b1 ⇐⇒ a2 # b2))

Lemma: geo-gt_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2,d1,d2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ (a1b1 > c1d1 ⇐⇒ a2b2 > c2d2))

Definition: geo-equilateral
EQΔ(a;b;c) ==  ((ab ≅ cb ∧ ac ≅ bc) ∧ ac ≅ ab) ∧ a # bc

Lemma: geo-equilateral_wf
∀[g1:EuclideanPlaneStructure]. ∀[a,b,c:Point].  (EQΔ(a;b;c) ∈ ℙ)

Definition: basic-geometry-
BasicGeometry- ==  EuclideanPlane

Lemma: basic-geometry-_wf
BasicGeometry- ∈ 𝕌'

Lemma: basic-geometry--subtype
BasicGeometry- ⊆r EuclideanPlane

Definition: basic-geometry
BasicGeometry ==  EuclideanPlane

Lemma: basic-geometry_wf
BasicGeometry ∈ 𝕌'

Lemma: basic-geometry-subtype
BasicGeometry ⊆r EuclideanPlane

Lemma: geo-strict-between-sym
∀e:BasicGeometry-. ∀a,b,c:Point.  (a-b-c ⇒ c-b-a)

Lemma: geo-strict-between-trans
∀e:BasicGeometry-. ∀a,b,c,d:Point.  (a-b-d ⇒ b-c-d ⇒ a-b-c)

Lemma: geo-strict-between-trans2
∀e:BasicGeometry-. ∀a,b,c,d:Point.  (d-a-b ⇒ d-b-c ⇒ a-b-c)

Lemma: geo-colinear-implies
∀e:BasicGeometry-. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ (¬((¬B(abc)) ∧ (¬B(bca)) ∧ (¬B(cab)))))

Lemma: geo-colinear-iff
∀e:BasicGeometry-. ∀a,b,c:Point.  (Colinear(a;b;c) ⇐⇒ ¬((¬B(abc)) ∧ (¬B(bca)) ∧ (¬B(cab))))

Lemma: geo-colinear-symmetry
∀[e:BasicGeometry]. ∀[a,b,c:Point].
  {Colinear(b;c;a) ∧ Colinear(c;a;b) ∧ Colinear(c;b;a) ∧ Colinear(a;c;b) ∧ Colinear(b;a;c)} supposing Colinear(a;b;c)

Lemma: geo-eq-preserves-col
∀g:EuclideanPlane. ∀a,b,x,y:Point.  (a ≡ b ⇒ Colinear(a;x;y) ⇒ Colinear(b;x;y))

Lemma: geo-strict-between-sep1
∀e:BasicGeometry-. ∀a,b,c:Point.  (a-b-c ⇒ a # c)

Lemma: geo-strict-between-sep2
∀e:GeometryPrimitives. ∀a,b,c:Point.  (a-b-c ⇒ a # b)

Lemma: geo-strict-between-sep3
∀e:GeometryPrimitives. ∀a,b,c:Point.  (a-b-c ⇒ b # c)

Lemma: geo-strict-between-same
∀[e:BasicGeometry-]. ∀[a,b:Point].  (¬a-b-a)

Lemma: geo-strict-between-same2
∀[e:BasicGeometry-]. ∀[a,b:Point].  False supposing a-b-a

Lemma: not-geo-strict-between-same
∀e:BasicGeometry-. ∀[a,b:Point].  False supposing a-b-b

Lemma: not-geo-strict-between-same2
∀e:BasicGeometry. ∀[a,b:Point].  False supposing a-a-b

Lemma: geo-eq_transitivity
∀[e:BasicGeometry-]. ∀[a,b,c:Point].  (a ≡ c) supposing (b ≡ c and a ≡ b)

Lemma: geo-congruent-implies-ge
∀[g:BasicGeometry-]. ∀[c,d,a,b:Point].  cd ≥ ab supposing cd ≅ ab

Lemma: geo-strict-between_functionality
∀e:BasicGeometry. ∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (a1-b1-c1 ⇐⇒ a2-b2-c2))

Lemma: geo-congruence-identity2
∀[e:BasicGeometry]. ∀[a,b,c,d:Point].  (a ≡ b) supposing (ab ≅ cd and c ≡ d)

Lemma: geo-congruence-identity3
∀[e:BasicGeometry]. ∀[a,b,c,d:Point].  (a ≡ b) supposing (cd ≅ ab and c ≡ d)

Lemma: geo-congruence-identity-eq
∀e:BasicGeometry. ∀a,b,c:Point.  ∀[d:Point]. (c ≡ d ⇒ ab ≅ cd ⇒ a ≡ b)

Lemma: geo-colinear-same
∀[e:BasicGeometry]. ∀[a,b:Point].  (Colinear(a;b;b) ∧ Colinear(b;a;b) ∧ Colinear(b;b;a))

Lemma: geo-not-colinear
∀e:BasicGeometry. ∀[a,b,c:Point].  (¬Colinear(a;b;c) ⇐⇒ ¬(B(abc) ∨ B(bca) ∨ B(cab)))

Lemma: geo-not-not-colinear
∀e:BasicGeometry. ∀[a,b,c:Point].  (¬¬Colinear(a;b;c) ⇐⇒ ¬¬(B(abc) ∨ B(bca) ∨ B(cab)))

Lemma: geo-strict-between-implies-colinear
∀e:BasicGeometry. ∀[a,b,c:Point].  Colinear(a;b;c) supposing a-b-c

Lemma: geo-between-implies-colinear2
∀e:BasicGeometry. ∀[a,b,c:Point].  Colinear(a;b;c) supposing B(cab)

Lemma: geo-between-implies-sep
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ B(abc) ⇒ a # c)

Lemma: geo-strict-between-implies-between
∀e:BasicGeometry-. ∀[a,b,c:Point].  B(abc) supposing a-b-c

Lemma: geo-between-implies-colinear3
∀e:BasicGeometry. ∀[a,b,c:Point].  Colinear(a;b;c) supposing B(bca)

Lemma: geo-between-same2
∀[e:BasicGeometry]. ∀[a,b,c:Point].  (a ≡ b) supposing (a ≡ c and B(abc))

Lemma: geo-cong-implies-ge
∀e:BasicGeometry. ∀a,b,c,d:Point.  (ab ≅ cd ⇒ cd ≥ ab)

Lemma: geo-ge-trivial
∀[g:BasicGeometry]. ∀[a,b:Point].  ab ≥ ab

Lemma: geo-simple-colinear-cases
∀[e:BasicGeometry-]. ∀[a,b,c:Point].
  ∀X:ℙ. (Stable{X} ⇒ Colinear(a;b;c) ⇒ (B(abc) ⇒ X) ⇒ (B(bca) ⇒ X) ⇒ (B(cab) ⇒ X) ⇒ X)

Lemma: geo-colinear-cases
∀e:BasicGeometry-
  ∀[a,b,c:Point].
    ∀X:ℙ
      (Stable{X}
      ⇒ (a ≡ b ⇒ X)
      ⇒ (b ≡ c ⇒ X)
      ⇒ (c ≡ a ⇒ X)
      ⇒ (a-b-c ⇒ X)
      ⇒ (b-c-a ⇒ X)
      ⇒ (c-a-b ⇒ X)
      ⇒ ((¬Colinear(a;b;c)) ⇒ X)
      ⇒ X)

Lemma: geo-between-exchange3
∀e:BasicGeometry-. ∀[a,b,c,d:Point].  (B(bcd)) supposing (B(acd) and B(abc))

Lemma: geo-sep-between-eq
∀e:BasicGeometry. ∀a,b,c:Point.  (B(abc) ⇒ a # b ⇒ a # c)

Lemma: geo-colinear-implies-1
∀e:BasicGeometry. ∀x,a,b:Point.  (Colinear(b;a;x) ⇒ Colinear(b;a;a))

Definition: geo-segment
geo-segment(e) ==  Point × Point

Lemma: geo-segment_wf
∀[e:EuclideanPlaneStructure]. (geo-segment(e) ∈ Type)

Definition: geo-mk-seg
ab ==  <a, b>

Lemma: geo-mk-seg_wf
∀[e:EuclideanPlaneStructure]. ∀[a,b:Point].  (ab ∈ geo-segment(e))

Definition: geo-seg1
geo-seg1(s) ==  fst(s)

Lemma: geo-seg1_wf
∀[e:EuclideanPlaneStructure]. ∀[s:geo-segment(e)].  (geo-seg1(s) ∈ Point)

Definition: geo-seg2
geo-seg2(s) ==  snd(s)

Lemma: geo-seg2_wf
∀[e:EuclideanPlaneStructure]. ∀[s:geo-segment(e)].  (geo-seg2(s) ∈ Point)

Lemma: geo_seg2_mk_seg_lemma
∀b,a:Top.  (geo-seg2(ab) ~ b)

Definition: geo-seg-proper
geo-seg-proper(e; s) ==  geo-seg1(s) # geo-seg2(s)

Lemma: geo-seg-proper_wf
∀[e:EuclideanPlaneStructure]. ∀[s:geo-segment(e)].  (geo-seg-proper(e; s) ∈ ℙ)

Definition: geo-proper-segment
geo-proper-segment(e) ==  s:geo-segment(e) × geo-seg-proper(e; s)

Lemma: geo-proper-segment_wf
∀[e:EuclideanPlaneStructure]. (geo-proper-segment(e) ∈ Type)

Lemma: geo_seg1_mk_seg_lemma
∀b,a:Top.  (geo-seg1(ab) ~ a)

Definition: geo-seg-of
geo-seg-of(sp) ==  fst(sp)

Lemma: geo-seg-of_wf
∀[e:BasicGeometry]. ∀[sp:geo-proper-segment(e)].  (geo-seg-of(sp) ∈ geo-segment(e))

Definition: geo-seg-congruent
geo-seg-congruent(e; s1; s2) ==  geo-seg1(s1)geo-seg2(s1) ≅ geo-seg1(s2)geo-seg2(s2)

Lemma: geo-seg-congruent_wf
∀[e:EuclideanPlaneStructure]. ∀[s1,s2:geo-segment(e)].  (geo-seg-congruent(e; s1; s2) ∈ ℙ)

Lemma: sq_stable_geo-seg-congruent
∀e:EuclideanPlaneStructure. ∀[s1,s2:geo-segment(e)].  SqStable(geo-seg-congruent(e; s1; s2))

Lemma: geo-seg-congruent_transitivity
∀e:BasicGeometry
  ∀[s1,s2,s3:geo-segment(e)].
    (geo-seg-congruent(e; s1; s3)) supposing (geo-seg-congruent(e; s1; s2) and geo-seg-congruent(e; s2; s3))

Lemma: geo-seg-congruent_symmetry
∀e:BasicGeometry. ∀[s1,s2:geo-segment(e)].  geo-seg-congruent(e; s2; s1) supposing geo-seg-congruent(e; s1; s2)

Lemma: geo-seg-congruent_inversion
∀e:BasicGeometry. ∀[s1,s2:geo-segment(e)].  geo-seg-congruent(e; s2; s1) supposing geo-seg-congruent(e; s1; s2)

Lemma: geo-seg-congruent-equiv
∀e:BasicGeometry. EquivRel(geo-segment(e);s,t.geo-seg-congruent(e; s; t))

Lemma: geo-congruent-flip-seg
∀e:BasicGeometry. ∀[a,b:Point].  geo-seg-congruent(e; ab; ba)

Lemma: geo-length-equiv
∀e:BasicGeometry. EquivRel({p:Point| B(OXp)} ;x,y.x ≡ y)

Definition: geo-length-type
Length ==  x,y:{p:Point| B(OXp)} //x ≡ y

Lemma: geo-length-type_wf
∀[e:BasicGeometry]. (Length ∈ Type)

Lemma: subtype-geo-length-type
∀[e:BasicGeometry]. ({p:Point| B(OXp)}  ⊆r Length)

Definition: geo-zero-length
0 ==  X

Lemma: geo-zero-length_wf
∀[e:BasicGeometry]. (0 ∈ Length)

Lemma: geo-seg-congruent_weakening
∀e:BasicGeometry. ∀[s1,s2:geo-segment(e)].  geo-seg-congruent(e; s1; s2) supposing s1 = s2 ∈ geo-segment(e)

Lemma: geo-seg-congruent_functionality
∀e:BasicGeometry. ∀s1,s2,t1,t2:geo-segment(e).
  (geo-seg-congruent(e; s1; t1)
  ⇒ geo-seg-congruent(e; s2; t2)
  ⇒ (geo-seg-congruent(e; s1; s2) ⇐⇒ geo-seg-congruent(e; t1; t2)))

Lemma: geo-seg-congruent-trivial
∀e:BasicGeometry. ∀[s:geo-segment(e)]. geo-seg-congruent(e; s; s)

Lemma: geo-midpoint_functionality
∀e:BasicGeometry. ∀m,a,b,m',a',b':Point.  (m ≡ m' ⇒ a ≡ a' ⇒ b ≡ b' ⇒ {a=m=b ⇒ a'=m'=b'})

Lemma: geo-midpoint-id2
∀e:BasicGeometry. ∀a,b:Point.  (a=b=a ⇒ a ≡ b)

Lemma: geo-midpoint-id
∀e:BasicGeometry. ∀a,b:Point.  (a=a=b ⇒ a ≡ b)

Lemma: geo-midpoint-id3
∀e:BasicGeometry. ∀a,b:Point.  (b=a=a ⇒ a ≡ b)

Lemma: stable__geo-midpoint
∀e:BasicGeometry. ∀[m,a,b:Point].  Stable{a=m=b}

Lemma: geo-midpoint-trivial
∀e:BasicGeometry. ∀a:Point.  a=a=a

Lemma: geo-midpoint-symmetry
∀e:BasicGeometry. ∀m,a,b:Point.  (a=m=b ⇒ b=m=a)

Lemma: extend-using-SC
∀e:EuclideanPlane. ∀q,a,b:Point.  (q # a ⇒ (∃x:Point. (B(qax) ∧ ax ≅ ab)))

Lemma: geo-inner-five-segment
∀e:EuclideanPlane
  ∀[a,b,c,d,A,B,C,D:Point].  (bd ≅ BD) supposing (cd ≅ CD and ad ≅ AD and bc ≅ BC and ac ≅ AC and B(ABC) and B(abc))

Lemma: geo-inner-five-segment'
∀e:EuclideanPlane
  ∀[a,b,c,A,B,C:Point].
    (∀d,D:Point.  (bd ≅ BD) supposing (cd ≅ CD and ad ≅ AD)) supposing (bc ≅ BC and ac ≅ AC and B(ABC) and B(abc))

Lemma: geo-inner-three-segment
∀e:EuclideanPlane. ∀[a,b,c,A,B,C:Point].  (ab ≅ AB) supposing (bc ≅ BC and ac ≅ AC and B(ABC) and B(abc))

Lemma: symmetric-point-construction1
∀e:BasicGeometry. ∀a:Point. ∀p:{p:Point| a # p} .  (∃p':Point [p=a=p'])

Lemma: symmetric-point-construction
∀e:BasicGeometry. ∀a,p:Point.  (a # p ⇒ (∃p':Point. p=a=p'))

Lemma: left-right-colinear-cases
∀e:EuclideanPlane. ∀u,v,b,c:Point.
  (∀a:Point. (a # b ⇒ Colinear(a;b;u) ⇒ Colinear(a;b;v) ⇒ (B(abu) ∨ B(abv)))) supposing (v leftof cb and u leftof bc)

Lemma: euclidean-plane-subtype-basic
EuclideanPlane ⊆r BasicGeometry

Definition: oriented-plane
OrientedPlane ==  EuclideanPlane

Lemma: oriented-plane_wf
OrientedPlane ∈ 𝕌'

Lemma: oriented-plane-subtype
OrientedPlane ⊆r EuclideanPlane

Lemma: op-geo-left-axioms
∀g:OrientedPlane. geo-left-axioms(g)

Lemma: oriented-colinear-trans
∀e:OrientedPlane
  ∀[A,C,B,D:Point].  (Colinear(A;B;C) ⇒ Colinear(B;C;D) ⇒ B # C ⇒ {Colinear(A;C;D) ∧ Colinear(A;B;D)})

Lemma: oriented-colinear-append
∀e:OrientedPlane. ∀L1,L2:Point List.
  ((∃A,B:Point. (A # B ∧ ((A ∈ L1) ∧ (A ∈ L2)) ∧ (B ∈ L1) ∧ (B ∈ L2)))
  ⇒ geo-colinear-set(e; L1)
  ⇒ geo-colinear-set(e; L2)
  ⇒ geo-colinear-set(e; L1 @ L2))

Lemma: not-left-collinear
∀g:OrientedPlane. ∀a,b,c:Point.  ((¬a leftof bc) ⇒ (¬a leftof cb) ⇒ (¬((¬B(abc)) ∧ (¬B(bca)) ∧ (¬B(cab)))))

Lemma: lsep-not-between
∀g:OrientedPlane. ∀a,b,c:Point.  (a # bc ⇒ (¬B(abc)))

Lemma: left-between-weak
∀g:OrientedPlane. ∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ (¬z leftof ba))

Lemma: left-between
∀g:OrientedPlane. ∀a,b,x,y,z:Point.  (x leftof ab ⇒ y leftof ab ⇒ B(xzy) ⇒ z leftof ab)

Lemma: colinear-lsep'
∀g:OrientedPlane. ∀a,b,c,y:Point.  (y # ab ⇒ b # c ⇒ Colinear(a;b;c) ⇒ y # cb)

Lemma: colinear-lsep-general
∀g:OrientedPlane. ∀a,b,c,d:Point.  (Colinear(a;b;c) ⇒ Colinear(a;b;d) ⇒ c # d ⇒ (∀y:Point. (y # ab ⇒ y # cd)))

Lemma: colinear-lsep-alt
∀g:OrientedPlane. ∀a,b,c,x,z:Point.  (a # bc ⇒ x # b ⇒ Colinear(a;b;x) ⇒ z # c ⇒ Colinear(x;c;z) ⇒ z # bc)

Lemma: colinear-lsep-cycle
∀g:EuclideanPlane. ∀a,b,c,y:Point.  (a # bc ⇒ y # b ⇒ Colinear(a;b;y) ⇒ y # bc)

Lemma: colinear-lsep2
∀g:OrientedPlane. ∀a,b,c,x,y:Point.  (a # bc ⇒ x # b ⇒ Colinear(a;b;x) ⇒ y # c ⇒ Colinear(b;c;y) ⇒ x # yc)

Lemma: lsep-iff
∀g:OrientedPlane. ∀a,b,c:Point.  (a # bc ⇐⇒ (∀y:Point. (y # b ⇒ Colinear(y;b;c) ⇒ a # by)) ∧ c # b)

Lemma: lsep-colinear-sep
∀g:OrientedPlane. ∀a,b,c:Point.  (a # bc ⇒ (∀y:Point. (Colinear(y;b;c) ⇒ a # y)))

Lemma: lsep-colinear-sep1
∀g:OrientedPlane. ∀a,b,c:Point. ∀y:{y:Point| Colinear(y;b;c)} .  (a # bc ⇒ a # y)

Lemma: left-right-sep
∀g:OrientedPlane. ∀a,b,c,d:Point.  (a leftof cd ⇒ b leftof dc ⇒ a # b)

Lemma: lsep-opposite-iff
∀g:OrientedPlane. ∀a,b,x,y:Point.
  (x # ab ⇒ y # ab ⇒ (∃z:Point. (B(xzy) ∧ Colinear(z;a;b)) ⇐⇒ x leftof ab ⇐⇒ y leftof ba))

Lemma: strict-between-left-right
∀e:EuclideanPlane. ∀x,y,p,a,q:Point.  (p leftof yx ⇒ Colinear(a;x;y) ⇒ p-a-q ⇒ q leftof xy)

Lemma: lsep-same-side-iff
∀g:OrientedPlane. ∀a,b,x,y:Point.
  (x # ab ⇒ y # ab ⇒ (∀z:Point. (B(xzy) ⇒ (¬Colinear(z;a;b))) ⇐⇒ x leftof ab ⇐⇒ y leftof ab))

Lemma: left-between-implies-right1
∀g:OrientedPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ B(xby) ⇒ y # b ⇒ y leftof ba)

Lemma: left-between-implies-right2
∀g:OrientedPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ B(xay) ⇒ y # a ⇒ y leftof ba)

Lemma: left-convex3
∀e:OrientedPlane. ∀b,p,q,x,z:Point.  (q leftof pb ⇒ Colinear(p;b;z) ⇒ B(zqx) ⇒ x leftof pb)

Lemma: left-opposite-between
∀e:OrientedPlane. ∀a,b,p,q,x:Point.  (B(aqx) ⇒ a leftof bp ⇒ q leftof pb ⇒ x leftof pb)

Lemma: lsep-inner-pasch
∀e:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p:{p:Point| a-p-c} . ∀q:{q:Point| b-q-c} .
  (∃x:Point [(B(bxp) ∧ B(axq))])

Lemma: lsep-inner-pasch-ext
∀e:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p:{p:Point| a-p-c} . ∀q:{q:Point| b-q-c} .
  (∃x:Point [(B(bxp) ∧ B(axq))])

Lemma: lsep-inner-pasch-strict
∀e:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p:{p:Point| a-p-c} . ∀q:{q:Point| b-q-c} .
  (∃x:Point [(b-x-p ∧ a-x-q)])

Lemma: lsep-inner-pasch-strict-ext
∀e:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p:{p:Point| a-p-c} . ∀q:{q:Point| b-q-c} .
  (∃x:Point [(b-x-p ∧ a-x-q)])

Lemma: not-not-inner-pasch
∀g:OrientedPlane. ∀a,b,c:Point. ∀p:{p:Point| B(apc)} . ∀q:{q:Point| B(bqc)} .  (¬¬(∃x:Point. (B(pxb) ∧ B(qxa))))

Definition: half-plane-cong-angle
abc ≅ρ dbc ==  (a leftof bc ∧ d leftof bc) ∧ Colinear(a;d;b)

Lemma: half-plane-cong-angle_wf
∀g:EuclideanPlane. ∀[d,a,b,c:Point].  (abc ≅ρ dbc ∈ ℙ)

Definition: half-plane-lt-angle
half-plane-lt-angle(e;d;a;b;c) ==  (a leftof bc ∧ d leftof bc) ∧ d leftof ba

Lemma: half-plane-lt-angle_wf
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (half-plane-lt-angle(e;d;a;b;c) ∈ ℙ)

Lemma: hp-cong-angle-reflexive
∀e:EuclideanPlane. ∀a,b,c:Point.  (a leftof bc ⇒ abc ≅ρ abc)

Lemma: hp-cong-angle-trans
∀e:EuclideanPlane. ∀a,b,c,d,f:Point.  ((abc ≅ρ dbc ∧ dbc ≅ρ fbc) ⇒ abc ≅ρ fbc)

Lemma: hp-angles-not-lt-and-cong
∀e:EuclideanPlane. ∀a,b,c,d:Point.  ((abc ≅ρ dbc ∧ half-plane-lt-angle(e;d;a;b;c)) ⇒ False)

Lemma: euclidean-plane-subtype-oriented
EuclideanPlane ⊆r OrientedPlane

Lemma: geo-colinear-implies-between-or
∀e:EuclideanPlane. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ (¬¬((B(acb) ∨ B(bac)) ∨ B(abc))))

Definition: geo-SCS
SCS(a;b;c;d) ==  SC(SymmetricPoint(SC(a;b;c;d);a);b;c;d)

Lemma: geo-SCS_wf
∀[g:EuclideanPlane]
  ∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .
    (SCS(a;b;c;d) ∈ {v:Point| cv ≅ cd ∧ (B(vbSCO(a;b;c;d)) ∧ Colinear(a;b;v)) ∧ (b # d ⇒ v # SCO(a;b;c;d))} )

Lemma: geo-SCS-congruent
∀g:EuclideanPlane. ∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  cSCS(a;b;c;d) ≅ cd

Lemma: use-SC
∀e:EuclideanPlane. ∀a,b,c,d:Point.
  (a # b ⇒ B(cbd) ⇒ (∃u,v:Point. (cu ≅ cd ∧ cv ≅ cd ∧ B(abu) ∧ (B(vbu) ∧ Colinear(a;b;v)) ∧ (b # d ⇒ v # u))))

Lemma: geo-three-segment
∀e:EuclideanPlane. ∀[a,b,c,A,B,C:Point].  (ac ≅ AC) supposing (bc ≅ BC and ab ≅ AB and B(ABC) and B(abc))

Lemma: geo-construction-unicity2
∀e:EuclideanPlane. ∀[Q,A,X,Y:Point].  (X ≡ Y) supposing (AY ≅ AX and B(QAX) and B(QAY) and Q # A)

Lemma: geo-between-outer-trans-cpy
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  (B(acd)) supposing (B(bcd) and B(abc) and b # c)

Lemma: geo-between-outer-trans2-cpy
∀e:EuclideanPlane. ∀[a,b,c,d:Point].  (B(abd)) supposing (B(bcd) and B(abc) and b # c)

Lemma: Euclid-Prop1
∀e:EuclideanPlane. ∀a,b:Point.  (a # b ⇒ (∃c:Point. EQΔ(c;b;a)))

Lemma: Euclid-Prop2-lemma
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀v:Point.  (∃x:Point [ax ≅ bv])

Definition: prop2-lemma
lemma2(a;b;c) ==  let x = Δ(a;b) in let u = SCO(x;b;b;c) in SCS(a;x;x;u)

Lemma: Euclid-Prop2-lemma-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀v:Point.  (∃x:Point [ax ≅ bv])

Lemma: Euclid-Prop2
∀e:EuclideanPlane. ∀a,b,c:Point.  (∃x:Point [ax ≅ bc])

Lemma: Euclid-Prop2-ext
∀e:EuclideanPlane. ∀a,b,c:Point.  (∃x:Point [ax ≅ bc])

Lemma: geo-extend-construction
∀e:EuclideanPlane. ∀q:Point. ∀a:{a:Point| q # a} . ∀b,c:Point.  (∃x:Point [(B(qax) ∧ ax ≅ bc)])

Lemma: geo-extend-construction-ext
∀e:EuclideanPlane. ∀q:Point. ∀a:{a:Point| q # a} . ∀b,c:Point.  (∃x:Point [(B(qax) ∧ ax ≅ bc)])

Definition: geo-extend
extend qa by bc ==
  SCO(q;a;a;if M(O;X;a) then if M(a;O;b) then lemma2(a;b;c) else lemma2(a;O;lemma2(O;b;c)) fi 
  if M(a;X;b) then lemma2(a;b;c)
  else lemma2(a;X;lemma2(X;b;c))
  fi )

Lemma: geo-extend_wf
∀e:EuclideanPlane. ∀q:Point. ∀a:{a:Point| q # a} . ∀b,c:Point.  (extend qa by bc ∈ {x:Point| B(qax) ∧ ax ≅ bc} )

Lemma: geo-extend-exists
∀e:EuclideanPlane. ∀q,a,b,c:Point.  (q # a ⇒ (∃x:Point. (B(qax) ∧ ax ≅ bc)))

Lemma: geo-extend-property1
∀e:BasicGeometry. ∀a:Point. ∀b:{b:Point| a # b} . ∀c,d:Point.  (bextend ab by cd ≅ cd ∧ (c # d ⇒ a-b-extend ab by cd))

Lemma: geo-extend-property
∀e:BasicGeometry. ∀a:Point. ∀b:{b:Point| a # b} . ∀c,d:Point.  (bextend ab by cd ≅ cd ∧ B(abextend ab by cd))

Lemma: geo-extend-exists1
∀e:BasicGeometry. ∀q,a,b,c:Point.  (q # a ⇒ (∃x:Point. ((b # c ⇒ q-a-x) ∧ ax ≅ bc)))

Lemma: geo-proper-extend-exists
∀e:BasicGeometry. ∀q,a,b,c:Point.  (q # a ⇒ b # c ⇒ (∃x:Point. (q-a-x ∧ ax ≅ bc)))

Lemma: geo-congruent-trivial
∀e:EuclideanPlane. ∀[a,b:Point].  aa ≅ bb

Lemma: geo-construction-unicity
∀e:BasicGeometry-. ∀[Q,A,X,Y:Point].  (X ≡ Y) supposing (AY ≅ AX and B(QAX) and B(QAY) and Q # A)

Lemma: geo-construction-unicity-from-first
∀e:BasicGeometry-. ∀[Q,A,X,Y:Point].  (X ≡ Y) supposing (QY ≅ QX and B(QAX) and B(QAY) and Q # A)

Lemma: geo-extend-equal-iff-congruent
∀e:BasicGeometry. ∀[a,b,c,d,c',d':Point].  uiff(extend ab by cd ≡ extend ab by c'd';cd ≅ c'd') supposing a # b

Lemma: geo-extend_functionality
∀[e:BasicGeometry]. ∀[a:Point]. ∀[b:{b:Point| a # b} ]. ∀[c,d,a':Point]. ∀[b':{b':Point| a' # b'} ]. ∀[c',d':Point].
  (extend ab by cd ≡ extend a'b' by c'd') supposing (a ≡ a' and b ≡ b' and c ≡ c' and d ≡ d')

Lemma: geo-between-outer-trans
∀e:BasicGeometry-. ∀[a,b,c,d:Point].  (B(acd)) supposing (B(bcd) and B(abc) and b # c)

Lemma: geo-between-outer-trans2
∀e:BasicGeometry-. ∀[a,b,c,d:Point].  (B(abd)) supposing (B(bcd) and B(abc) and b # c)

Lemma: geo-strict-between-trans3
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a-b-c ⇒ b-c-d ⇒ a-c-d)

Lemma: geo-between-exchange4
∀e:BasicGeometry-. ∀[a,b,c,d:Point].  (B(abd)) supposing (B(acd) and B(abc))

Definition: geo-length
|s| ==  extend OX by geo-seg1(s)geo-seg2(s)

Lemma: geo-length_wf1
∀[e:BasicGeometry]. ∀[s:geo-segment(e)].  (|s| ∈ {p:Point| B(OXp)} )

Lemma: geo-length_wf
∀[e:BasicGeometry]. ∀[s:geo-segment(e)].  (|s| ∈ Length)

Lemma: length-seg-eq
∀[e:BasicGeometry]. ∀[a,b:Point].  |ab| ≡ |ab|

Definition: geo-add-length
p + q ==  extend Op by Xq

Lemma: geo-add-length_wf1
∀[e:BasicGeometry]. ∀[x,y:{p:Point| B(OXp)} ].  (x + y ∈ {p:Point| B(OXp)} )

Lemma: geo-add-length_functionality
∀[e:BasicGeometry]. ∀[x,y,x',y':{p:Point| B(OXp)} ].  (x + y ≡ x' + y') supposing (x ≡ x' and y ≡ y')

Lemma: geo-add-length_wf
∀[e:BasicGeometry]. ∀[x,y:Length].  (x + y ∈ Length)

Definition: geo-le
p ≤ q ==  ↓∃p',q':{p:Point| B(OXp)} . ((p' = p ∈ Length) ∧ (q' = q ∈ Length) ∧ B(Xp'q'))

Lemma: geo-le_wf
∀[e:BasicGeometry]. ∀[p,q:Length].  (p ≤ q ∈ ℙ)

Lemma: geo-le_witness
∀[e:BasicGeometry]. ∀[p,q:{p:Point| B(OXp)} ].  Ax ∈ p ≤ q supposing B(Xpq)

Lemma: sq_stable__geo-le
∀[e:BasicGeometry]. ∀[p,q:Length].  SqStable(p ≤ q)

Definition: geo_ge
geo_ge(e; p; q) ==  q ≤ p

Lemma: geo_ge_wf
∀[e:BasicGeometry]. ∀[p,q:Length].  (geo_ge(e; p; q) ∈ ℙ)

Lemma: geo-le_weakening
∀[e:BasicGeometry]. ∀[p,q:Length].  p ≤ q supposing p = q ∈ Length

Lemma: geo-le-same
∀[e:BasicGeometry]. ∀[p:Length].  p ≤ p

Lemma: geo-le_imp
∀e:BasicGeometry. ∀p,q:{p:Point| B(OXp)} .  B(Xpq) supposing p ≤ q

Lemma: geo-le_transitivity
∀e:BasicGeometry. ∀[p,q,r:Length].  (p ≤ r) supposing (q ≤ r and p ≤ q)

Lemma: geo-le_functionality_wrt_implies
∀[e:BasicGeometry]. ∀[a,b,c,d:Length].  ({a ≤ d supposing b ≤ c}) supposing (c ≤ d and geo_ge(e; b; a))

Lemma: geo-le-add1
∀e:BasicGeometry. ∀[p,q:Length].  p ≤ p + q

Lemma: geo-seg-congruent-iff-length
∀e:BasicGeometry. ∀[s,t:geo-segment(e)].  uiff(geo-seg-congruent(e; s; t);|s| ≡ |t|)

Lemma: geo-congruent-iff-length
∀e:BasicGeometry. ∀[a,b,c,d:Point].  uiff(ab ≅ cd;|ab| = |cd| ∈ Length)

Lemma: geo-length-equality
∀e:BasicGeometry. ∀p':{p:Point| B(OXp)} .  (|Xp'| = p' ∈ Length)

Lemma: geo-length_functionality
∀e:BasicGeometry. ∀[a,b,c,d:Point].  (|ab| = |cd| ∈ Length) supposing (b ≡ d and a ≡ c)

Lemma: geo-length-flip-eq
∀e:BasicGeometry. ∀[a,b:Point].  |ab| ≡ |ba|

Lemma: geo-length-flip
∀e:BasicGeometry. ∀[a,b:Point].  (|ab| = |ba| ∈ Length)

Lemma: geo-zero-length-iff
∀e:BasicGeometry. ∀a,b:Point.  (|ab| = 0 ∈ Length ⇐⇒ a ≡ b)

Lemma: trivial-zero-length
∀[e:BasicGeometry]. ∀[a:Point].  (|aa| = 0 ∈ Length)

Lemma: trivial-lengths-equal
∀[e:BasicGeometry]. ∀[a,b:Point].  (|aa| = |bb| ∈ Length)

Lemma: geo-ge-trivial2
∀[g:BasicGeometry]. ∀[a,b,c:Point].  ab ≥ cc

Lemma: geo-add-length-comm
∀[e:BasicGeometry]. ∀[x,y:Length].  (x + y = y + x ∈ Length)

Lemma: geo-add-length-zero
∀[e:BasicGeometry]. ∀[x:Length].  (x + X = x ∈ Length)

Lemma: geo-length-null-segment
∀[e:BasicGeometry]. ∀[a:Point].  (|aa| = X ∈ Length)

Lemma: geo-le-null-segment
∀e:BasicGeometry. ∀[p:Length]. ∀[a:Point].  uiff(p ≤ |aa|;p = |aa| ∈ Length)

Lemma: geo-le-zero
∀e:BasicGeometry. ∀[p:Length]. uiff(p ≤ 0;p = 0 ∈ Length)

Lemma: geo-zero-le
∀e:BasicGeometry. ∀[p:Length]. 0 ≤ p

Lemma: geo-add-length-zero2
∀[e:BasicGeometry]. ∀[x:Length]. ∀[a:Point].  (x + |aa| = x ∈ Length)

Lemma: geo-add-length-zero3
∀[e:BasicGeometry]. ∀[x:Length]. ∀[a:Point].  (|aa| + x = x ∈ Length)

Lemma: geo-add-length-between
∀[e:BasicGeometry]. ∀[a,b,c:Point].  |ac| = |ab| + |bc| ∈ Length supposing B(abc)

Lemma: geo-add-length-assoc
∀[e:BasicGeometry]. ∀[x,y,z:Length].  (x + y + z = x + y + z ∈ Length)

Lemma: geo-add-length-cancel-left
∀[e:BasicGeometry]. ∀[x,y,z:Length].  x = y ∈ Length supposing z + x = z + y ∈ Length

Lemma: geo-add-length-cancel-right
∀[e:BasicGeometry]. ∀[x,y,z:Length].  x = y ∈ Length supposing x + z = y + z ∈ Length

Lemma: geo-add-length-implies-eq-zero
∀[e:BasicGeometry]. ∀[x,y:Length].  y = 0 ∈ Length supposing x = x + y ∈ Length

Lemma: geo-add-length-implies-eq
∀[e:BasicGeometry]. ∀[x:Length]. ∀[a,b:Point].  a ≡ b supposing x = x + |ab| ∈ Length

Lemma: geo-add-length-is-zero
∀e:BasicGeometry. ∀x,y:Length.  (x + y = 0 ∈ Length ⇐⇒ (x = 0 ∈ Length) ∧ (y = 0 ∈ Length))

Lemma: geo-add-length-implies-eq2
∀[e:BasicGeometry]. ∀[x:Length]. ∀[a,b:Point].  a ≡ b supposing x = x + |ab| + |ab| ∈ Length

Lemma: geo-congruent-between-implies-equal
∀e:BasicGeometry. ∀[a,b,c,x:Point].  (b ≡ x) supposing (B(abc) and ab ≅ ax and bc ≅ xc)

Lemma: geo-gt-irrefl
∀e:EuclideanPlane. ∀a,b:Point.  (¬ab > ab)

Lemma: geo-between-congruent
∀e:BasicGeometry. ∀a,b,c:Point.  (B(abc) ⇒ ac ≅ ab ⇒ c ≡ b)

Lemma: geo-congruent-between-exists
∀e:BasicGeometry. ∀a,b,c,a',c':Point.
  (a # b ⇒ (∃b':Point. (B(a'b'c') ∧ ab ≅ a'b' ∧ bc ≅ b'c')) supposing (B(abc) and ac ≅ a'c'))

Lemma: geo-congruent-between-exists2
∀e:BasicGeometry. ∀a,b,c,a',c':Point.
  (a # c ⇒ (∃b':Point. (B(a'b'c') ∧ ab ≅ a'b' ∧ bc ≅ b'c')) supposing (B(abc) and ac ≅ a'c'))

Lemma: geo-congruent-preserves-gt
∀e:BasicGeometry. ∀a,b,c,d,a',b',c',d':Point.  (ab > cd ⇒ ab ≅ a'b' ⇒ cd ≅ c'd' ⇒ a'b' > c'd')

Lemma: geo-congruent-strictbetween-exists
∀e:BasicGeometry. ∀a,b,c,a',c':Point.  (a-b-c ⇒ ac ≅ a'c' ⇒ (∃b':Point. ((a'-b'-c' ∧ ab ≅ a'b') ∧ bc ≅ b'c')))

Lemma: geo-congruent-preserves-between
∀e:BasicGeometry. ∀[a,b,c,a',b',c':Point].  (B(a'b'c')) supposing (bc ≅ b'c' and ac ≅ a'c' and ab ≅ a'b' and B(abc))

Lemma: geo-gt-trans
∀e:EuclideanPlane. ∀a,b,c,d,x,y:Point.  (ab > cd ⇒ cd > xy ⇒ ab > xy)

Lemma: geo-gt-implies-point
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ c # d ⇒ (¬¬(∃f:Point. (c-d-f ∧ cf ≅ ab))))

Lemma: geo-gt-implies-point2
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ c # d ⇒ (∃f:Point. (B(cdf) ∧ cf ≅ ab)))

Lemma: geo-congruent-preserves-strict-between
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (a-b-c ⇒ ab ≅ a'b' ⇒ ac ≅ a'c' ⇒ bc ≅ b'c' ⇒ a'-b'-c')

Lemma: geo-congruent-preserves-colinear
∀e:BasicGeometry
  ∀[a,b,c,a',b',c':Point].  (Colinear(a';b';c')) supposing (bc ≅ b'c' and ac ≅ a'c' and ab ≅ a'b' and Colinear(a;b;c))

Lemma: congruence-preserves-between_symmetric-points
∀e:BasicGeometry. ∀a,b,c,b',c':Point.
  (B(abc) ⇒ Colinear(a;c;c') ⇒ ab ≅ ab' ⇒ ac ≅ ac' ⇒ b'-a-b ⇒ c # c' ⇒ B(ab'c'))

Lemma: congruence-preserves-between_symmetric-points2
∀e:BasicGeometry. ∀a,b,c,b',c':Point.
  (B(abc) ⇒ Colinear(a;c;c') ⇒ ab ≅ ab' ⇒ ac ≅ ac' ⇒ b'-a-b ⇒ (B(ab'c') ∨ B(abc')))

Lemma: geo-colinear-five-segment
∀e:BasicGeometry
  ∀[a,b,c,d,A,B,C,D:Point].
    (cd ≅ CD) supposing (bd ≅ BD and ad ≅ AD and bc ≅ BC and ab ≅ AB and ac ≅ AC and Colinear(a;b;c) and a # b)

Lemma: geo-colinear-equidistant
∀e:BasicGeometry. ∀[a,b,c,p,q:Point].  (cp ≅ cq) supposing (ap ≅ aq and bp ≅ bq and Colinear(a;b;c) and a # b)

Lemma: not-not-double-pasch
∀e:BasicGeometry. ∀a,b,c,a',b',p:Point.  (B(abc) ⇒ B(a'b'c) ⇒ B(apa') ⇒ (¬¬(∃q:Point. (B(pqc) ∧ B(bqb')))))

Lemma: geo-between-same-side
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (¬((¬B(ACD)) ∧ (¬B(ADC)))) supposing (A # B and B(ABC) and B(ABD))

Lemma: geo-between-same-side-or
∀e:BasicGeometry. ∀A,B,C,d:Point.  ((A # B ∧ C # d) ⇒ B(ABC) ⇒ B(ABd) ⇒ (B(ACd) ∨ B(AdC)))

Lemma: geo-between-same-side2
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (¬((¬B(BCD)) ∧ (¬B(BDC)))) supposing (A # B and B(ABC) and B(ABD))

Lemma: geo-between-same-side2-or
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (¬¬(B(BCD) ∨ B(BDC))) supposing (A # B and B(ABC) and B(ABD))

Lemma: geo-between-same-side2-or-strong
∀e:BasicGeometry. ∀A,B,C,d:Point.  ((A # B ∧ C # d) ⇒ B(ABC) ⇒ B(ABd) ⇒ (B(BCd) ∨ B(BdC)))

Lemma: geo-ge-symmetry
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab ≥ cd ⇒ {ba ≥ cd ∧ ab ≥ dc ∧ ba ≥ dc})

Lemma: geo-strict-between-same-side
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (¬((¬A-C-D) ∧ (¬A-D-C))) supposing (C # D and A-B-C and A-B-D)

Lemma: geo-strict-between-same-side2
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (¬((¬B-C-D) ∧ (¬B-D-C))) supposing (C # D and A-B-C and A-B-D)

Lemma: geo-colinear-sep-cases
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ Colinear(a;b;c) ⇒ ((¬((¬B(acb)) ∧ (¬B(abc)))) ∨ (¬((¬B(bca)) ∧ (¬B(bac))))))

Lemma: geo-le-cases
∀e:BasicGeometry. ∀[p,q:Length].  (¬¬(p ≤ q ∨ q ≤ p))

Lemma: geo-le-iff
∀e:BasicGeometry. ∀A,B,C,P:Point.  (|AB| ≤ |CP| ⇐⇒ CP ≥ AB)

Lemma: stable__geo-le
∀e:BasicGeometry. ∀x,y:Length.  Stable{x ≤ y}

Lemma: geo-add-length_functionality_wrt_le
∀[e:BasicGeometry]. ∀[x,y,x',y':Length].  (x + y ≤ x' + y') supposing (x ≤ x' and y ≤ y')

Lemma: geo-add-length_functionality_wrt_cong
∀e:BasicGeometry. ∀x,y,x',y':Length.  ((x = x' ∈ Length) ⇒ (y = y' ∈ Length) ⇒ (x + y = x' + y' ∈ Length))

Lemma: geo-le-from-be
∀[e:BasicGeometry]. ∀[a,b,c:Point].  |ab| ≤ |ac| supposing B(abc)

Lemma: geo-le-sep
∀e:BasicGeometry. ∀A,B,C,P:Point.  (|AB| ≤ |CP| ⇒ A # B ⇒ C # P)

Lemma: geo-add-length-cancel-left-le
∀[e:BasicGeometry]. ∀[x,y,z:Length].  x ≤ y supposing z + x ≤ z + y

Lemma: geo-add-length-le-implies-eq
∀[e:BasicGeometry]. ∀[x:Length]. ∀[a,b:Point].  a ≡ b supposing x + |ab| ≤ x

Lemma: triangle-inequality-for-colinear
∀[e:EuclideanPlane]. ∀[a,b,c:Point].  (Colinear(b;a;c) ⇒ |ac| ≤ |ab| + |bc|)

Definition: geo-lt
p < q ==  ∃a,b:Point. (a # b ∧ p + |ab| ≤ q)

Lemma: geo-lt_wf
∀[e:BasicGeometry]. ∀[p,q:Length].  (p < q ∈ ℙ)

Lemma: geo-le_weakening-lt
∀[e:BasicGeometry]. ∀[p,q:Length].  p ≤ q supposing p < q

Lemma: geo-le-cases2
∀e:BasicGeometry. ∀[p,q:Length].  (¬¬((p < q ∨ q < p) ∨ (p = q ∈ Length)))

Lemma: geo-lt-irrefl
∀[e:BasicGeometry]. ∀[p:Length].  False supposing p < p

Lemma: geo-lt_transitivity
∀e:BasicGeometry. ∀p,q,r:Length.  (p ≤ q ⇒ q < r ⇒ p < r)

Lemma: geo-lt_transitivity2
∀e:BasicGeometry. ∀p,q,r:Length.  (p < q ⇒ q ≤ r ⇒ p < r)

Lemma: geo-cong-preserves-lt
∀e:BasicGeometry. ∀p,q,p1,q1:Length.  (p < q ⇒ (p = p1 ∈ Length) ⇒ (q = q1 ∈ Length) ⇒ p1 < q1)

Lemma: geo-gt-implies-lt
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ (¬¬|cd| < |ab|))

Lemma: geo-lt-irrefl2
∀e:BasicGeometry. ∀p,q,r:Length.  (p < q + r ⇒ q + r < p ⇒ False)

Lemma: not-lt-and-eq
∀[e:BasicGeometry]. ∀[p,q:Length].  ((p = q ∈ Length) ⇒ q < p ⇒ False)

Lemma: not-lt-and-symm-le
∀[e:BasicGeometry]. ∀[p,q:Length].  (p ≤ q ⇒ q < p ⇒ False)

Lemma: geo-lt_functionality_wrt_implies
∀e:BasicGeometry. ∀a,b,c,d:Length.  (geo_ge(e; b; a) ⇒ c ≤ d ⇒ {b < c ⇒ a < d})

Lemma: geo-zero-lt-iff
∀e:BasicGeometry. ∀u,v:Point.  (0 < |uv| ⇐⇒ u # v)

Lemma: geo-lt-sep
∀e:BasicGeometry. ∀a,b,c,d:Point.  (|ab| < |cd| ⇒ c # d)

Lemma: geo-lt-null-segment
∀e:BasicGeometry. ∀[p:Length]. ∀[a:Point].  uiff(p < |aa|;False)

Lemma: geo-lt-null-segment2
∀e:BasicGeometry. ∀[p:Length]. ∀[a,b:Point].  (False) supposing (a ≡ b and p < |ab|)

Lemma: geo-add-length_functionality_wrt_lt
∀[e:BasicGeometry]. ∀[x,y,x',y':Length].  (y ≤ y' ⇒ x < x' ⇒ x + y < x' + y')

Lemma: geo-add-length-cancel-left-lt
∀[e:BasicGeometry]. ∀[x,y,z:Length].  (z + x < z + y ⇒ x < y)

Lemma: geo-add-length-cancel-right-lt
∀[e:BasicGeometry]. ∀[x,y,z:Length].  (z + x < y + x ⇒ z < y)

Lemma: geo-add-length-cancel-left-lt2
∀e:BasicGeometry. ∀y,z:Length.  (z < z + y ⇐⇒ 0 < y)

Lemma: geo-add-length-cancel-left-lt3
∀e:BasicGeometry. ∀y,z:Length.  (z < 0 + y ⇐⇒ z < y)

Lemma: geo-lt-from-strict-between
∀e:EuclideanPlane. ∀a,b,c:Point.  (a-b-c ⇒ |ab| < |ac|)

Lemma: geo-colinear-same-side
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (Colinear(B;C;D)) supposing (A # B and B(ABC) and B(ABD))

Lemma: geo-colinear-same-side2
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (Colinear(A;C;D)) supposing (A # B and B(ABC) and B(ABD))

Lemma: geo-colinear-between
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (Colinear(A;C;D)) supposing (A # C and B # A and B(ACB) and B(ADB))

Lemma: geo-colinear-between2
∀e:BasicGeometry. ∀[A,B,C,D:Point].  (Colinear(B;C;D)) supposing (B # C and A # B and B(ACB) and B(ADB))

Lemma: geo-between-middle
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # d ⇒ B(abd) ⇒ B(acd) ⇒ (¬((¬B(bcd)) ∧ (¬B(cbd)))))

Lemma: geo-between-middle2
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # d ⇒ B(abd) ⇒ B(acd) ⇒ (¬¬(B(bcd) ∨ B(cbd))))

Lemma: colinear-transitivity-2
∀e:BasicGeometry. ∀p,q,a,b:Point.  (p # q ⇒ Colinear(p;q;a) ⇒ Colinear(p;q;b) ⇒ Colinear(p;a;b))

Lemma: geo-colinear-from-between
∀e:BasicGeometry. ∀[A,C,D:Point].  (A # C ⇒ (∃B:Point. (A # B ∧ B(ACB) ∧ B(ADB))) ⇒ Colinear(A;C;D))

Lemma: geo-colinear-cons
∀e:BasicGeometry. ∀L:Point List. ∀A:Point.
  (geo-colinear-set(e; [A / L]) ⇐⇒ geo-colinear-set(e; L) ∧ (∀B∈L.(∀C∈L.Colinear(A;B;C))))

Lemma: test-prove-separated
∀e:BasicGeometry. ∀A,B,C,X,Y,Z,W,U,V:Point.
  ((A # B ∨ A-X-B ∨ B-X-A) ⇒ (B(ABC) ∨ B(CBA)) ⇒ (B(YCA) ∨ B(ACY)) ⇒ (ZW ≅ AY ∨ ZW ≅ YA) ⇒ ZW ≅ UV ⇒ U # V)

Lemma: geo-intersection-unicity
∀e:BasicGeometry. ∀a,b,c,d,p,q:Point.
  ((¬Colinear(a;b;c)) ⇒ c # d ⇒ Colinear(a;b;p) ⇒ Colinear(a;b;q) ⇒ Colinear(c;d;p) ⇒ Colinear(c;d;q) ⇒ p ≡ q)

Lemma: test-colinear-sets
∀e:BasicGeometry. ∀A,B,C,X,Y,Z,W,U,V:Point.  (A # B ⇒ Colinear(A;B;X) ⇒ B(ABC) ⇒ B(YCA) ⇒ Y # C ⇒ Colinear(C;Y;X))

Lemma: geo-add-length-between-iff
∀e:BasicGeometry. ∀[a,b,c:Point].  uiff(B(abc);|ac| = |ab| + |bc| ∈ Length)

Lemma: geo-seg-length-test
∀e:BasicGeometry. ∀[a,b,c,d,x,y:Point].  (ba ≅ xy) supposing (dc ≅ yx and ab ≅ cd)

Lemma: geo-seg-length-test-ext
∀e:BasicGeometry. ∀[a,b,c,d,x,y:Point].  (ba ≅ xy) supposing (dc ≅ yx and ab ≅ cd)

Definition: geo-le-pt
ab≤cd ==  ∃y:Point. (B(cyd) ∧ ab ≅ cy)

Lemma: geo-le-pt_wf
∀[e:EuclideanPlaneStructure]. ∀[a,b,c,d:Point].  (ab≤cd ∈ ℙ)

Lemma: geo-le-pt-from-be
∀e:BasicGeometry. ∀a,b,c:Point.  ab≤ac supposing B(abc)

Definition: geo-tri
Triangle(a;b;c) ==  a # b ∧ b # c ∧ c # a

Lemma: geo-tri_wf
∀e:BasicGeometry. ∀[a,b,c:Point].  (Triangle(a;b;c) ∈ ℙ)

Definition: geo-pt-sep-from-line
geo-pt-sep-from-line(e; x; a; b) ==
  (a # x ∧ b # x) ∧ (∀y:Point. (((y-a-b ⇒ y # x) ∧ (a-b-y ⇒ y # x)) ∧ (b-y-a ⇒ y # x)))

Lemma: geo-pt-sep-from-line_wf
∀[e:BasicGeometry]. ∀[a,b,x:Point].  (geo-pt-sep-from-line(e; x; a; b) ∈ ℙ)

Definition: geo-opp-side
P-AB-Q ==  (¬(∀T:Point. (B(PTQ) ⇒ (¬Colinear(A;B;T))))) ∧ (¬Colinear(A;B;P)) ∧ (¬Colinear(A;B;Q))

Lemma: geo-opp-side_wf
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].  (P-AB-Q ∈ ℙ)

Lemma: geo-opp-side-trivial
∀[e:BasicGeometry]. ∀[A,P,Q:Point].  (¬P-AA-Q)

Lemma: geo-opp-side_functionality
∀[e:BasicGeometry]. ∀[A,B,P,Q,A',B',P',Q':Point].  (A ≡ A' ⇒ B ≡ B' ⇒ P ≡ P' ⇒ Q ≡ Q' ⇒ (P-AB-Q ⇐⇒ P'-A'B'-Q'))

Lemma: stable__geo-opp-side
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].  Stable{P-AB-Q}

Definition: geo-same-side
A,B-PQ ==  ∀T:Point. (B(ATB) ⇒ (¬Colinear(P;Q;T)))

Lemma: geo-same-side_wf
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].  (P,Q-AB ∈ ℙ)

Lemma: geo-same-side-iff
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].
  (P,Q-AB ⇐⇒ ((¬Colinear(A;B;P)) ∧ (¬Colinear(A;B;Q))) ∧ (¬P leftof AB ⇐⇒ ¬Q leftof AB))

Lemma: geo-opp-side-iff
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].
  (P-AB-Q ⇐⇒ ((¬Colinear(A;B;P)) ∧ (¬Colinear(A;B;Q))) ∧ (¬P leftof AB ⇐⇒ ¬Q leftof BA))

Lemma: geo-opp-side-sym
∀e:BasicGeometry. ∀a,b,p,q:Point.  (a-pq-b ⇒ b-pq-a)

Lemma: geo-opp-side-sym2
∀e:BasicGeometry. ∀a,b,p,q:Point.  (a-pq-b ⇒ a-qp-b)

Lemma: geo-5segSAS
∀e:BasicGeometry. ∀a,b,c,f,g,A,B,C,F,G:Point.
  (af ≅ AF ∧ fb ≅ FB ∧ bc ≅ BC ∧ ag ≅ AG ∧ gc ≅ GC) ⇒ fg ≅ FG supposing B(afb) ∧ B(agc) ∧ B(AFB) ∧ B(AGC)

Definition: geo-sep-line
geo-sep-line(e;a;b;c) ==  ∀z:Point. (Colinear(z;b;c) ⇒ a # z)

Lemma: geo-sep-line_wf
∀[e:BasicGeometry]. ∀[a,b,c:Point].  (geo-sep-line(e;a;b;c) ∈ ℙ)

Definition: geo-same-line
line(a;b)=line(c;d) ==  Colinear(a;b;c) ∧ Colinear(a;b;d)

Lemma: geo-same-line_wf
∀[e:BasicGeometry]. ∀[a,b,c,d:Point].  (line(a;b)=line(c;d) ∈ ℙ)

Lemma: geo-same-line-symmetry
∀[e:BasicGeometry]. ∀[a:Point]. ∀[b:{b:Point| a # b} ]. ∀[c:Point]. ∀[d:{d:Point| c # d} ].
  (line(a;b)=line(c;d) ⇒ line(c;d)=line(a;b))

Lemma: geo-same-line-transitivity
∀[e:BasicGeometry]. ∀[a:Point]. ∀[b:{b:Point| a # b} ]. ∀[c:Point]. ∀[d:{d:Point| c # d} ]. ∀[x:Point]. ∀[y:{y:Point| 
                                                                                                           x # y} ].
  (line(a;b)=line(c;d) ⇒ line(c;d)=line(x;y) ⇒ line(a;b)=line(x;y))

Lemma: geo-same-line-reflexive
∀[e:BasicGeometry]. ∀[a,b:Point].  line(a;b)=line(a;b)

Definition: geo-tar-opp-side
geo-tar-opp-side(e;a;b;p;q) ==  (a # pq ∧ b # pq) ∧ (∃t:Point. (Colinear(p;q;t) ∧ B(atb)))

Lemma: geo-tar-opp-side_wf
∀[e:BasicGeometry]. ∀[A,B,P,Q:Point].  (geo-tar-opp-side(e;A;B;P;Q) ∈ ℙ)

Lemma: geo-tar-opp-side-invariant
∀e:BasicGeometry. ∀A,B,P,Q,C,D:Point.
  (C # D ⇒ Colinear(C;P;Q) ⇒ Colinear(D;P;Q) ⇒ geo-tar-opp-side(e;A;B;P;Q) ⇒ geo-tar-opp-side(e;A;B;C;D))

Lemma: geo-tar-opp-side-iff
∀e:BasicGeometry. ∀A,B,P,Q:Point.  (geo-tar-opp-side(e;P;Q;A;B) ⇐⇒ P # AB ∧ Q # AB ∧ (P leftof AB ⇐⇒ Q leftof BA))

Definition: geo-tar-same-side
geo-tar-same-side(e;a;b;p;q) ==  ∃c:Point. (geo-tar-opp-side(e;a;c;p;q) ∧ geo-tar-opp-side(e;b;c;p;q))

Lemma: geo-tar-same-side_wf
∀[e:BasicGeometry]. ∀[a,b,p,q:Point].  (geo-tar-same-side(e;a;b;p;q) ∈ ℙ)

Lemma: geo-tar-same-side-iff
∀e:BasicGeometry. ∀A,B,P,Q:Point.  (geo-tar-same-side(e;P;Q;A;B) ⇐⇒ P # AB ∧ Q # AB ∧ (P leftof AB ⇐⇒ Q leftof AB))

Lemma: geo-tar-same-side-invariant
∀e:BasicGeometry. ∀A,B,P,Q,C,D:Point.
  (C # D ⇒ Colinear(C;P;Q) ⇒ Colinear(D;P;Q) ⇒ geo-tar-same-side(e;A;B;P;Q) ⇒ geo-tar-same-side(e;A;B;C;D))

Lemma: geo-tar-opp-side-symmetry
∀e:BasicGeometry. ∀a,b,c,d:Point.  (geo-tar-opp-side(e;a;b;c;d) ⇒ geo-tar-opp-side(e;b;a;c;d))

Lemma: 2opp-side-implies-same-side
∀e:BasicGeometry. ∀a,c,d,p,q:Point.
  (((geo-tar-opp-side(e;a;d;p;q) ∧ geo-tar-opp-side(e;c;d;p;q)) ∧ a # c) ⇒ geo-tar-same-side(e;a;c;p;q))

Definition: geo-cong-angle
abc ≅a xyz ==
  (((a # b ∧ b # c) ∧ x # y) ∧ y # z)
  ∧ (∃a',c',x',z':Point. (B(baa') ∧ B(bcc') ∧ B(yxx') ∧ B(yzz') ∧ ba' ≅ yx' ∧ bc' ≅ yz' ∧ a'c' ≅ x'z'))

Lemma: geo-cong-angle_wf
∀[e:BasicGeometry]. ∀[a,b,c,x,y,z:Point].  (abc ≅a xyz ∈ ℙ)

Definition: tar-cong-angle
TAabc=TAxyz ==
  a # b
  ∧ c # b
  ∧ x # y
  ∧ z # y
  ∧ (∃a',c',x',z':Point
      (((B(baa') ∧ B(bcc') ∧ B(yxx') ∧ B(yzz') ∧ aa' ≅ yx ∧ cc' ≅ yz ∧ a'c' ≅ x'z') ∧ xx' ≅ ba) ∧ zz' ≅ bc))

Lemma: tar-cong-angle_wf
∀[e:BasicGeometry]. ∀[a,b,c,x,y,z:Point].  (TAabc=TAxyz ∈ ℙ)

Lemma: geo-cong-angle-refl
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ b # c ⇒ abc ≅a abc)

Lemma: geo-cong-angle-symm
∀e:BasicGeometry. ∀a,b,c:Point.  ((a # b ∧ c # b) ⇒ abc ≅a cba)

Lemma: geo-cong-angle-symm2
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.  (xyz ≅a abc ⇒ abc ≅a xyz)

Lemma: geo-cong-angle-symm3
∀e:BasicGeometry. ∀x,y,z,a,b,c:Point.  (xyz ≅a abc ⇒ zyx ≅a cba)

Definition: geo-bisect-angle
geo-bisect-angle(e;a;b;c) ==  a # b ∧ b # c ∧ (∃d:Point. (d # a ∧ d # c ∧ abd ≅a dbc))

Lemma: geo-bisect-angle_wf
∀e:BasicGeometry. ∀a,b,c:Point.  (geo-bisect-angle(e;a;b;c) ∈ ℙ)

Definition: geo-cong-tri
Cong3(abc,a'b'c') ==  ab ≅ a'b' ∧ bc ≅ b'c' ∧ ca ≅ c'a'

Lemma: geo-cong-tri_wf
∀[e:BasicGeometry]. ∀[a,b,c,a',b',c':Point].  (Cong3(abc,a'b'c') ∈ ℙ)

Lemma: geo-cong-tri-symmetry
∀[e:BasicGeometry]. ∀[a,b,c,a',b',c':Point].  Cong3(bca,b'c'a') supposing Cong3(abc,a'b'c')

Lemma: geo-bet-sep-cong-tri-exists
∀e:BasicGeometry. ∀a,b,c,a',c':Point.
  (a # b ⇒ (∃b':Point. (B(a'b'c') ∧ Cong3(abc,a'b'c'))) supposing (B(abc) and ac ≅ a'c'))

Lemma: geo-between-cong-tri-exists
∀[e:BasicGeometry]. ∀[a,b,c,a',c':Point].
  (B(abc) ⇒ ac ≅ a'c' ⇒ (¬¬(∃b':Point. (Cong3(abc,a'b'c') ∧ Colinear(a';b';c')))))

Lemma: geo-colinear-cong-tri-exists
∀[e:BasicGeometry]. ∀[a,b,c,a',c':Point].
  (Colinear(a;b;c) ⇒ ac ≅ a'c' ⇒ (¬¬(∃b':Point. (Cong3(abc,a'b'c') ∧ Colinear(a';b';c')))))

Lemma: cong-tri-implies-cong-angle
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.  (Cong3(abc,xyz) ⇒ a # b ⇒ b # c ⇒ x # y ⇒ y # z ⇒ abc ≅a xyz)

Lemma: cong-tri-implies-all-cong-angle
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  (Cong3(abc,xyz) ⇒ a # b ⇒ b # c ⇒ c # a ⇒ x # y ⇒ y # z ⇒ z # x ⇒ {abc ≅a xyz ∧ bca ≅a yzx ∧ cab ≅a zxy})

Lemma: cong-tri-implies-cong-angle2
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.  (a # b ⇒ b # c ⇒ ab ≅ xy ⇒ bc ≅ yz ⇒ ca ≅ zx ⇒ abc ≅a xyz)

Definition: geo-out-strict
geo-out-strict(e;p;a;b) ==  ¬((¬p-a-b) ∧ (¬p-b-a))

Lemma: geo-out-strict_wf
∀[e:BasicGeometry]. ∀[p,a,b:Point].  (geo-out-strict(e;p;a;b) ∈ ℙ)

Lemma: stable__geo-out-strict
∀[e:BasicGeometry]. ∀[a,b:Point].  ∀p:Point. Stable{geo-out-strict(e;p;a;b)}

Lemma: geo-out-strict_functionality
∀e:BasicGeometry. ∀p,a,b,p',a',b':Point.
  (p ≡ p' ⇒ a ≡ a' ⇒ b ≡ b' ⇒ {geo-out-strict(e;p;a;b) ⇐⇒ geo-out-strict(e;p';a';b')})

Lemma: geo-out-strict_inversion
∀e:BasicGeometry. ∀a,b,c:Point.  (geo-out-strict(e;a;b;c) ⇒ geo-out-strict(e;a;c;b))

Lemma: geo-out-strict_weakening
∀e:BasicGeometry. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ (¬B(cab)) ⇒ a # b ⇒ b # c ⇒ geo-out-strict(e;a;b;c))

Lemma: geo-out-strict_transitivity
∀e:BasicGeometry. ∀a,b,c,d:Point.
  (b # d ⇒ geo-out-strict(e;a;b;c) ⇒ geo-out-strict(e;a;c;d) ⇒ geo-out-strict(e;a;b;d))

Lemma: geo-out-strict-colinear
∀e:BasicGeometry. ∀a,b,c:Point.  (geo-out-strict(e;a;b;c) ⇒ Colinear(a;b;c))

Definition: geo-out
out(p ab) ==  p # a ∧ p # b ∧ (¬((¬B(pab)) ∧ (¬B(pba))))

Lemma: geo-out_wf
∀[e:BasicGeometry]. ∀[p,a,b:Point].  (out(p ab) ∈ ℙ)

Lemma: sq_stable__geo-out
∀e:BasicGeometry. ∀p,a,b:Point.  SqStable(out(p ab))

Lemma: geo-out_functionality
∀e:BasicGeometry. ∀p,a,b,p',a',b':Point.  (p ≡ p' ⇒ a ≡ a' ⇒ b ≡ b' ⇒ {out(p ab) ⇐⇒ out(p' a'b')})

Lemma: geo-out_inversion
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ out(a cb))

Lemma: geo-out_weakening
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ b ≡ c ⇒ out(a bc))

Lemma: geo-out_transitivity
∀e:BasicGeometry. ∀a,b,c,d:Point.  (out(a bc) ⇒ out(a cd) ⇒ out(a bd))

Lemma: geo-between-out
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ a # c ⇒ B(abc) ⇒ out(a bc))

Lemma: geo-out-distinct
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ {a # b ∧ a # c})

Lemma: geo-out-trivial
∀e:BasicGeometry. ∀a,b:Point.  (a # b ⇒ out(a bb))

Lemma: geo-out-colinear
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ Colinear(a;b;c))

Lemma: not-lsep-if-out
∀g:EuclideanPlane. ∀a,b,c:Point.  (out(b ac) ⇒ (¬a # bc))

Lemma: not-out-if-lsep
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ (¬out(b ac)))

Lemma: geo-out-iff-between1
∀e:BasicGeometry. ∀p,a,b,c:Point.  (p # a ⇒ p # b ⇒ p # c ⇒ B(apc) ⇒ (B(bpc) ⇐⇒ out(p ab)))

Lemma: geo-out-if-between
∀e:BasicGeometry. ∀p,a,b,c:Point.  (a-p-c ⇒ b-p-c ⇒ out(p ab))

Lemma: geo-out-iff-colinear
∀e:BasicGeometry. ∀p,a,b:Point.  (out(p ab) ⇐⇒ (Colinear(p;a;b) ∧ (¬B(apb))) ∧ p # a ∧ p # b)

Lemma: geo-out-iff-exists
∀e:BasicGeometry. ∀p,a,b:Point.  (out(p ab) ⇐⇒ (∃c:Point. (p # c ∧ B(apc) ∧ B(bpc))) ∧ p # a ∧ p # b)

Lemma: geo-between-implies-out
∀e:BasicGeometry. ∀p,a,b:Point.  ((∃c:Point. (p # c ∧ B(pca) ∧ B(pcb))) ⇒ out(p ab))

Lemma: geo-between-implies-out2
∀e:BasicGeometry. ∀p,a,b,c:Point.  (p # c ⇒ B(pca) ⇒ B(pcb) ⇒ out(p ab))

Lemma: geo-between-implies-out3
∀e:BasicGeometry. ∀p,a,b,c:Point.  (p-b-a ⇒ p-c-a ⇒ out(p bc))

Lemma: geo-strict-between-implies-out
∀e:BasicGeometry. ∀a,b,c:Point.  (a-b-c ⇒ out(a bc))

Lemma: geo-strict-between-implies-out2
∀e:BasicGeometry. ∀a,b,c:Point.  (a-b-c ⇒ out(a cb))

Lemma: geo-between-out-implies-out
∀e:EuclideanPlane. ∀a,b,c,c':Point.  (out(a cc') ⇒ (a-b-c ∨ a-c-b) ⇒ out(a c'b))

Lemma: geo-between-out-implies-out2
∀e:EuclideanPlane. ∀a,b,c,c':Point.  (out(a cc') ⇒ ((B(abc) ∧ a # b) ∨ (B(acb) ∧ a # c)) ⇒ out(a c'b))

Lemma: geo-bet-out-out-bet
∀e:BasicGeometry. ∀b,a,a',c,c':Point.  (B(abc) ⇒ out(b aa') ⇒ out(b cc') ⇒ B(a'bc'))

Lemma: geo-out2-bet-out
∀e:BasicGeometry. ∀a,b,c,x,p:Point.  (out(b ac) ⇒ out(b xp) ⇒ B(axc) ⇒ {out(b ap) ∧ out(b cp)})

Lemma: geo-out-unicity
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ ab ≅ ac ⇒ b ≡ c)

Lemma: geo-out-le-iff-bet
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ (|ab| ≤ |ac| ⇐⇒ B(abc)))

Lemma: geo-out2-bet
∀e:BasicGeometry. ∀a,b,c:Point.  (out(a bc) ⇒ out(c ab) ⇒ B(abc))

Lemma: geo-lt-out-to-between
∀e:EuclideanPlane. ∀a,b,c:Point.  (out(a bc) ⇒ |ab| < |ac| ⇒ a-b-c)

Lemma: geo-gt-out-to-between
∀e:EuclideanPlane. ∀a,b,c:Point.  (out(a bc) ⇒ ac > ab ⇒ a-b-c)

Lemma: geo-cong-preserves-bet-out
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (B(abc) ⇒ ab ≅ a'b' ⇒ ac ≅ a'c' ⇒ out(a' b'c') ⇒ B(a'b'c'))

Lemma: geo-cong-preserves-strict-bet-out
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (a-b-c ⇒ ab ≅ a'b' ⇒ ac ≅ a'c' ⇒ out(a' b'c') ⇒ a'-b'-c')

Lemma: geo-out-cong-cong
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (out(a bc) ⇒ out(a' b'c') ⇒ ab ≅ a'b' ⇒ ac ≅ a'c' ⇒ bc ≅ b'c')

Lemma: geo-colinear-not-out
∀e:BasicGeometry. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ (¬out(a bc) ⇐⇒ B(bac)))

Lemma: geo-colinear-out-cases
∀[e:BasicGeometry-]. ∀[a,b,c:Point].  ∀X:ℙ. (Stable{X} ⇒ Colinear(a;b;c) ⇒ (out(a bc) ⇒ X) ⇒ (B(cab) ⇒ X) ⇒ X)

Lemma: geo-not-bet-and-out
∀e:BasicGeometry. ∀a,b,c:Point.  (B(abc) ⇒ (¬out(b ac)))

Lemma: geo-out-to-bet
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (Colinear(a';b';c') ⇒ (out(b ac) ⇐⇒ out(b' a'c')) ⇒ B(abc) ⇒ B(a'b'c'))

Lemma: geo-col-out2-col
∀e:BasicGeometry. ∀a,b,c,a',c':Point.  (Colinear(a;b;c) ⇒ out(b aa') ⇒ out(b cc') ⇒ Colinear(a';b;c'))

Lemma: out-congruent
∀e:BasicGeometry. ∀a,b,c,c',c1,d,d',d1:Point.
  (out(a cc') ⇒ out(b dd') ⇒ ac' ≅ bd' ⇒ B(acc1) ⇒ B(bdd1) ⇒ cc1 ≅ bd ⇒ dd1 ≅ ac ⇒ (ac1 ≅ bd1 ∧ c'c1 ≅ d'd1))

Lemma: geo-congruent-preserves-out
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (bc ≅ b'c' ⇒ ac ≅ a'c' ⇒ ab ≅ a'b' ⇒ out(a bc) ⇒ out(a' b'c'))

Lemma: geo-out-cong-implies-eq
∀e:BasicGeometry. ∀a,b,x,y:Point.  (out(a bx) ⇒ out(a by) ⇒ ax ≅ ay ⇒ x ≡ y)

Lemma: extended-out-preserves-between
∀e:EuclideanPlane. ∀a,b,c,d:Point.  ((out(a bc) ∧ b-a-d) ⇒ c-a-d)

Lemma: geo-between-middle-or
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ b # c ⇒ b # d ⇒ B(abd) ⇒ B(acd) ⇒ (B(bcd) ∨ B(cbd)))

Lemma: geo-col-between-cases
∀e:EuclideanPlane. ∀a,b,c,x:Point.  (a-b-c ⇒ Colinear(a;x;c) ⇒ (¬¬(B(xab) ∨ B(axb) ∨ B(bxc) ∨ B(bcx))))

Lemma: geo-between-out-implies-out3
∀e:EuclideanPlane. ∀a,b,b',c,c',t:Point.
  (out(a bb') ⇒ out(a cc') ⇒ a-b-c ⇒ B(b'tc') ⇒ a # t ⇒ {(out(a ct) ∧ out(a bt)) ∧ out(a c't) ∧ out(a b't)})

Lemma: geo-left-out-better
∀e:EuclideanPlane. ∀a,b,a',p:Point.  (p leftof ba ⇒ b # a' ⇒ (¬((¬B(baa')) ∧ (¬B(ba'a)))) ⇒ p leftof ba')

Lemma: geo-left-out
∀e:EuclideanPlane. ∀a,b,a',p:Point.  (p leftof ba ⇒ out(b aa') ⇒ p leftof ba')

Lemma: geo-left-out-better-1
∀e:EuclideanPlane. ∀a,b,b',p:Point.  (p leftof ba ⇒ b' # a ⇒ (¬((¬B(ab'b)) ∧ (¬B(abb')))) ⇒ p leftof b'a)

Lemma: geo-left-out-1
∀e:EuclideanPlane. ∀a,b,b',p:Point.  (p leftof ba ⇒ out(a bb') ⇒ p leftof b'a)

Lemma: geo-left-out-2
∀e:EuclideanPlane. ∀a,b,p,p':Point.  (p leftof ba ⇒ out(b pp') ⇒ p' leftof ba)

Lemma: geo-left-out-3
∀e:EuclideanPlane. ∀a,b,p,p':Point.  (p leftof ba ⇒ out(a pp') ⇒ p' leftof ba)

Lemma: geo-left-out-4
∀e:EuclideanPlane. ∀a,b,p,a',b':Point.  (p leftof ab ⇒ out(p aa') ⇒ out(p bb') ⇒ p leftof a'b')

Lemma: geo-equilateral-exists
∀e:BasicGeometry-. ∀a,b,c:Point.  (a # bc ⇒ (∃x:Point. ((ax ≅ ac ∧ out(a bx)) ∧ a # xc)))

Lemma: weak-same-side-invariant
∀[e:BasicGeometry]. ∀[A,B,C,D:Point].
  (¬¬(((∀P:Point. (P leftof AB ⇐⇒ P leftof CD)) ∧ (∀P:Point. (P leftof BA ⇐⇒ P leftof DC)))
     ∨ ((∀P:Point. (P leftof AB ⇐⇒ P leftof DC)) ∧ (∀P:Point. (P leftof BA ⇐⇒ P leftof CD))))) supposing 
     (A # B and 
     C # D and 
     Colinear(C;A;B) and 
     Colinear(D;A;B))

Lemma: geo-colinear-left-out
∀e:EuclideanPlane. ∀a,b,x,y:Point.  (Colinear(b;x;y) ⇒ x leftof ab ⇒ y leftof ab ⇒ out(b xy))

Lemma: geo-colinear-left-out2
∀e:EuclideanPlane. ∀a,b,x,y:Point.  (Colinear(b;x;y) ⇒ x leftof ba ⇒ y leftof ba ⇒ out(b xy))

Lemma: geo-SCS-out
∀e:EuclideanPlane. ∀a:Point. ∀x,b:{b:Point| a # b} .  out(a bSCS(b;a;a;x))

Lemma: center-on-circle-overlap
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # b ⇒ |bc| ≤ |ab| + |ab| ⇒ Overlap(a;b;b;c))

Lemma: geo-be-end-eq
∀e:BasicGeometry. ∀a,b,c:Point.  (B(abc) ⇒ ab ≅ ac ⇒ b ≡ c)

Lemma: cong-angle-out-aux_1
∀g:BasicGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  (abc ≅a def ⇒ out(b a'a) ⇒ out(b c'c) ⇒ out(e d'd) ⇒ out(e f'f) ⇒ ba' ≅ ed' ⇒ bc' ≅ ef' ⇒ a'c' ≅ d'f')

Lemma: cong-angle-out-aux2_1
∀g:BasicGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  (a'c' ≅ d'f' ⇒ out(b a'a) ⇒ out(b c'c) ⇒ out(e d'd) ⇒ out(e f'f) ⇒ ba' ≅ ed' ⇒ bc' ≅ ef' ⇒ abc ≅a def)

Lemma: cong-angle-out-exists2
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  (abc ≅a xyz
  ⇒ a # b
  ⇒ c # b
  ⇒ x # y
  ⇒ z # y
  ⇒ (∃a',c',x',z':Point. (out(b a'a) ∧ out(b c'c) ∧ out(y x'x) ∧ out(y z'z) ∧ a'bc' ≅a x'yz')))

Lemma: cong-angle-out-exists3
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  (abc ≅a xyz
  ⇒ a # b
  ⇒ c # b
  ⇒ x # y
  ⇒ z # y
  ⇒ (∃a',c',x',z':Point. ((out(b a'a) ∧ out(b c'c) ∧ out(y x'x) ∧ out(y z'z) ∧ a'bc' ≅a x'yz') ∧ Cong3(a'bc',x'yz'))))

Lemma: out-preserves-angle-cong_1
∀e:BasicGeometry. ∀a,b,c,a',b',c',p,q,p',q':Point.
  (abc ≅a a'b'c' ⇒ out(b cq) ⇒ out(b ap) ⇒ out(b' c'q') ⇒ out(b' a'p') ⇒ pbq ≅a p'b'q')

Lemma: out-cong-angle
∀e:BasicGeometry. ∀a,b,c,a',c':Point.  (out(b cc') ⇒ out(b aa') ⇒ abc ≅a a'bc')

Lemma: cong-angle-between-exists
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  (abc ≅a xyz
  ⇒ b # a
  ⇒ b # c
  ⇒ y # x
  ⇒ y # z
  ⇒ (∃a',c',x',z':Point. (B(baa') ∧ B(bcc') ∧ B(yxx') ∧ B(yzz') ∧ ((ba ≅ xx' ∧ aa' ≅ yx) ∧ bc ≅ zz') ∧ cc' ≅ yz)))

Lemma: cong-angle-between-exists-iff
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  ((((b # a ∧ b # c) ∧ y # x) ∧ y # z)
  ⇒ (abc ≅a xyz
     ⇐⇒ ∃a',c',x',z':Point
          ((((B(baa') ∧ B(bcc')) ∧ B(yxx')) ∧ B(yzz'))
          ∧ (((ba ≅ xx' ∧ aa' ≅ yx) ∧ bc ≅ zz') ∧ cc' ≅ yz)
          ∧ a'c' ≅ x'z')))

Lemma: geo-cong-angle-transitivity
∀e:BasicGeometry. ∀a,b,c,x,y,z,p,q,r:Point.  (abc ≅a xyz ⇒ xyz ≅a pqr ⇒ abc ≅a pqr)

Lemma: geo-cong-angle-symmetry
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  (xyz ≅a abc ⇒ {zyx ≅a abc ∧ xyz ≅a cba ∧ zyx ≅a cba ∧ abc ≅a xyz ∧ cba ≅a xyz ∧ abc ≅a zyx ∧ cba ≅a zyx})

Lemma: geo-cong-angle_functionality
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2,d1,d2,f1,f2,g1,g2:Point.
  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ d1 ≡ d2 ⇒ f1 ≡ f2 ⇒ g1 ≡ g2 ⇒ (a1b1c1 ≅a d1f1g1 ⇐⇒ a2b2c2 ≅a d2f2g2))

Lemma: geo-cong-angle_inversion
∀e:BasicGeometry. ∀a,b,c:Point.  ((a # b ∧ c # b) ⇒ abc ≅a cba)

Lemma: geo-cong-angle_weakening
∀e:BasicGeometry. ∀a,b,c:Point.  ((a # b ∧ a ≡ c) ⇒ abc ≅a abc)

Lemma: geo-zero-angle-congruence-out
∀g:EuclideanPlane. ∀a,b,c,x,y:Point.  (abc ≅a xyx ⇒ out(b ac))

Lemma: geo-zero-angle-congruence-subst
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc ≅a xyx ⇒ aba ≅a xyx)

Definition: geo-five-seg-compressed
FSC(a;b;c;d  a';b';c';d') ==  Colinear(a;b;c) ∧ Cong3(abc,a'b'c') ∧ ad ≅ a'd' ∧ bd ≅ b'd'

Lemma: geo-five-seg-compressed_wf
∀[e:BasicGeometry]. ∀[a,b,c,d,a',b',c',d':Point].  (FSC(a;b;c;d  a';b';c';d') ∈ ℙ)

Lemma: geo-fsc-ap
∀e:BasicGeometry. ∀a,b,c,d,a',b',c',d':Point.  (FSC(a;b;c;d  a';b';c';d') ⇒ a # b ⇒ cd ≅ c'd')

Lemma: geo-colinear-congruence1
∀e:BasicGeometry. ∀A,B,C,P,Q:Point.  (A # B ⇒ Colinear(A;B;C) ⇒ AP ≅ AQ ⇒ BP ≅ BQ ⇒ CP ≅ CQ)

Lemma: geo-colinear-congruence2
∀e:BasicGeometry. ∀A,B,C,C':Point.  (A # B ⇒ Colinear(A;B;C) ⇒ AC ≅ AC' ⇒ BC ≅ BC' ⇒ C ≡ C')

Lemma: geo-strict-between-congruence
∀e:BasicGeometry. ∀A,B,C,C':Point.  (B(ACB) ⇒ AC ≅ AC' ⇒ BC ≅ BC' ⇒ C ≡ C')

Lemma: not-col-distincts
∀e:BasicGeometry. ∀A,B,C:Point.  ((¬Colinear(A;B;C)) ⇒ (¬¬(A # B ∧ B # C ∧ A # C)))

Lemma: symmetric-point-unicity
∀e:BasicGeometry. ∀a,p,p1,p2:Point.  (p=a=p1 ⇒ p=a=p2 ⇒ p1 ≡ p2)

Lemma: symmetric-point-unicity2
∀e:BasicGeometry. ∀a,p,p1,p2:Point.  (p1=a=p ⇒ p2=a=p ⇒ p1 ≡ p2)

Lemma: seg-midpoints-equal
∀e:BasicGeometry. ∀P,Q,A,X:Point.  ((P=A=X ∧ Q=A=X) ⇒ P ≡ Q)

Lemma: seg-midpoints-equal-flip
∀e:BasicGeometry. ∀P,Q,A,X:Point.  ((P=A=X ∧ X=A=Q) ⇒ P ≡ Q)

Lemma: geo-midpoint-diagonals-congruent
∀e:BasicGeometry. ∀A,P,Q,p,q:Point.  (p=A=P ⇒ q=A=Q ⇒ PQ ≅ pq)

Lemma: geo-vert-angle-SAS
∀e:BasicGeometry. ∀a,p,q,p',q':Point.  (p-a-q ⇒ p'-a-q' ⇒ pa ≅ p'a ⇒ qa ≅ q'a ⇒ p'q ≅ pq')

Lemma: symmetry-preserves-congruence
∀e:BasicGeometry. ∀A,P,Q,p,q:Point.  (p=A=P ⇒ q=A=Q ⇒ PQ ≅ pq)

Lemma: geo-midpoint-diagonals-between
∀e:BasicGeometry. ∀A,P,Q,R,P',Q',R':Point.  ((((P=A=P' ∧ R=A=R') ∧ Q=A=Q') ∧ B(PQR)) ⇒ B(P'Q'R'))

Lemma: geo-midpoint-diagonals-congruent2
∀e:BasicGeometry. ∀P,Q,R,S,P',Q',R',S',A:Point.  (((((P=A=P' ∧ Q=A=Q') ∧ R=A=R') ∧ S=A=S') ∧ PQ ≅ RS) ⇒ P'Q' ≅ R'S')

Lemma: Mid_cases
∀e:BasicGeometry. ∀A,B,C:Point.  ((B=A=C ∨ C=A=B) ⇒ B=A=C)

Lemma: Mid_perm
∀e:BasicGeometry. ∀A,B,C:Point.  (B=A=C ⇒ (B=A=C ∧ C=A=B))

Lemma: symmetry_preserves_midpoint
∀e:BasicGeometry. ∀a,b,c,d,e1,f,z:Point.  ((((a=z=d ∧ b=z=e1) ∧ c=z=f) ∧ a=b=c) ⇒ d=e1=f)

Lemma: at-most-one-midpoint
∀e:BasicGeometry. ∀P,P',A,B:Point.  ((P=A=P' ∧ P=B=P') ⇒ A ≡ B)

Lemma: midpoint-sep
∀e:BasicGeometry. ∀A,B,M:Point.  (A # B ⇒ A=M=B ⇒ {A # M ∧ B # M})

Lemma: colinear-implies-midpoint
∀e:BasicGeometry. ∀M,A,B:Point.  (A # B ⇒ Colinear(A;M;B) ⇒ MA ≅ MB ⇒ A=M=B)

Lemma: colinear-implies-congruent_or_midpoint
∀e:BasicGeometry. ∀M,A,B:Point.  (Colinear(A;M;B) ⇒ MA ≅ MB ⇒ (¬¬(A ≡ B ∨ A=M=B)))

Lemma: opposite-side-congruent-diagonals-midpoint
∀e:BasicGeometry. ∀A,B,C,D,P:Point.
  ((¬Colinear(A;B;C)) ⇒ B # D ⇒ AB ≅ CD ⇒ BC ≅ DA ⇒ Colinear(A;P;C) ⇒ Colinear(B;P;D) ⇒ {A=P=C ∧ B=P=D})

Lemma: midpoints-preserve-congruence
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.
  ((((a'=b'=c' ∧ a=b=c) ∧ a' # c' ∧ a # c) ∧ ac ≅ a'c') ⇒ (ab ≅ a'b' ∧ bc ≅ b'c'))

Lemma: geo-krippen-aux
∀e:BasicGeometry. ∀a1,a2,b1,b2,c,m1,m2:Point.
  (B(a1ca2) ⇒ B(b1cb2) ⇒ ca1 ≅ cb1 ⇒ ca2 ≅ cb2 ⇒ a1=m1=b1 ⇒ a2=m2=b2 ⇒ |ca1| ≤ |ca2| ⇒ B(m1cm2))

Lemma: geo-krippen-lemma
∀e:BasicGeometry. ∀a1,a2,b1,b2,c,m1,m2:Point.
  (B(a1ca2) ⇒ B(b1cb2) ⇒ ca1 ≅ cb1 ⇒ ca2 ≅ cb2 ⇒ a1=m1=b1 ⇒ a2=m2=b2 ⇒ B(m1cm2))

Lemma: geo-conga-to-cong3
∀E:BasicGeometry. ∀a,b,c,d,e,f:Point.
  (a # b
  ⇒ c # b
  ⇒ d # e
  ⇒ f # e
  ⇒ abc ≅a def
  ⇒ (∃a',c',d',f':Point. (out(b a'a) ∧ out(b cc') ∧ out(e d'd) ∧ out(e ff') ∧ Cong3(a'bc',d'ef'))))

Lemma: geo-between-seg-eq
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (B(abc) ⇒ B(a'b'c') ⇒ ab ≅ a'b' ⇒ ac ≅ a'c' ⇒ bc ≅ b'c')

Definition: geo-lt-pt
ab < cd ==  ∃y:Point. (c-y-d ∧ ab ≅ cy)

Lemma: geo-lt-pt_wf
∀[e:EuclideanPlaneStructure]. ∀[a,b,c,d:Point].  (ab < cd ∈ ℙ)

Lemma: geo-lt-pt-exists
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ ab < cd ⇒ (∃x:Point. (a-b-x ∧ ax ≅ cd)))

Lemma: geo-eqt
∀e:BasicGeometry. ∀a,b,c:{p:Point| B(OXp)} .
  (((a = b ∈ {p:Point| B(OXp)} ) ∧ (b = c ∈ {p:Point| B(OXp)} )) ⇒ (a = c ∈ {p:Point| B(OXp)} ))

Lemma: geo-eq-x-implies-eq
∀e:BasicGeometry. ∀a,b:Point.  ((X = |ab| ∈ Length) ⇒ a ≡ b)

Lemma: geo-sum-eq-x
∀e:BasicGeometry. ∀a,b,c,d:Point.  ((X = |ab| + |cd| ∈ Length) ⇒ (a ≡ b ∧ c ≡ d))

Lemma: geo-ab-eq-x
∀e:BasicGeometry. ∀a,b:Point.  (a ≡ b ⇒ (X = |ab| ∈ Length))

Lemma: geo-colinear-switch
∀e:BasicGeometry. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(a;c;b))

Lemma: geo-colinear-switch2
∀e:BasicGeometry. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(b;a;c))

Lemma: geo-colinear-switch3
∀e:BasicGeometry. ∀a,b,c:Point.  (Colinear(a;b;c) ⇒ Colinear(c;b;a))

Lemma: geo-colinear-trivial
∀e:BasicGeometry. ∀a,b:Point.  ((¬(a = b ∈ Point)) ⇒ (Colinear(a;b;b) ∧ Colinear(b;a;b)))

Lemma: geo-cong3-to-conga-aux
∀e:BasicGeometry. ∀b,a,a',a0,e0,d,d',d0:Point.
  (out(b aa')
  ⇒ out(e0 dd')
  ⇒ B(baa0)
  ⇒ B(e0dd0)
  ⇒ ba' ≅ e0d'
  ⇒ aa0 ≅ e0d
  ⇒ dd0 ≅ ba
  ⇒ (ba0 ≅ e0d0 ∧ a'a0 ≅ d'd0))

Lemma: geo-cong3-to-conga
∀e:BasicGeometry. ∀a,b,c,d,E,f:Point.
  ((∃a',c',d',f':Point. (out(b a'a) ∧ out(b c'c) ∧ out(E d'd) ∧ out(E f'f) ∧ Cong3(a'bc',d'Ef'))) ⇒ abc ≅a dEf)

Lemma: cong3-implies-conga
∀e:BasicGeometry. ∀a,b,c,d,E,f:Point.  (a # b ⇒ b # c ⇒ Cong3(abc,dEf) ⇒ abc ≅a dEf)

Lemma: geo-be-compress
∀e:BasicGeometry. ∀a,b,c:Point.  (B(abc) ⇒ B(acb) ⇒ b ≡ c)

Lemma: geo-between-middle
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # d ⇒ B(abd) ⇒ B(acd) ⇒ (¬((¬B(bcd)) ∧ (¬B(cbd)))))

Lemma: geo-eq-implies-col
∀e:BasicGeometry. ∀a,b,c:Point.  ((¬(a = b ∈ Point)) ⇒ (b = c ∈ Point) ⇒ Colinear(a;b;c))

Lemma: geo-col-connect
∀e:BasicGeometry. ∀a,b,c,d:Point.  (c # b ⇒ Colinear(a;b;c) ⇒ Colinear(c;b;d) ⇒ Colinear(a;b;d))

Lemma: right-angle_functionality
∀e:BasicGeometry. ∀a,b,c,a',b',c':Point.  (a ≡ a' ⇒ b ≡ b' ⇒ c ≡ c' ⇒ {Rabc ⇐⇒ Ra'b'c'})

Lemma: stable__right-angle
∀e:BasicGeometry. ∀a,b,c:Point.  Stable{Rabc}

Lemma: implies-right-angle
∀e:BasicGeometry. ∀a,b,c,c':Point.  (c'=b=c ⇒ ac ≅ ac' ⇒ Rabc)

Lemma: right-angle-symmetry
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ Rcba)

Lemma: symmetry-preserves-right-angle
∀e:BasicGeometry. ∀a,b,c,c':Point.  (c=b=c' ⇒ Rabc ⇒ Rabc')

Lemma: right-angle-trivial
∀e:BasicGeometry. ∀a,b:Point.  Rabb

Lemma: right-angle-trivial2
∀e:BasicGeometry. ∀a,b:Point.  Rbba

Lemma: right-angle-colinear
∀e:BasicGeometry. ∀a,b,c,a':Point.  (Rabc ⇒ a # b ⇒ Colinear(b;a;a') ⇒ Ra'bc)

Lemma: right-angle-colinear2
∀e:BasicGeometry. ∀a,b,c,c':Point.  (Rabc ⇒ c # b ⇒ Colinear(b;c;c') ⇒ Rabc')

Lemma: adjacent-right-angles
∀e:BasicGeometry. ∀a,b,c,a':Point.  (b # c ⇒ Rabc ⇒ Ra'bc ⇒ Colinear(a;b;a'))

Lemma: right-angle-legs-same
∀e:BasicGeometry. ∀a,b:Point.  (Rbab ⇒ a ≡ b)

Lemma: colinear-right-angle
∀e:BasicGeometry. ∀a,b,c:Point.  (b # c ⇒ Colinear(a;b;c) ⇒ Rabc ⇒ a ≡ b)

Lemma: right-angles-not-acute
∀e:BasicGeometry. ∀a,b,c,a':Point.  (Rabc ⇒ Ra'bc ⇒ B(aca') ⇒ b ≡ c)

Lemma: right-angles-not-acute2
∀e:BasicGeometry. ∀a,b,c,a':Point.  (b # c ⇒ Rabc ⇒ Ra'bc ⇒ B(aa'c) ⇒ a ≡ a')

Lemma: right-angles-not-complementary
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ Racb ⇒ b ≡ c)

Lemma: colinear-right-angle-trivial
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ Colinear(a;b;c) ⇒ (¬(a # b ∧ c # b)))

Lemma: congruence-preserves-right-angle
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ (∀a',b',c':Point.  (Cong3(abc,a'b'c') ⇒ Ra'b'c')))

Definition: geo-perp-in
ab  ⊥x cd ==  Colinear(a;b;x) ∧ Colinear(c;d;x) ∧ (∀u,v:Point.  (Colinear(a;b;u) ⇒ Colinear(c;d;v) ⇒ Ruxv))

Lemma: geo-perp-in_wf
∀[e:BasicGeometry]. ∀[x,a,b,c,d:Point].  (ab  ⊥x cd ∈ ℙ)

Lemma: stable__geo-perp-in
∀e:BasicGeometry. ∀x:Point.  ∀[a,b,c,d:Point].  Stable{ab  ⊥x cd}

Lemma: sq_stable__geo-perp-in
∀e:BasicGeometry. ∀x:Point.  ∀[a,b,c,d:Point].  SqStable(ab  ⊥x cd)

Lemma: geo-perp-in_functionality
∀e:BasicGeometry. ∀x:Point.
  ∀[a,b,c,d:Point].
    ∀x':Point
      ∀[a',b',c',d':Point].
        (uiff(ab  ⊥x cd;a'b'  ⊥x' c'd')) supposing (d ≡ d' and c ≡ c' and b ≡ b' and a ≡ a' and x ≡ x')

Lemma: geo-perp-in-symmetry1
∀e:BasicGeometry. ∀x:Point.  ∀[a,b,c,d:Point].  (ab  ⊥x cd ⇒ cd  ⊥x ab)

Lemma: geo-perp-in-symmetry2
∀e:BasicGeometry. ∀x:Point.  ∀[a,b,c,d:Point].  (ab  ⊥x cd ⇒ ba  ⊥x cd)

Lemma: geo-perp-in-symmetry
∀e:BasicGeometry. ∀x:Point.
  ∀[a,b,c,d:Point].  (ab  ⊥x cd ⇒ {ba  ⊥x cd ∧ ab  ⊥x dc ∧ ba  ⊥x dc ∧ cd  ⊥x ab ∧ dc  ⊥x ab ∧ cd  ⊥x ba ∧ dc  ⊥x ba})

Lemma: geo-perp-in-not-eq
∀e:BasicGeometry. ∀x:Point.  ∀[a,b,c,d:Point].  (ab  ⊥x cd ⇒ (¬a ≡ b))

Definition: geo-perp
ab ⊥ cd ==  ∃x:Point. ab  ⊥x cd

Lemma: geo-perp_wf
∀[e:BasicGeometry]. ∀[a,b,c,d:Point].  (ab ⊥ cd ∈ ℙ)

Lemma: geo-perp-all-symmetry
∀e:BasicGeometry. ∀[a,b,c,d:Point].  (ab ⊥ cd ⇒ {ba ⊥ cd ∧ ab ⊥ dc ∧ ba ⊥ dc ∧ cd ⊥ ab ∧ dc ⊥ ab ∧ cd ⊥ ba ∧ dc ⊥ ba})

Lemma: geo-perp-symmetry
∀e:BasicGeometry. ∀a,b,c,d:Point.  (ab ⊥ cd ⇒ cd ⊥ ab)

Lemma: geo-perp-symmetry2
∀e:BasicGeometry. ∀b,a,c,u:Point.  (ab ⊥ cu ⇒ ba ⊥ cu)

Lemma: geo-perp-in-iff
∀e:BasicGeometry. ∀a,b,c,d,x:Point.
  (a # b
  ⇒ c # d
  ⇒ (ab  ⊥x cd
     ⇐⇒ Colinear(a;b;x) ∧ Colinear(c;d;x) ∧ (∃u,v:Point. (Colinear(a;b;u) ∧ Colinear(c;d;v) ∧ u # x ∧ v # x ∧ Ruxv))))

Lemma: geo-perp-in-iff2
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ c # d ⇒ (ab  ⊥c cd ⇐⇒ Colinear(a;b;c) ∧ Racd ∧ Rbcd))

Lemma: geo-perp-in-unicity1
∀e:BasicGeometry. ∀x,a,b,c:Point.  (ba  ⊥x ca ⇒ x ≡ a)

Lemma: geo-perp-in-unicity2
∀e:BasicGeometry. ∀a,b,c:Point.
  ((¬Colinear(a;b;c))
  ⇒ (∀d,x:Point.  (c # d ⇒ ab  ⊥x cd ⇒ (∀y:Point. (Colinear(a;b;y) ⇒ Colinear(c;d;y) ⇒ x ≡ y)))))

Lemma: geo-perp-in-same-colinear
∀[e:BasicGeometry]. ∀[a,b,c,d,x:Point].  (Colinear(x;c;d)) supposing (ab  ⊥x xc and ab  ⊥x xd)

Lemma: geo-perp-irrefl
∀[e:BasicGeometry]. ∀[a,b:Point].  (ab ⊥ ab ⇒ a ≡ b)

Lemma: perp-col
∀e:BasicGeometry. ∀a,b,c,d,x,y:Point.  (a # b ⇒ ab  ⊥x cd ⇒ x # y ⇒ Colinear(a;b;x) ⇒ Colinear(a;b;y) ⇒ cd  ⊥x xy)

Lemma: geo-perp-colinear
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.  (b # a ⇒ c # b ⇒ Colinear(a;b;c) ⇒ bc ⊥ xy ⇒ ab ⊥ xy)

Lemma: geo-perp-trivial-when-colinear
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (b # a ⇒ Colinear(a;b;c) ⇒ ab  ⊥d dc ⇒ d ≡ c)

Lemma: geo-perp-midsegments
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ (∀c',d,p:Point.  (c'=p=d ⇒ c'=a=c ⇒ d=b=c ⇒ Rbap)))

Lemma: geo-perp-unicity
∀e:BasicGeometry. ∀a,b,c,u,v:Point.  (a # b ⇒ Colinear(a;b;u) ⇒ Colinear(a;b;v) ⇒ ab ⊥ cu ⇒ ab ⊥ cv ⇒ u ≡ v)

Lemma: geo-midpoint-implies-between
∀e:BasicGeometry. ∀a,b,m:Point.  (a # b ⇒ a=m=b ⇒ a-m-b)

Lemma: p8geo
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  ((Triangle(a;b;c) ∧ Triangle(x;y;z)) ⇒ Cong3(abc,xyz) ⇒ (abc ≅a xyz ∧ bac ≅a yxz ∧ bca ≅a yzx))

Lemma: geo-sas
∀e:BasicGeometry. ∀a,b,c,A,B,C:Point.
  (bc ≅ BC) supposing (((ab ≅ AB ∧ ac ≅ AC) ∧ bac ≅a BAC) and (Triangle(a;b;c) ∧ Triangle(A;B;C)))

Lemma: geo-sas2
∀e:BasicGeometry. ∀a,b,c,A,B,C:Point.  bc ≅ BC supposing (ab ≅ AB ∧ ac ≅ AC) ∧ bac ≅a BAC

Lemma: geo-reflected-right-triangles-congruent
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # bc ⇒ Rcba ⇒ a=b=d ⇒ Cong3(abc,dbc))

Lemma: p5geo
∀e:BasicGeometry. ∀a,b,c:Point.  ((ab ≅ ac ∧ Triangle(a;b;c)) ⇒ (∃j,k:Point. (jbc ≅a kcb ∧ B(abj) ∧ B(ack))))

Lemma: p4geo
∀e:BasicGeometry. ∀a,b,c,A,B,C:Point.
  ((Triangle(a;b;c) ∧ Triangle(A;B;C))
  ⇒ (ab ≅ AB ∧ ac ≅ AC ∧ bac ≅a BAC)
  ⇒ (bc ≅ BC ∧ abc ≅a ABC ∧ bca ≅a BCA ∧ Cong3(abc,ABC)))

Lemma: cong-angle-out-exists1
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.  (abc ≅a xyz ⇒ (∃x',z':Point. (out(y x'x) ∧ out(y z'z) ∧ Cong3(x'yz',abc))))

Lemma: cong-angle-out-exists
∀g:EuclideanPlane. ∀a,b,c,x,y,z,a',c',p:Point.
  (abc ≅a xyz
  ⇒ a # b
  ⇒ c # b
  ⇒ p # b
  ⇒ x # y
  ⇒ z # y
  ⇒ ((out(b aa') ∧ out(b cc')) ∧ a'-p-c')
  ⇒ (∃x',z',p':Point
       (((x'-p'-z' ∧ Cong3(a'bc',x'yz')) ∧ out(y xx') ∧ out(y zz'))
       ∧ (x'p' ≅ a'p ∧ p'z' ≅ pc')
       ∧ bp ≅ yp'
       ∧ x'yp' ≅a a'bp)))

Lemma: geo-out-preserves-opp-side-case1
∀e:BasicGeometry. ∀p,q,a,b,c,r,m:Point.
  (p # q ⇒ a-pq-c ⇒ Colinear(p;q;m) ⇒ a=m=c ⇒ Colinear(p;q;r) ⇒ B(rba) ⇒ r # b ⇒ b-pq-c)

Lemma: geo-out-preserves-opp-side
∀e:BasicGeometry. ∀p,q,a,b,c,r,m:Point.
  (p # q ⇒ a-pq-c ⇒ Colinear(p;q;m) ⇒ a=m=c ⇒ Colinear(p;q;r) ⇒ out(r ab) ⇒ b-pq-c)

Lemma: geo-le-pt-exists
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ ab≤cd ⇒ (∃x:Point. (B(abx) ∧ ax ≅ cd)))

Lemma: le-if-point-be-end
∀e:BasicGeometry. ∀a,b,c,d,x:Point.  (a # b ⇒ B(abx) ⇒ ax ≅ cd ⇒ ab≤cd)

Lemma: geo-le-pt-functionality
∀e:BasicGeometry. ∀a,b,c,d,a',b',c',d':Point.  (a # b ⇒ ab≤cd ⇒ ab ≅ a'b' ⇒ cd ≅ c'd' ⇒ a'b'≤c'd')

Lemma: geo-le-pt-reflexivity
∀e:BasicGeometry. ∀a,b:Point.  ab≤ab

Lemma: geo-le-pt-transitivity
∀e:BasicGeometry. ∀a,b,c,d,c',d':Point.  (a # b ⇒ ab≤cd ⇒ cd≤c'd' ⇒ ab≤c'd')

Lemma: geo-le-pt-switch-congruence
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ ab≤cd ⇒ cd≤ab ⇒ ab ≅ cd)

Lemma: geo-le-pt-from-cong
∀e:BasicGeometry. ∀a,b,c,d:Point.  (ab ≅ cd ⇒ ab≤cd)

Lemma: geo-le-pt-comm
∀e:BasicGeometry. ∀a,b:Point.  ab≤ba

Lemma: geo-le-pt-right-comm
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # b ⇒ ab≤cd ⇒ ab≤dc)

Lemma: geo-be-neq
∀e:BasicGeometry. ∀a,b,c:Point.  (a # b ⇒ B(abc) ⇒ a # c)

Lemma: cong-angle-out-exists-iff
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  ((((b # a ∧ b # c) ∧ y # x) ∧ y # z)
  ⇒ (abc ≅a xyz ⇐⇒ ∃a',c',x',z':Point. ((((out(b a'a) ∧ out(b c'c)) ∧ out(y x'x)) ∧ out(y z'z)) ∧ a'bc' ≅a x'yz')))

Lemma: cong-angle-out-all-iff
∀e:BasicGeometry. ∀a,b,c,x,y,z:Point.
  ((((b # a ∧ b # c) ∧ y # x) ∧ y # z)
  ⇒ (abc ≅a xyz
     ⇐⇒ ∀a',c',x',z':Point.
           ((((out(b a'a) ∧ out(b c'c)) ∧ out(y x'x)) ∧ out(y z'z) ∧ ba' ≅ yx' ∧ bc' ≅ yz') ⇒ a'c' ≅ x'z')))

Lemma: supplementary-angles-preserve-congruence
∀g:EuclideanPlane. ∀a,b,c,d,e,f,a',d':Point.  (abc ≅a def ⇒ a-b-a' ⇒ d-e-d' ⇒ a'bc ≅a d'ef)

Lemma: vertical-angles-congruent
∀e:EuclideanPlane. ∀a,b,c,a',c':Point.  (a-b-a' ⇒ c-b-c' ⇒ abc ≅a a'bc')

Lemma: between-preserves-left-1
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ B(ABV) ⇒ C leftof AV)

Lemma: between-preserves-left-2
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ A # V ⇒ B(AVB) ⇒ C leftof AV)

Lemma: between-preserves-left-3
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ A # V ⇒ B(VAB) ⇒ C leftof VA)

Lemma: between-preserves-left-4
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ A-B-V ⇒ C leftof BV)

Lemma: between-preserves-left-5
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ B # V ⇒ B(AVB) ⇒ C leftof VB)

Lemma: between-preserves-left-6
∀e:EuclideanPlane. ∀A,B,C,V:Point.  (C leftof AB ⇒ B # V ⇒ B(VAB) ⇒ C leftof VB)

Lemma: geo-colinear-left-out3
∀e:EuclideanPlane. ∀a,b,c,a',c',x,x':Point.
  (Colinear(b;x;x') ⇒ a-x-c ⇒ a'-x'-c' ⇒ out(b aa') ⇒ out(b cc') ⇒ b leftof ac ⇒ b leftof a'c' ⇒ out(b xx'))

Lemma: geo-length-property
∀g:EuclideanPlane. ∀a,b:Point.  ab ≅ X|ab|

Lemma: geo-add-length-property1
∀g:EuclideanPlane. ∀s1,s2:geo-segment(g).  B(X|s1||s1| + |s2|)

Lemma: geo-add-length-property2
∀g:EuclideanPlane. ∀s:geo-segment(g). ∀c,d:Point.  cd ≅ |s||s| + |cd|

Lemma: geo-add-length-property3
∀g:EuclideanPlane. ∀p,q:{p:Point| B(OXp)} .  (B(Xpq) ⇒ p + |pq| ≡ q)

Lemma: geo-le-iff-between-points
∀g:EuclideanPlane. ∀p,q:{p:Point| B(OXp)} .  (p ≤ q ⇐⇒ B(Xpq))

Lemma: geo-le-iff-between
∀g:EuclideanPlane. ∀s1,s2:geo-segment(g).  (|s1| ≤ |s2| ⇐⇒ B(X|s1||s2|))

Lemma: geo-lt-iff-strict-between-points
∀g:EuclideanPlane. ∀p,q:{p:Point| B(OXp)} .  (p < q ⇐⇒ p ≤ q ∧ p # q)

Lemma: geo-lt-iff-strict-between
∀g:EuclideanPlane. ∀s1,s2:geo-segment(g).  (|s1| < |s2| ⇐⇒ B(X|s1||s2|) ∧ |s1| # |s2|)

Lemma: geo-lt-add1
∀e:BasicGeometry. ∀p,q:{a:Point| B(OXa)} . ∀r:{a:Point| B(OXa) ∧ (|Xa| = p + q ∈ Length)} .  (X # p ⇒ X # q ⇒ p < r)

Lemma: geo-lt-add1_1
∀e:BasicGeometry. ∀p,q,r:Length.  (p < q ⇒ p < q + r)

Lemma: geo-le_antisymmetry
∀e:BasicGeometry. ∀[p,q:Length].  (p = q ∈ Length) supposing (q ≤ p and p ≤ q)

Lemma: geo-lt-add1_2
∀e:BasicGeometry. ∀p,q,r:{a:Point| B(OXa)} .  (X # p ⇒ X # q ⇒ X # r ⇒ p < q ⇒ p + r < q + r)

Lemma: geo-lt-add1-iff
∀e:BasicGeometry. ∀p,q,r:{a:Point| B(OXa)} .  (X # p ⇒ X # q ⇒ X # r ⇒ (p < q ⇐⇒ p + r < q + r))

Lemma: geo-lt-add1-iff2
∀e:BasicGeometry. ∀a1,a2,b1,b2,c1,c2:Point.  (|a1a2| < |b1b2| ⇐⇒ |a1a2| + |c1c2| < |b1b2| + |c1c2|)

Lemma: geo-le-congruent
∀g:BasicGeometry. ∀a,b,c,d:Point.  ((|ab| ≤ |cd| ∧ |cd| ≤ |ab|) ⇒ ab ≅ cd)

Lemma: geo-lt-implies-gt-strong-1
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (|cd| < |ab| ⇒ (∃w:Point. (B(awb) ∧ aw ≅ cd ∧ w # b)))

Lemma: geo-lt-implies-gt-strong
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (|cd| < |ab| ⇒ ab > cd)

Lemma: not-gt-and-lt
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ |ab| < |cd| ⇒ False)

Lemma: geo-lt-implies-point
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (|ab| < |cd| ⇒ a # b ⇒ (∃f:Point. (a-b-f ∧ af ≅ cd)))

Lemma: geo-ge-cases
∀e:BasicGeometry. ∀a,b,c,d:Point.  (¬¬((ab > cd ∨ cd > ab) ∨ ab ≅ cd))

Lemma: not-geo-lt-points
∀g:EuclideanPlane. ∀p,q:{p:Point| B(OXp)} .  (¬p < q ⇐⇒ q ≤ p)

Lemma: not-geo-lt
∀g:EuclideanPlane. ∀p,q:Length.  (¬p < q ⇐⇒ q ≤ p)

Lemma: geo-sep-iff-or-lt
∀e:BasicGeometry. ∀x,y:{p:Point| B(OXp)} .  (x # y ⇐⇒ x < y ∨ y < x)

Lemma: geo-zero-point-sep-iff-sep
∀e:BasicGeometry. ∀a,b:Point.  (X # |ab| ⇐⇒ a # b)

Lemma: not-lt-or
∀g:EuclideanPlane. ∀p,q:Length.  (¬¬(p < q ∨ q < p ∨ (p = q ∈ Length)))

Lemma: geo-add-length-lt-sep
∀e:BasicGeometry. ∀a,b,c,d,g,h:Point.  (|ab| < |cd| + |gh| ⇒ (c # d ∨ g # h))

Lemma: geo-add-length-lt-sep2
∀e:BasicGeometry. ∀a,b,c,d,g,h:Point.  (|ab| < |cd| + |gh| ⇒ |ab| # |cd| + |gh|)

Lemma: geo-add-length-lt-cancel-for-double
∀e:EuclideanPlane. ∀a,b:{a:Point| B(OXa)} .  (a + a < b + b ⇒ a < b)

Lemma: geo-triangle-inequality-lt-sep
∀e:BasicGeometry. ∀a,b,c,d,g,h:Point.
  (|ab| < |gh| + |cd| ⇒ |cd| < |ab| + |gh| ⇒ |gh| < |cd| + |ab| ⇒ ((a # b ∧ g # h) ∧ c # d))

Lemma: geo-length-between-property
∀e:BasicGeometry. ∀p,q:{p:Point| B(OXp)} . ∀a,b,c,d:Point.
  (B(Xpq) ⇒ (p = |ab| ∈ Length) ⇒ (q = |cd| ∈ Length) ⇒ B(X|ab||cd|))

Lemma: geo-gt-prim-implies-le
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab>cd ⇒ |cd| ≤ |ab|)

Lemma: geo-gt-prim-implies-lt
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab>cd ⇒ |cd| < |ab|)

Lemma: geo-gt-prim-iff-lt
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab>cd ⇐⇒ |cd| < |ab|)

Lemma: geo-gt-not-congruent
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (ab > cd ⇒ (¬ab ≅ cd))

Lemma: geo-SS_functionality
∀[g:EuclideanPlane]. ∀[a,b:Point]. ∀[u:{u:Point| u leftof ab} ]. ∀[v:{v:Point| v leftof ba} ]. ∀[a',b':Point].
∀[u':{u:Point| u leftof a'b'} ]. ∀[v':{v:Point| v leftof b'a'} ].
  (geo-SS(g;a;b;u;v) ≡ geo-SS(g;a';b';u';v')) supposing (v ≡ v' and u ≡ u' and b ≡ b' and a ≡ a')

Lemma: left-between-triangle
∀e:EuclideanPlane. ∀a,x,y,p:Point.  (a leftof xy ⇒ x-p-a ⇒ a leftof py)

Lemma: left-between-triangle2
∀e:EuclideanPlane. ∀a,x,y,p:Point.  (a leftof yx ⇒ x-p-a ⇒ a leftof yp)

Lemma: plane-sep-imp-Opasch_left
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| B(abc)} . ∀x:Point. ∀y:{y:Point| b-x-y} .
  (x leftof ab ⇒ (∃p:Point [(B(axp) ∧ B(cpy))]))

Lemma: outer-Pasch
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| B(abc)} . ∀x:Point. ∀y:{y:Point| b-x-y} .
  (x # ab ⇒ (∃p:Point [(B(axp) ∧ B(cpy))]))

Lemma: outer-Pasch-ext
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| B(abc)} . ∀x:Point. ∀y:{y:Point| b-x-y} .
  (x # ab ⇒ (∃p:Point [(B(axp) ∧ B(cpy))]))

Lemma: full-Pasch-lemma
∀e:EuclideanPlane. ∀a,x,y,d,p:Point.
  ((((d leftof xa ∧ x-p-a) ∧ d # py) ∧ a leftof xy) ⇒ (∃p':Point. ((x-p'-y ∨ a-p'-y) ∧ Colinear(d;p;p'))))

Lemma: full-Pasch
∀e:EuclideanPlane. ∀a,x,y,d,p:Point.
  ((((d # xa ∧ x-p-a) ∧ d # py) ∧ a leftof xy) ⇒ (∃p':Point. ((x-p'-y ∨ a-p'-y) ∧ Colinear(d;p;p'))))

Lemma: right-angles-congruent-axiom_wf
∀[g:BasicGeometry]. (right-angles-congruent-axiom(g) ∈ ℙ)

Lemma: geo-left-interiority
∀g:OrientedPlane. ∀a,b,c,p:Point.  (p leftof ab ⇒ p leftof bc ⇒ p leftof ca ⇒ (¬a leftof cb))

Lemma: left-transitivity
∀g:OrientedPlane. ∀a,b,x,y,z:Point.
  (x leftof ab ⇒ y leftof ab ⇒ z leftof ab ⇒ y leftof ax ⇒ z leftof ay ⇒ (¬z leftof xa))

Definition: geo-convex
IsConvex(x.P[x]) ==  ∀x,y,z:Point.  (B(xyz) ⇒ P[x] ⇒ P[z] ⇒ P[y])

Lemma: geo-convex_wf
∀[g:BasicGeometry-]. ∀[P:Point ⟶ ℙ].  (IsConvex(x.P[x]) ∈ ℙ)

Lemma: geo-convex-intersection
∀[g:BasicGeometry]. ∀[T:Type].  ∀P:T ⟶ Point ⟶ ℙ. ((∀t:T. IsConvex(x.P[t;x])) ⇒ IsConvex(x.∀t:T. P[t;x]))

Lemma: oriented-plane-axioms
∀g:OrientedPlane. ∀P:OrientedPlane ⟶ ℙ.
  ((∀g:OrientedPlane. (BasicGeometryAxioms(g) ⇒ geo-left-axioms(g) ⇒ P[g])) ⇒ P[g])

Lemma: geo-left-convex
∀g:OrientedPlane. ∀a,b:Point.  IsConvex(x.x leftof ab)

Lemma: geo-left-antisymmetry
∀g:OrientedPlane. ∀a,b,c:Point.  (a leftof bc ⇒ (¬a leftof cb))

Lemma: geo-left-transitivity
∀g:OrientedPlane. ∀t,s,p,q,r:Point.
  (p leftof ts ⇒ q leftof ts ⇒ r leftof ts ⇒ q leftof tp ⇒ r leftof tq ⇒ (¬r leftof pt))

Lemma: geo-not-left-convex
∀g:OrientedPlane. ∀a,b:Point.  IsConvex(x.¬x leftof ab)

Definition: geo-orientation
geo-orientation(g;a;b;c) ==  g."Lorsquashstable" a b c ⋅

Lemma: geo-orientation_wf
∀[g:EuclideanPlaneStructure]. ∀[a,b:Point]. ∀[c:{c:Point| a # bc} ].
  (geo-orientation(g;a;b;c) ∈ a leftof bc ∨ a leftof cb)

Definition: geo-isleft
isleft(a;b;c) ==  isl(geo-orientation(g;a;b;c))

Lemma: geo-isleft_wf
∀[g:EuclideanPlaneStructure]. ∀[a,b:Point]. ∀[c:{c:Point| a # bc} ].  (isleft(a;b;c) ∈ 𝔹)

Lemma: assert-geo-isleft
∀g:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| a # bc} .  (↑isleft(a;b;c) ⇐⇒ a leftof bc)

Lemma: bnot-isleft
∀g:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| a # bc} .  ¬bisleft(a;b;c) = isleft(a;c;b)

Lemma: isleft-symmetry
∀g:OrientedPlane. ∀a,b:Point. ∀c:{c:Point| a # bc} .  isleft(a;b;c) = isleft(b;c;a)

Definition: geo-general-position
geo-general-position(g;xs) ==  ∀k:ℕ||xs||. ∀j:ℕk. ∀i:ℕj.  xs[k] # xs[i]xs[j]

Lemma: geo-general-position_wf
∀[g:OrientedPlane]. ∀[xs:Point List].  (geo-general-position(g;xs) ∈ ℙ)

Lemma: geo-general-position-implies
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j,k:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ (¬(k = i ∈ ℤ)) ⇒ (¬(k = j ∈ ℤ)) ⇒ xs[i] # xs[j]xs[k])

Definition: left-test
i L jk ==  isleft(xs[i];xs[j];xs[k])

Lemma: left-test_wf
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i:ℕ||xs||]. ∀[j:{j:ℕ||xs||| ¬(i = j ∈ ℤ)} ].
∀[k:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} ].
  (i L jk ∈ 𝔹)

Lemma: assert-left-test
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i:ℕ||xs||. ∀j:{j:ℕ||xs||| ¬(i = j ∈ ℤ)} .
∀k:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} .
  (↑i L jk ⇐⇒ xs[i] leftof xs[j]xs[k])

Lemma: left-test-symmetry
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i:ℕ||xs||. ∀j:{j:ℕ||xs||| ¬(i = j ∈ ℤ)} .
∀k:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} .
  i L jk = j L ki

Lemma: bnot-left-test
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i:ℕ||xs||. ∀j:{j:ℕ||xs||| ¬(i = j ∈ ℤ)} .
∀k:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} .
  ¬bi L jk = i L kj

Definition: in-hull
ij ∈ Hull(xs) ==  ∀k:ℕ||xs||. ((¬(k = i ∈ ℤ)) ⇒ (¬(k = j ∈ ℤ)) ⇒ (↑k L ij))

Lemma: in-hull_wf
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i,j:ℕ||xs||].
  ij ∈ Hull(xs) ∈ ℙ supposing ¬(i = j ∈ ℤ)

Lemma: in-hull-unique1
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i,j,k:ℕ||xs||].
  (j = k ∈ ℤ) supposing (ik ∈ Hull(xs) and (¬(i = k ∈ ℤ)) and ij ∈ Hull(xs) and (¬(i = j ∈ ℤ)))

Lemma: in-hull-unique2
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i,j,k:ℕ||xs||].
  (j = k ∈ ℤ) supposing (ki ∈ Hull(xs) and (¬(k = i ∈ ℤ)) and ji ∈ Hull(xs) and (¬(j = i ∈ ℤ)))

Lemma: in-hull-unique3
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i,j,k:ℕ||xs||].
  ((((((¬(j = k ∈ ℤ)) ∧ (¬(j = i ∈ ℤ))) ∧ (¬(k = i ∈ ℤ))) ∧ jk ∈ Hull(xs)) ∧ ji ∈ Hull(xs)) ⇒ False)

Lemma: in-hull-transitivity
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ ij ∈ Hull(xs) ⇒ Trans({k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} ;x,y.(¬(x = y ∈ ℤ)) ∧ (↑x L iy)\000C))

Definition: find-hull
find-hull(g;xs) ==
  let L ⟵ [2, ||xs||)
  in eager-accum(hs,k.let p,q = find_transitions(λx,y. k L xy;hs) 
                      in if isl(p) ∧b isl(q)
                         then hs
                         else eval x = outr(p) in
                              eval y = outr(q) in
                                if x <z y
                                then let as ⟵ firstn(x + 1;hs)
                                     in let bs ⟵ nth_tl(y;hs)
                                        in as @ [k / bs]
                                else let as ⟵ firstn((x - y) + 1;nth_tl(y;hs))
                                     in [k / as]
                                fi 
                         fi ;[0; 1];L)

Definition: hull-cmp
hull-cmp(g;xs;i;j) ==  λx,y. if (x =z y) then 0 if y L ix then 1 else -1 fi 

Lemma: hull-cmp_wf
∀[g:OrientedPlane]. ∀[xs:{xs:Point List| geo-general-position(g;xs)} ]. ∀[i,j:ℕ||xs||].
  (hull-cmp(g;xs;i;j) ∈ comparison({k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} )) supposing (ij ∈ Hull(xs) and (¬(i = j\000C ∈ ℤ)))

Lemma: in-hull-leftmost
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} .
  (2 < ||xs||
  ⇒ (∀i,j:ℕ||xs||.
        ((¬(i = j ∈ ℤ))
        ⇒ ij ∈ Hull(xs)
        ⇒ (∃x:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} 
             ∀y:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} . ((¬(x = y ∈ ℤ)) ⇒ (↑x L iy))))))

Lemma: in-hull-sorted
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ))
  ⇒ ij ∈ Hull(xs)
  ⇒ (∃ps:{k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))}  List
       (permutation({k:ℕ||xs||| (¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))} ;ps;
                    filter(λk.((¬b(k =z i)) ∧b (¬b(k =z j)));upto(||xs||)))
       ∧ sorted-by(λx,y. ((¬(x = y ∈ ℤ)) ⇒ (↑x L yi));ps))))

Lemma: in-hull-next
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ ij ∈ Hull(xs) ⇒ (∃k:ℕ||xs||. ((¬(k = i ∈ ℤ)) ∧ ki ∈ Hull(xs))))

Lemma: in-hull-unique-next
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ ij ∈ Hull(xs) ⇒ (∃!k:ℕ||xs||. ((¬(k = i ∈ ℤ)) ∧ ki ∈ Hull(xs))))

Lemma: in-hull-next2
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ (ij ∈ Hull(xs) ∧ 2 < ||xs||) ⇒ (∃k:ℕ||xs||. (((¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))) ∧ ki ∈ Hull(xs))))

Lemma: in-hull-unique-next2
∀g:OrientedPlane. ∀xs:{xs:Point List| geo-general-position(g;xs)} . ∀i,j:ℕ||xs||.
  ((¬(i = j ∈ ℤ)) ⇒ (ij ∈ Hull(xs) ∧ 2 < ||xs||) ⇒ (∃!k:ℕ||xs||. (((¬(k = i ∈ ℤ)) ∧ (¬(k = j ∈ ℤ))) ∧ ki ∈ Hull(xs))))

Lemma: Euclid-midpoint-1
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃d:Point [a=d=b])

Definition: midpoint-construction
Mid(a;b) ==  geo-SS(e;b;a;CC(b;a;a;b);CC(a;b;b;a))

Lemma: midpoint-construction_wf
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (Mid(a;b) ∈ {d:Point| a=d=b} )

Lemma: Euclid-midpoint
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃d:Point [a=d=b])

Lemma: segment-density
∀e:EuclideanPlane. ∀a,b:Point.  ∃x:Point. B(axb)

Lemma: Euclid-Prop10
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃d:Point [(a-d-b ∧ ad ≅ db)])

Lemma: Euclid-Prop10-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃d:Point [(a-d-b ∧ ad ≅ db)])

Lemma: segment-density-strict
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} .  (∃x:Point [a-x-b])

Definition: geo-isosceles
ISOΔ(a;b;c) ==  (ab ≅ ac ∧ abc ≅a acb) ∧ a # bc

Lemma: geo-isosceles_wf
∀[g1:EuclideanPlane]. ∀[a,b,c:Point].  (ISOΔ(a;b;c) ∈ ℙ)

Lemma: Euclid-Prop9
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| c # ba} .  ∃f:Point. acf ≅a bcf

Lemma: Euclid-Prop9-ext
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| c # ba} .  ∃f:Point. acf ≅a bcf

Lemma: euclid-Prop3
∀e:EuclideanPlane. ∀A:Point. ∀B:{B:Point| A # B} . ∀C1:Point. ∀C2:{C2:Point| C1 # C2} .
  (|C1C2| < |AB| ⇒ (∃E:Point [(B(AEB) ∧ AE ≅ C1C2)]))

Lemma: euclid-Prop3-ext
∀e:EuclideanPlane. ∀A:Point. ∀B:{B:Point| A # B} . ∀C1:Point. ∀C2:{C2:Point| C1 # C2} .
  (|C1C2| < |AB| ⇒ (∃E:Point [(B(AEB) ∧ AE ≅ C1C2)]))

Lemma: Euclid-Prop4
∀e:EuclideanPlane. ∀a,b,c,A,B,C:Point.
  ((Triangle(a;b;c) ∧ Triangle(A;B;C))
  ⇒ (ab ≅ AB ∧ ac ≅ AC ∧ bac ≅a BAC)
  ⇒ (bc ≅ BC ∧ abc ≅a ABC ∧ bca ≅a BCA ∧ Cong3(abc,ABC)))

Lemma: Euclid-Prop5_1
∀e:EuclideanPlane. ∀a,b,c:Point.  ((ab ≅ ac ∧ Triangle(a;b;c)) ⇒ abc ≅a acb)

Lemma: Euclid-Prop5_1-not-tri
∀e:EuclideanPlane. ∀a,b,c:Point.  (b # c ⇒ ab ≅ ac ⇒ abc ≅a acb)

Lemma: Euclid-Prop5_2
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.  ((ISOΔ(a;b;c) ∧ a-b-x ∧ a-c-y) ⇒ xbc ≅a ycb)

Lemma: Euclid-Prop5
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.  (((ab ≅ ac ∧ a # bc) ∧ a-b-x ∧ a-c-y) ⇒ (abc ≅a acb ∧ xbc ≅a ycb))

Lemma: colinear-equidistant-points-exist
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.
  ∃u,v:Point. (Colinear(a;b;u) ∧ Colinear(a;b;v) ∧ u # v ∧ cu ≅ cv)

Lemma: lsep-iff-all-sep
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇐⇒ (∀x:Point. (Colinear(x;b;c) ⇒ a # x)) ∧ b # c)

Lemma: sep-if-all-lsep
∀g:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ (∀x:Point. (Colinear(x;b;c) ⇒ a # x)))

Lemma: congruence-preserves-lsep
∀g:EuclideanPlane. ∀a,b,c,A,B,C:Point.  (ab ≅ AB ⇒ ac ≅ AC ⇒ bc ≅ BC ⇒ c # ab ⇒ (¬¬C # AB))

Lemma: lsep-colinear
∀g:EuclideanPlane. ∀p,a,b,x,y:Point.  (p # ab ⇒ x # y ⇒ Colinear(x;a;b) ⇒ Colinear(y;a;b) ⇒ p # xy)

Lemma: out-preserves-lsep
∀g:EuclideanPlane. ∀a,b,c,b',c':Point.  (a # bc ⇒ out(a bb') ⇒ out(a cc') ⇒ a # b'c')

Lemma: Euclid-erect-2perp
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| Colinear(a;b;c)} .
  ∃q:Point. (∃p:Point [(ab  ⊥c pc ∧ ab  ⊥c qc ∧ p leftof ab ∧ q leftof ba)])

Lemma: Euclid-erect-perp-on-same-side
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| Colinear(a;b;c)} . ∀q:{q:Point| q # ab} .
  (∃p:Point [(ab  ⊥c pc ∧ p # ab ∧ (p leftof ab ⇐⇒ q leftof ab))])

Lemma: Euclid-erect-perp
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| Colinear(a;b;c)} .  (∃p:Point [(ab  ⊥c pc ∧ p # ab)])

Lemma: Euclid-erect-perp-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| Colinear(a;b;c)} .  (∃p:Point [(ab  ⊥c pc ∧ p # ab)])

Lemma: isosceles-sep-implies-lsep
∀e:EuclideanPlane. ∀a,b,x:Point.  (xa ≅ xb ⇒ a # b ⇒ (∀m:{m:Point| a=m=b} . m # x) ⇒ x # ab)

Lemma: midpoint-of-equidistant-points-is-perp
∀e:EuclideanPlane. ∀u:Point. ∀v:{v:Point| u # v} . ∀c:{c:Point| c # uv} .  (cu ≅ cv ⇒ (∀m:Point. (u=m=v ⇒ uv  ⊥m mc)))

Lemma: no-three-colinear-on-circle
∀[e:EuclideanPlane]. ∀[a:Point]. ∀[b:{b:Point| b # a} ]. ∀[c:{c:Point| c # a ∧ c # b ∧ Colinear(a;b;c)} ].
  ∀p:Point. (¬(pa ≅ pb ∧ pb ≅ pc))

Lemma: Euclid-drop-perp-0
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.
  ∃x:Point. (∃p:Point [(Colinear(p;x;c) ∧ ab  ⊥p px ∧ x # ab ∧ x # c)])

Lemma: Euclid-drop-perp-0-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.
  ∃x:Point. (∃p:Point [(Colinear(p;x;c) ∧ ab  ⊥p px ∧ x # ab ∧ x # c)])

Lemma: Euclid-drop-perp-00
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  ∃x,p:Point. (Colinear(p;x;c) ∧ ab  ⊥p px ∧ x # ab ∧ x # c)

Lemma: Euclid-drop-perp-1
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| ∀x:Point. (Colinear(a;b;x) ⇒ c # x)} .
  ∃p:Point. (Colinear(a;b;p) ∧ ab  ⊥p pc)

Lemma: Euclid-drop-perp
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| c # ab} .  (∃p:Point [(Colinear(a;b;p) ∧ ab  ⊥p pc)])

Lemma: Euclid-drop-perp-ext
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀c:{c:Point| c # ab} .  (∃p:Point [(Colinear(a;b;p) ∧ ab  ⊥p pc)])

Lemma: circle-not-colinear
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab ≅ ac ⇒ ab ≅ ad ⇒ b # c ⇒ c # d ⇒ d # b ⇒ (¬Colinear(b;c;d)))

Definition: circle-circumscription
circle-circumscription(e) ==  ∀a,b,c:Point.  (b # ac ⇒ (∃m:Point. (am ≅ bm ∧ bm ≅ cm)))

Lemma: circle-circumscription_wf
∀[e:GeometryPrimitives]. (circle-circumscription(e) ∈ ℙ)

Definition: euclid5
euclid5(e) ==
  ∀P,Q,R,S,T,U:Point.  (P-T-Q ⇒ R-T-S ⇒ Q-U-R ⇒ P # QS ⇒ PT ≅ QT ⇒ RT ≅ ST ⇒ (∃I:Point. (S-Q-I ∧ P-U-I)))

Lemma: euclid5_wf
∀[e:BasicGeometry]. (euclid5(e) ∈ ℙ)

Definition: geo-intersect-points
ab \/ cd ==  a # b ∧ (∃x,y:{z:Point| Colinear(z;a;b)} . (x leftof cd ∧ y leftof dc))

Lemma: geo-intersect-points_wf
∀e:GeometryPrimitives. ∀a,b,c,d:Point.  (ab \/ cd ∈ ℙ)

Lemma: geo-intersect-points-iff
∀e:EuclideanPlane. ∀a,b,c,d:Point.
  (ab \/ cd
  ⇐⇒ a # b
      ∧ c # d
      ∧ (∃a1,b1,c1,d1,v:Point
          (a1-v-b1
          ∧ c1-v-d1
          ∧ Colinear(a1;a;b)
          ∧ Colinear(b1;a;b)
          ∧ Colinear(c1;c;d)
          ∧ Colinear(d1;c;d)
          ∧ a1 leftof c1d1
          ∧ b1 leftof d1c1)))

Lemma: geo-intersect-points-iff2
∀e:EuclideanPlane. ∀p1,p2,l1,l2:Point.
  (p1p2 \/ l1l2
  ⇐⇒ p1 # p2
      ∧ l1 # l2
      ∧ (∃a,b,c,d,v:Point
          (a-v-b
          ∧ c-v-d
          ∧ Colinear(a;p1;p2)
          ∧ Colinear(b;p1;p2)
          ∧ Colinear(c;l1;l2)
          ∧ Colinear(d;l1;l2)
          ∧ a leftof cd
          ∧ b leftof dc
          ∧ c leftof ba
          ∧ d leftof ab)))

Lemma: geo-intersect-points-symmetry
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (ab \/ cd ⇒ cd \/ ab)

Definition: geo-parallel-points
geo-parallel-points(e;a;b;c;d) ==  (a # b ∧ c # d) ∧ (¬(∃x,y:{z:Point| Colinear(z;a;b)} . (x leftof cd ∧ y leftof dc)))

Lemma: geo-parallel-points_wf
∀e:GeometryPrimitives. ∀a,b,c,d:Point.  (geo-parallel-points(e;a;b;c;d) ∈ ℙ)

Lemma: geo-parallel-not-intersect
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel-points(e;a;b;c;d) ⇒ (¬ab \/ cd))

Lemma: geo-parallel-iff-not-intersect
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel-points(e;a;b;c;d) ⇐⇒ (a # b ∧ c # d) ∧ (¬ab \/ cd))

Lemma: geo-parallel-points-implies
∀e:EuclideanPlane. ∀a,b,x,y:Point.
  (geo-parallel-points(e;a;b;x;y)
  ⇒ (a # b ∧ x # y)
  ⇒ (∀x1,y1:{z:Point| Colinear(z;a;b)} .  (x1 leftof xy ⇒ (¬y1 leftof yx))))

Lemma: geo-colinear-preserves-parallel
∀e:EuclideanPlane. ∀a,b,c,d,x:Point.
  (geo-parallel-points(e;a;b;c;d) ⇒ Colinear(a;b;x) ⇒ a # x ⇒ geo-parallel-points(e;a;x;c;d))

Lemma: geo-parallel-points-symmetry
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel-points(e;a;b;c;d) ⇒ geo-parallel-points(e;c;d;a;b))

Lemma: geo-parallel-points-symmetry2
∀e:EuclideanPlane. ∀a,b,c,d:Point.
  (geo-parallel-points(e;a;b;c;d)
  ⇒ (geo-parallel-points(e;b;a;c;d) ∧ geo-parallel-points(e;a;b;d;c) ∧ geo-parallel-points(e;b;a;d;c)))

Lemma: geo-colinear-preserves-parallel2
∀e:EuclideanPlane. ∀a,b,c,d,x,y:Point.
  (geo-parallel-points(e;a;b;c;d)
  ⇒ Colinear(a;b;x)
  ⇒ Colinear(c;d;y)
  ⇒ c # y
  ⇒ a # x
  ⇒ geo-parallel-points(e;a;x;c;y))

Definition: geo-parallel
geo-parallel(e;a;b;c;d) ==  (a # b ∧ c # d) ∧ (∀x:Point. (Colinear(a;b;x) ⇒ x # cd))

Lemma: geo-parallel_wf
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel(e;a;b;c;d) ∈ ℙ)

Lemma: geo-parallel_functionality
∀e:EuclideanPlane. ∀a,b,c,d,a',b',c',d':Point.
  (a ≡ a' ⇒ b ≡ b' ⇒ c ≡ c' ⇒ d ≡ d' ⇒ geo-parallel(e;a;b;c;d) ⇒ geo-parallel(e;a';b';c';d'))

Lemma: geo-parallel-right-comm
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel(e;a;b;c;d) ⇒ geo-parallel(e;a;b;d;c))

Lemma: geo-parallel-refl
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel(e;a;b;c;d) ⇒ geo-parallel(e;a;b;c;d))

Lemma: geo-parallel-lsep-opp
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel(e;a;b;c;d) ⇒ c # ab)

Lemma: geo-parallel-symmetry
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (geo-parallel(e;a;b;c;d) ⇒ geo-parallel(e;c;d;a;b))

Lemma: colinear-preserves-parallel
∀e:EuclideanPlane. ∀a,b,c,d,y:Point.  ((geo-parallel(e;a;b;c;d) ∧ Colinear(c;d;y) ∧ c # y) ⇒ geo-parallel(e;a;b;c;y))

Lemma: geo-parallel-strict
∀e:EuclideanPlane. ∀a,b:Point.  (geo-parallel(e;a;b;a;b) ⇒ False)

Definition: TarskiPP
TarskiPP(e) ==  ∀a,b,c,d,t:Point.  (((B(adt) ∧ B(bdc)) ∧ a # d) ⇒ (∃x,y:Point. ((B(abx) ∧ B(acy)) ∧ B(xty))))

Lemma: TarskiPP_wf
∀[e:GeometryPrimitives]. (TarskiPP(e) ∈ ℙ)

Definition: PlayfairPP
PlayfairPP(eu) ==
  ∀a0,a1,b0,b1,c0,c1,p:Point.
    ((geo-parallel-points(eu;a0;a1;b0;b1) ∧ geo-parallel-points(eu;a0;a1;c0;c1))
    ⇒ (Colinear(p;b0;b1) ∧ Colinear(p;c0;c1))
    ⇒ (Colinear(c0;b0;b1) ∧ Colinear(c1;b0;b1)))

Lemma: PlayfairPP_wf
∀[e:EuclideanPlane]. (PlayfairPP(e) ∈ ℙ)

Lemma: Euclid-Prop7
∀e:EuclideanPlane. ∀a,b:Point. ∀c,d:{p:Point| p leftof ab} .  (ac ≅ ad ⇒ bc ≅ bd ⇒ c ≡ d)

Lemma: Euclid-Prop7-aux
∀e:EuclideanPlane. ∀a,b:Point. ∀c,d:{p:Point| ¬p leftof ba} .  (a # b ⇒ ac ≅ ad ⇒ bc ≅ bd ⇒ c ≡ d)

Lemma: Euclid-Prop7'
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # b ⇒ ac ≅ ad ⇒ bc ≅ bd ⇒ (¬c leftof ba ⇐⇒ ¬d leftof ba) ⇒ c ≡ d)

Lemma: geo-CC_functionality
∀[g:EuclideanPlane]. ∀[a,b:Point]. ∀[c:{c:Point| a # c} ]. ∀[d:{d:Point| StrictOverlap(a;b;c;d)} ]. ∀[a',b':Point].
∀[c':{c':Point| a' # c'} ]. ∀[d':{d':Point| StrictOverlap(a';b';c';d')} ].
  (CC(a;b;c;d) ≡ CC(a';b';c';d')) supposing (d ≡ d' and c ≡ c' and b ≡ b' and a ≡ a')

Lemma: colinear-cong3
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.
  (a # b ⇒ Colinear(a;b;c) ⇒ ab ≅ xy ⇒ (∃z:Point. (Colinear(x;y;z) ∧ Cong3(abc,xyz))))

Lemma: half-plane-point-exists
∀g:EuclideanPlane. ∀x,y:Point.  (x # y ⇒ (∃q:Point. q leftof xy))

Lemma: zero-angles-congruent2
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (out(b ac) ⇒ out(y xz) ⇒ abc ≅a xyz)

Definition: geo-lt-angle
abc < xyz ==
  (¬out(y xz))
  ∧ (∃p,p',x',z':Point. (abc ≅a xyp ∧ B(yp'p) ∧ (out(y xx') ∧ out(y zz')) ∧ (¬B(xyp)) ∧ B(x'p'z') ∧ p' # z'))

Lemma: geo-lt-angle_wf
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc < xyz ∈ ℙ)

Lemma: not-lt-zero-angle
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc < xyz ⇒ (B(yzx) ∨ B(yxz)) ⇒ False)

Lemma: straight-angles-not-lt
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (a-b-c ⇒ x-y-z ⇒ (¬abc < xyz))

Lemma: lt-angle-not-cong
∀e:EuclideanPlane. ∀x,y,z:Point.  (¬xyz < xyz)

Lemma: cong-angle-out-exists-cong3
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (abc ≅a xyz ⇒ (∃a',c':Point. (out(b a'a) ∧ out(b c'c) ∧ a'bc' ≅a xyz ∧ Cong3(a'bc',xyz))))

Lemma: congruence-preserves-right-angle2
∀e:BasicGeometry. ∀a,b,c:Point.  (Rabc ⇒ (∀a',b',c':Point.  (abc ≅a a'b'c' ⇒ Ra'b'c')))

Lemma: lsep-cong-angle-implies-sep
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (a # bc ⇒ abc ≅a xyz ⇒ x # z)

Lemma: interior-point-preserves-cong-angle
∀g:EuclideanPlane. ∀a,b,c,x,y,z,p,q:Point.
  (abc ≅a xyz ⇒ B(aqc) ⇒ B(xpz) ⇒ Cong3(abc,xyz) ⇒ Cong3(aqc,xpz) ⇒ x # yz ⇒ abq ≅a xyp)

Lemma: interior-point-cong-angle-transfer
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.
  (abc < xyz
  ⇒ def ≅a xyz
  ⇒ (x # yz ∨ d # ef)
  ⇒ (∃p',d',f':Point. (d'ep' ≅a abc ∧ B(d'p'f') ∧ p' # f' ∧ out(e ff') ∧ out(e dd'))))

Lemma: interior-point-cong-angle-transfer-full
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.
  (abc < xyz
  ⇒ def ≅a xyz
  ⇒ d # ef
  ⇒ (∃p,p',d',f':Point. (d'ep ≅a abc ∧ B(d'p'f') ∧ p' # f' ∧ (out(e dd') ∧ out(e ff')) ∧ B(ep'p) ∧ (¬B(dep)))))

Lemma: geo-cong-angle-preserves-lt-angle2
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.  (def ≅a xyz ⇒ abc < xyz ⇒ d # ef ⇒ abc < def)

Lemma: interior-implies-lt-angle
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (x # yz ⇒ c leftof ba ⇒ (∃f:Point. ((f leftof ba ∧ f leftof cb) ∧ abf ≅a xyz)) ⇒ xyz < abc)

Lemma: Euclid-Prop6-lemma
∀e:EuclideanPlane. ∀a,b,c:Point.
  (cab ≅a cba
  ⇒ c # ab
  ⇒ (∃x:Point
       (Colinear(c;a;x) ∧ ax ≅ bc ∧ (c leftof ab ⇒ x leftof ab) ∧ (c leftof ba ⇒ x leftof ba) ∧ Cong3(axb,bca))))

Lemma: Euclid-Prop6
∀e:EuclideanPlane. ∀a,b,c:Point.  (c # ab ⇒ cab ≅a cba ⇒ ca ≅ cb)

Lemma: right-angle-SAS
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  ((Rabc ∧ a # b ∧ b # c) ⇒ (Rxyz ∧ x # y ∧ y # z) ⇒ ab ≅ xy ⇒ bc ≅ yz ⇒ ac ≅ xz)

Lemma: geo-right-angles-congruent
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (((Rabc ∧ Rxyz) ∧ (x # y ∧ y # z) ∧ a # b ∧ b # c) ⇒ abc ≅a xyz)

Lemma: adjacent-right-angles-supplementary
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (c-b-d ⇒ a # b ⇒ (Rabc ⇐⇒ abc ≅a abd))

Lemma: hypotenuse-leg-congruence
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (Rabc ⇒ Rxyz ⇒ ac ≅ xz ⇒ ab ≅ xy ⇒ a # b ⇒ x # y ⇒ b # c ⇒ y # z ⇒ bc ≅ yz)

Lemma: geo-reflected-right-triangles-congruent
∀e:BasicGeometry. ∀a,b,c,d:Point.  (a # bc ⇒ Rcba ⇒ a=b=d ⇒ Cong3(abc,dbc))

Lemma: cong3-in-half-plane
∀e:EuclideanPlane. ∀a,b,c,x,y,u:Point.
  (c # ab ⇒ u # xy ⇒ ab ≅ xy ⇒ (∃z:Point. (Cong3(abc,xyz) ∧ z # xy ∧ (u leftof xy ⇐⇒ z leftof xy))))

Lemma: unique-angles-in-half-plane
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (a # bc
  ⇒ x # yz
  ⇒ ((∃f:Point. (acb ≅a fzy ∧ (x leftof yz ⇐⇒ f leftof yz) ∧ (x leftof zy ⇐⇒ f leftof zy)))
     ∧ (∀f1,f2:Point.
          ((acb ≅a f1zy ∧ acb ≅a f2zy)
          ⇒ (((x leftof yz ⇐⇒ f1 leftof yz) ∧ (x leftof zy ⇐⇒ f1 leftof zy))
             ∧ (x leftof yz ⇐⇒ f2 leftof yz)
             ∧ (x leftof zy ⇐⇒ f2 leftof zy))
          ⇒ Colinear(z;f1;f2)))))

Lemma: unique-angles-in-half-plane-better
∀e:EuclideanPlane. ∀a,b,c,q:Point.  (a leftof bc ⇒ q leftof bc ⇒ qbc ≅a abc ⇒ out(b aq))

Lemma: unique-angles-in-half-plane-better2
∀e:EuclideanPlane. ∀a,b,c,q:Point.  (a leftof bc ⇒ q leftof bc ⇒ qcb ≅a acb ⇒ out(c aq))

Lemma: opp-side_half-plane-angle-congruence
∀e:EuclideanPlane. ∀b,p,b',p',a,c,a',c':Point.
  ((a leftof bp ∧ c leftof pb) ⇒ (a' leftof b'p' ∧ c' leftof p'b') ⇒ (abp ≅a a'b'p' ∧ pbc ≅a p'b'c') ⇒ abc ≅a a'b'c')

Lemma: adjacent-right-angles-supplementary-using-geom-tactic
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (c-b-d ⇒ a # b ⇒ (Rabc ⇐⇒ abc ≅a abd))

Lemma: congruent-half-plane-angles-implies-right-angles
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (c-b-d ⇒ a # cd ⇒ abc ≅a abd ⇒ {Rabd ∧ Rabc})

Lemma: straight-angles-congruent
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (a-b-c ⇒ x-y-z ⇒ abc ≅a xyz)

Lemma: Euclid-prop14
∀g:EuclideanPlane. ∀a,b,x,y:Point.  (a # b ⇒ x leftof ab ⇒ y leftof ba ⇒ Rxba ⇒ Ryba ⇒ Colinear(x;b;y))

Lemma: hp-right-angles-out
∀e:EuclideanPlane. ∀a,b,p1,p2:Point.
  (((Rbap1 ∧ Rbap2) ∧ p1 # ab ∧ (p1 leftof ab ⇐⇒ p2 leftof ab) ∧ (p1 leftof ba ⇐⇒ p2 leftof ba)) ⇒ out(a p1p2))

Lemma: out-implies-straightangle
∀e:EuclideanPlane. ∀a,b,c,a',b',c':Point.  (a' # b' ⇒ c' # b' ⇒ out(b ac) ⇒ (abc ≅a a'b'c' ⇐⇒ out(b' a'c')))

Lemma: between-implies-straightangle
∀e:EuclideanPlane. ∀a,b,c,a',b',c':Point.  (a-b-c ⇒ (abc ≅a a'b'c' ∧ a' # b' ∧ b' # c' ⇐⇒ a'-b'-c'))

Lemma: zero-angles-congruent
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (b # a ⇒ y # x ⇒ B(bac) ⇒ B(yxz) ⇒ abc ≅a xyz)

Lemma: angle-cong-preserves-straight-angle
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (B(xyz) ⇒ abc ≅a xyz ⇒ a-b-c)

Lemma: angle-cong-preserves-zero-angle
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (out(y xz) ⇒ abc ≅a xyz ⇒ out(b ac))

Lemma: geo-lt-angle-degenerate-case1
∀e:EuclideanPlane. ∀a,b,x,y,z:Point.  (a # b ⇒ x-y-z ⇒ aba < xyz)

Lemma: geo-lt-angle-degenerate-case2
∀e:EuclideanPlane. ∀a,b,x,y,z:Point.  (a # b ⇒ x # yz ⇒ aba < xyz)

Lemma: straight-angles-not-lt2
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (a-b-c ⇒ (¬abc < xyz))

Lemma: cong-angle-preserves-lsep_weak
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (x # yz ⇒ abc ≅a xyz ⇒ (¬¬a # bc))

Lemma: zero-angle-less-than-all
∀g:EuclideanPlane. ∀a,b,x,y,z:Point.  (a # b ⇒ x # yz ⇒ aba < xyz)

Lemma: perp-in-congruence
∀e:EuclideanPlane
  ∀[a,b,A,B,c,d,C,D:Point].
    (ad ≅ AD ∧ bd ≅ BD ∧ cd ≅ CD) supposing (ab  ⊥d dc and AB  ⊥D DC and bc ≅ BC and ac ≅ AC and ab ≅ AB)

Lemma: congruence-implies-between
∀e:EuclideanPlane
  ∀[a,b,c,d,A,B,C,D:Point].
    (B(ABC)) supposing 
       ((A # B ⇒ C # B ⇒ (A leftof BD ⇐⇒ C leftof DB)) and 
       B(abc) and 
       d # b and 
       bd ≅ BD and 
       ad ≅ AD and 
       cd ≅ CD and 
       bc ≅ BC and 
       ab ≅ AB)

Lemma: opp-side-congruence-lemma
∀e:EuclideanPlane
  ∀[a,b,A,B,c,d,C,D:Point].
    (cd ≅ CD) supposing 
       (C leftof AB and 
       D leftof BA and 
       c leftof ab and 
       d leftof ba and 
       a # b and 
       bd ≅ BD and 
       ad ≅ AD and 
       bc ≅ BC and 
       ac ≅ AC and 
       ab ≅ AB)

Lemma: opp-side_half-plane-angle-congruence-lemma
∀e:EuclideanPlane. ∀b,p,b',p',a,c,a',c',d:Point.
  ((a leftof bp ∧ c leftof pb)
  ⇒ (a' leftof b'p' ∧ c' leftof p'b')
  ⇒ ((abp ≅a a'b'p' ∧ pbc ≅a p'b'c') ∧ (a-d-c ∧ out(b dp)) ∧ b # d)
  ⇒ (∃a'',c'',d'':Point
       ((ba ≅ b'a'' ∧ (bc ≅ b'c'' ∧ bd ≅ b'd'') ∧ ad ≅ a''d'' ∧ dc ≅ d''c'' ∧ out(b' d''p')) ∧ B(a''d''c''))))

Lemma: use-plane-sep_strict
∀g:EuclideanPlane. ∀a,b,u,v:Point.  (u leftof ab ⇒ v leftof ba ⇒ (∃x:Point. (Colinear(a;b;x) ∧ u-x-v)))

Lemma: plane-sep-imp-Opasch_left-strict
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| B(abc)} . ∀x:Point. ∀y:{y:Point| b-x-y} .
  (x leftof ab ⇒ b # c ⇒ (∃p:Point [(a-x-p ∧ c-p-y)]))

Lemma: outer-pasch-strict
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| B(abc)} . ∀x:Point. ∀y:{y:Point| b-x-y} .
  (x # ab ⇒ b # c ⇒ (∃p:Point [(a-x-p ∧ c-p-y)]))

Lemma: geo-cong-angle-preserves-lt-angle
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.  (abc ≅a def ⇒ abc < xyz ⇒ def < xyz)

Lemma: geo-out-preserves-lt-angle
∀e:EuclideanPlane. ∀a,b,c,a',c',x,y,z:Point.  (a # bc ⇒ out(b aa') ⇒ out(b cc') ⇒ abc < xyz ⇒ a'bc' < xyz)

Lemma: geo-out-interior-point-exists
∀g:EuclideanPlane. ∀a,b,c,a',c',x:Point.
  (a # bc
  ⇒ out(b aa')
  ⇒ out(b cc')
  ⇒ a-x-c
  ⇒ (∃x':Point. (((a'-x'-c' ∧ out(b xx')) ∧ abx ≅a a'bx') ∧ cbx ≅a c'bx')))

Lemma: geo-lt-angle-triangle-point-exists
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc < xyz ⇒ a # bc ⇒ x # yz ⇒ (∃p:Point. (x-p-z ∧ xyp ≅a abc)))

Lemma: lt-angle-not-cong2
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc < xyz ⇒ (¬abc ≅a xyz))

Lemma: geo-lt-angle-trans
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.  (abc < def ⇒ def < xyz ⇒ a # bc ⇒ d # ef ⇒ x # yz ⇒ abc < xyz)

Lemma: geo-lt-angle-symm
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (abc < def ⇒ d # ef ⇒ abc < fed)

Lemma: geo-lt-angle-symm2
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (abc < def ⇒ cba < def)

Lemma: geo-lt-angle_functionality
∀e:EuclideanPlane. ∀a,a',b,b',c,c',x,x',y,y',z,z':Point.
  (a ≡ a' ⇒ b ≡ b' ⇒ c ≡ c' ⇒ x ≡ x' ⇒ y ≡ y' ⇒ z ≡ z' ⇒ (abc < xyz ⇐⇒ a'b'c' < x'y'z'))

Lemma: geo-between-lt-angle
∀e:EuclideanPlane. ∀a,b,c,p:Point.  (a # bc ⇒ b-p-c ⇒ bap < bac)

Lemma: lt-angle-irrefl
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (abc < xyz ⇒ (¬xyz < abc))

Definition: hp-angle-sum
abc + xyz ≅ def ==  ∃p,p',d',f':Point. (((abc ≅a dep ∧ fep ≅a xyz) ∧ B(ep'p)) ∧ (out(e dd') ∧ out(e ff')) ∧ d'-p'-f')

Lemma: hp-angle-sum_wf
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ∈ ℙ)

Definition: angle-sum
abc + def ≅a xyz ==  ∃p:Point. ((p leftof xy ∧ p leftof yz) ∧ abc ≅a xyp ∧ def ≅a zyp)

Lemma: angle-sum_wf
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅a ijk ∈ ℙ)

Lemma: hp-angle-sum-functionality
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (a ≡ a'
  ⇒ b ≡ b'
  ⇒ c ≡ c'
  ⇒ x ≡ x'
  ⇒ y ≡ y'
  ⇒ z ≡ z'
  ⇒ i ≡ i'
  ⇒ j ≡ j'
  ⇒ k ≡ k'
  ⇒ (abc + xyz ≅ ijk ⇐⇒ a'b'c' + x'y'z' ≅ i'j'k'))

Lemma: angle-sum-functionality
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (a ≡ a'
  ⇒ b ≡ b'
  ⇒ c ≡ c'
  ⇒ x ≡ x'
  ⇒ y ≡ y'
  ⇒ z ≡ z'
  ⇒ i ≡ i'
  ⇒ j ≡ j'
  ⇒ k ≡ k'
  ⇒ (abc + xyz ≅a ijk ⇐⇒ a'b'c' + x'y'z' ≅a i'j'k'))

Lemma: hp-angle-sum-symm
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ i # jk ⇒ xyz + abc ≅ ijk)

Lemma: straight-angle-sum1
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ a-b-c ⇒ out(y xz))

Lemma: straight-angle-sum1_symm
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ x-y-z ⇒ out(b ac))

Lemma: straight-angle-sum2
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ out(y xz) ⇒ (a-b-c ⇐⇒ i-j-k))

Lemma: straight-angle-sum2_symm
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ out(b ac) ⇒ (x-y-z ⇐⇒ i-j-k))

Lemma: right-angle-sum
∀g:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.
  (a # b ⇒ b # c ⇒ x # y ⇒ y # z ⇒ Rabc ⇒ Rxyz ⇒ i-j-k ⇒ abc + xyz ≅ ijk)

Lemma: hp-angle-sum-sep
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (abc + xyz ≅ ijk ⇒ {i # j ∧ j # k})

Lemma: hp-angle-sum-subst
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z,i,j,k:Point.  (abc + def ≅ xyz ⇒ abc ≅a ijk ⇒ ijk + def ≅ xyz)

Lemma: hp-angle-sum-subst1
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z,i,j,k:Point.  (abc + def ≅ xyz ⇒ def ≅a ijk ⇒ abc + ijk ≅ xyz)

Lemma: hp-angle-sum-eq
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (abc ≅a a'b'c'
  ⇒ xyz ≅a x'y'z'
  ⇒ abc + xyz ≅ ijk
  ⇒ a'b'c' + x'y'z' ≅ i'j'k'
  ⇒ i # jk
  ⇒ i' # j'k'
  ⇒ ijk ≅a i'j'k')

Lemma: hp-angle-sum-subst2
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z,i,j,k:Point.  (abc + def ≅ xyz ⇒ abc ≅a ijk ⇒ ijk + def ≅ xyz)

Lemma: hp-angle-sum-subst3
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z,i,j,k:Point.  (abc + def ≅ xyz ⇒ xyz ≅a ijk ⇒ x # yz ⇒ abc + def ≅ ijk)

Definition: heyting-geometry
HeytingGeometry ==  EuclideanPlane

Lemma: heyting-geometry_wf
HeytingGeometry ∈ 𝕌'

Lemma: heyting-geometry-subtype
HeytingGeometry ⊆r EuclideanPlane

Definition: geo-triangle
a # bc ==  a # bc

Lemma: geo-triangle_wf
∀[e:GeometryPrimitives]. ∀[a,b,c:Point].  (a # bc ∈ ℙ)

Lemma: sq_stable__geo-triangle
∀e:EuclideanPlaneStructure. ∀a,b,c:Point.  SqStable(a # bc)

Lemma: not-geo-triangle-iff-colinear
∀e:HeytingGeometry. ∀a,b,c:Point.  (¬a # bc ⇐⇒ Colinear(a;b;c))

Lemma: geo-not-triangle
∀e:HeytingGeometry. ∀a,b,c:Point.  ((¬a # bc) ⇒ (¬((¬B(abc)) ∧ (¬B(bca)) ∧ (¬B(cab)))))

Lemma: heyting-not-not-inner-pasch
∀e:HeytingGeometry. ∀a,b,c:Point. ∀p:{p:Point| B(apc)} . ∀q:{q:Point| B(bqc)} .  (¬¬(∃x:Point. (B(pxb) ∧ B(qxa))))

Lemma: geo-triangle-implies
∀e:HeytingGeometry. ∀a,b,c:Point.
  (a # bc ⇒ {c # ba ∧ c # ab ∧ a # c ∧ (¬B(abc)) ∧ (∀z:Point. (z # b ⇒ Colinear(a;b;z) ⇒ z # bc))})

Lemma: geo-triangle-colinear
∀e:HeytingGeometry. ∀a,b,c,z:Point.  (a # bc ⇒ z # b ⇒ Colinear(a;b;z) ⇒ z # bc)

Lemma: geo-triangle-symmetry
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ {b # ca ∧ c # ab ∧ a # cb ∧ b # ac ∧ c # ba})

Lemma: geo-triangle-colinear'
∀e:HeytingGeometry. ∀a,b,c,x,z:Point.  (a # bc ⇒ x # b ⇒ Colinear(a;b;x) ⇒ z # c ⇒ Colinear(x;c;z) ⇒ z # bc)

Lemma: geo-triangle-colinear2
∀e:HeytingGeometry. ∀a,b,c,x,y:Point.  (a # bc ⇒ x # b ⇒ Colinear(a;b;x) ⇒ y # c ⇒ Colinear(b;c;y) ⇒ x # yc)

Lemma: geo-triangle-colinear3
∀e:HeytingGeometry. ∀a,b,c,x,y,z:Point.
  (a # bc ⇒ x # b ⇒ Colinear(a;b;x) ⇒ y # c ⇒ Colinear(b;c;y) ⇒ z # x ⇒ Colinear(c;x;z) ⇒ x # yz)

Lemma: geo-triangle-property
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ {a # b ∧ b # c ∧ c # a ∧ (¬a-b-c) ∧ (¬b-c-a) ∧ (¬c-a-b)})

Lemma: geo-triangle-property2
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ {(¬B(abc)) ∧ (¬B(bca)) ∧ (¬B(cab))})

Lemma: geo-triangle_functionality
∀e:HeytingGeometry. ∀a1,a2,b1,b2,c1,c2:Point.  (a1 ≡ a2 ⇒ b1 ≡ b2 ⇒ c1 ≡ c2 ⇒ (a1 # b1c1 ⇐⇒ a2 # b2c2))

Lemma: geo-triangle-separation
∀e:HeytingGeometry. ∀a,b,c:Point.
  (a # bc
  ⇒ {∀x,y:Point.  (((Colinear(a;b;x) ∧ Colinear(c;b;y)) ∧ x # b ∧ y # b) ⇒ (x # by ∧ (∀m:Point. (x-m-y ⇒ m # b))))})

Lemma: geo-inner-pasch-ex
∀e:HeytingGeometry. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p,q:Point.  (a-p-c ⇒ b-q-c ⇒ (∃x:Point. (b-x-p ∧ a-x-q)))

Lemma: geo-inner-pasch-ex2
∀e:HeytingGeometry. ∀a,b:Point. ∀c:{c:Point| c # ab} . ∀p,q:Point.  (a-p-c ⇒ b-q-c ⇒ (∃x:Point. (B(bxp) ∧ B(axq))))

Lemma: geo-segments-cross
∀e:HeytingGeometry. ∀p,b,q,a:Point.  ((∃c:Point. (a-p-c ∧ b-q-c ∧ c # ab)) ⇒ (∃x:Point. (p-x-b ∧ q-x-a)))

Lemma: geo-triangle-same-line
∀e:HeytingGeometry. ∀x,a:Point. ∀b:{b:Point| a # b} . ∀c:Point. ∀d:{d:Point| c # d} .
  (line(a;b)=line(c;d) ⇒ {x # ab ⇐⇒ x # cd})

Lemma: geo-triangles-between
∀e:HeytingGeometry. ∀a,b,c,p,q:Point.  (a # bc ⇒ b-p-a ⇒ b-q-c ⇒ p # bq)

Lemma: cong-angle-out-aux
∀g:HeytingGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  ((a # bc ∧ abc ≅a def)
  ⇒ d # ef
  ⇒ out(b a'a)
  ⇒ out(b c'c)
  ⇒ out(e d'd)
  ⇒ out(e f'f)
  ⇒ ba' ≅ ed'
  ⇒ bc' ≅ ef'
  ⇒ a'c' ≅ d'f')

Lemma: cong-angle-out-aux-weak
∀g:HeytingGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  (abc ≅a def ⇒ out(b a'a) ⇒ out(b c'c) ⇒ out(e d'd) ⇒ out(e f'f) ⇒ ba' ≅ ed' ⇒ bc' ≅ ef' ⇒ a'c' ≅ d'f')

Lemma: cong-angle-out-aux2
∀g:HeytingGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  ((a # bc ∧ a'c' ≅ d'f')
  ⇒ d # ef
  ⇒ out(b a'a)
  ⇒ out(b c'c)
  ⇒ out(e d'd)
  ⇒ out(e f'f)
  ⇒ ba' ≅ ed'
  ⇒ bc' ≅ ef'
  ⇒ abc ≅a def)

Lemma: cong-angle-out-aux2-weak
∀g:HeytingGeometry. ∀a,b,c,d,e,f,a',c',d',f':Point.
  (a'c' ≅ d'f' ⇒ out(b a'a) ⇒ out(b c'c) ⇒ out(e d'd) ⇒ out(e f'f) ⇒ ba' ≅ ed' ⇒ bc' ≅ ef' ⇒ abc ≅a def)

Lemma: geo-out-triangle
∀e:HeytingGeometry. ∀a,b,c,a',c':Point.  (b # ac ⇒ (out(b aa') ∧ out(b cc')) ⇒ b # a'c')

Lemma: cong-angle-out-exists-aux3
∀e:HeytingGeometry. ∀a,b,c,x,y,z:Point.
  ((∃a',c',x',z':Point
     ((Cong3(a'bc',x'yz') ∧ b # a'c' ∧ y # x'z') ∧ out(b a'a) ∧ out(b c'c) ∧ out(y x'x) ∧ out(y z'z)))
  ⇒ abc ≅a xyz)

Lemma: cong-angle-out-exists-aux3-weak
∀e:HeytingGeometry. ∀a,b,c,x,y,z:Point.
  ((∃a',c',x',z':Point. (Cong3(a'bc',x'yz') ∧ out(b a'a) ∧ out(b c'c) ∧ out(y x'x) ∧ out(y z'z))) ⇒ abc ≅a xyz)

Lemma: sup-angles-preserve-congruence
∀e:HeytingGeometry. ∀a,b,c,x,y,z,a',x':Point.  ((abc ≅a xyz ∧ a # bc ∧ x # yz) ⇒ a-b-a' ⇒ x-y-x' ⇒ a'bc ≅a x'yz)

Lemma: vert-angles-congruent
∀e:HeytingGeometry. ∀b,a,a',c,c':Point.  (a-b-a' ⇒ c-b-c' ⇒ a # bc ⇒ abc ≅a a'bc')

Lemma: double-pasch-exists
∀e:HeytingGeometry. ∀a,b,c,a',b',p:Point.  (a-b-c ⇒ a'-b'-c ⇒ a-p-a' ⇒ c # aa' ⇒ (∃q:Point. (p-q-c ∧ b-q-b')))

Lemma: geo-tar-opp-side-mid1
∀e:HeytingGeometry. ∀a,c,r,m:Point.
  (geo-tar-opp-side(e;a;c;r;m) ⇒ a=m=c ⇒ (∀b:Point. (r-a-b ⇒ geo-tar-opp-side(e;b;c;r;m))))

Lemma: segment-intersection
∀e:HeytingGeometry. ∀a,b,c:Point.  (c # ab ⇒ (∃p,q:Point. (Colinear(a;b;p) ∧ c-p-q)))

Lemma: isosceles-mid-between
∀e:HeytingGeometry. ∀a,b,c,p,q,r,x:Point.
  (a # bc ⇒ B(apb) ⇒ B(cqb) ⇒ p=x=q ⇒ a=r=c ⇒ a=p=b ⇒ c=q=b ⇒ pb ≅ qb ⇒ b-x-r)

Lemma: isosceles-mid-exists
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ ab ≅ cb ⇒ (∃x:Point. a=x=c))

Lemma: isosceles-mid-cong-angles
∀e:HeytingGeometry. ∀a,b,c,m:Point.  (c # ab ⇒ a=m=b ⇒ ac ≅ bc ⇒ acm ≅a bcm)

Lemma: isosc-bisectors-between
∀e:HeytingGeometry. ∀a,b,c,m,a',b',m':Point.
  (c # ab ⇒ ac ≅ bc ⇒ (c-a-a' ∧ b'-b-c) ⇒ a=m=b ⇒ a'=m'=b' ⇒ aa' ≅ bb' ⇒ c-m-m')

Lemma: isosc-bisectors-between_1
∀e:HeytingGeometry. ∀a,b,c,m,a',b',m':Point.
  (c # ab ⇒ ac ≅ bc ⇒ (c-a'-a ∧ c-b'-b) ⇒ a=m=b ⇒ a'=m'=b' ⇒ aa' ≅ bb' ⇒ c-m'-m)

Lemma: isosc-bisectors-between-ns
∀e:HeytingGeometry. ∀a,b,c,m,a',b',m':Point.
  (c # ab ⇒ ac ≅ bc ⇒ (B(caa') ∧ B(b'bc)) ⇒ a=m=b ⇒ a'=m'=b' ⇒ aa' ≅ bb' ⇒ B(cmm'))

Lemma: isosc-bisectors-between_1-ns
∀e:HeytingGeometry. ∀a,b,c,m,a',b',m':Point.
  (c # a'b' ⇒ ac ≅ bc ⇒ (B(ca'a) ∧ B(cb'b)) ⇒ a=m=b ⇒ a'=m'=b' ⇒ aa' ≅ bb' ⇒ B(cm'm))

Lemma: isosc-colinear-mid-exists
∀e:HeytingGeometry. ∀a,b,c,m,a',b',m':Point.
  (c # ab ⇒ ac ≅ bc ⇒ (out(c aa') ∧ out(c bb')) ⇒ a=m=b ⇒ a'c ≅ b'c ⇒ (∃m':Point. (out(c m'm) ∧ a'=m'=b')))

Lemma: not-perp-point-construction
∀e:HeytingGeometry. ∀a,b,c:Point.
  (a # bc ⇒ (∃c',b':Point. ((c=c'=b' ∧ ab' ≅ ac) ∧ Colinear(a;b';b) ∧ a # c'b' ∧ Rac'b')))

Lemma: not-perp-point-construction-between
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ (∃c',b':Point. ((c=c'=b' ∧ ab' ≅ ac) ∧ b-a-b' ∧ a # c'b' ∧ Rac'b')))

Lemma: perp-aux1
∀e:HeytingGeometry. ∀a,b,c,p,q,r:Point.  (a # bc ⇒ a-p-b ⇒ c-q-b ⇒ a-r-c ⇒ (∃y:Point. (p-y-c ∧ q-y-r)))

Lemma: perp-aux2
∀e:HeytingGeometry. ∀a,b,c,p,q,r:Point.  (a # bc ⇒ a-p-b ⇒ c-q-b ⇒ a-r-c ⇒ p # qr)

Lemma: perp-aux-separations
∀e:HeytingGeometry. ∀a,b,c,x,c1,c',p:Point.
  ((((c # ba ∧ ab  ⊥x cx) ∧ a # x)
  ∧ ((c=a=c1 ∧ c=x=c') ∧ c'a ≅ ca)
  ∧ c' # c1a
  ∧ ((a # cc' ∧ c1=p=c') ∧ ab  ⊥a pa)
  ∧ p # ab)
  ⇒ ((c' # c1 ∧ c # x ∧ (c' # x ∧ c1 # p) ∧ c' # p ∧ c # c1) ∧ c # c'c1))

Lemma: erected-perp-opp-side-triangle
∀e:HeytingGeometry. ∀a,b,c,p,t:Point.
  ((c # ba ∧ ((ab ⊥ pa ∧ Colinear(a;b;t)) ∧ p-t-c) ∧ p # ba) ⇒ geo-tar-opp-side(e;p;c;a;b))

Lemma: geo-double-pasch-same-point
∀e:HeytingGeometry. ∀A,B,C,d,f,g,x,y:Point.
  (A # BC ⇒ A-d-C ⇒ A-g-B ⇒ B-f-C ⇒ C-x-g ⇒ C-y-g ⇒ B-x-d ⇒ B-y-d ⇒ A-x-f ⇒ A-y-f ⇒ x ≡ y)

Lemma: p5-triangles
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ ab ≅ cb ⇒ (bac ≅a bca ∧ (∀p,q:Point.  ((b-a-p ∧ b-c-q) ⇒ pac ≅a qca))))

Lemma: p4-triangles
∀e:HeytingGeometry. ∀a,b,c,x,y,z:Point.
  (a # bc ⇒ x # yz ⇒ ab ≅ xy ⇒ ac ≅ xz ⇒ bac ≅a yxz ⇒ ((bc ≅ yz ∧ Cong3(abc,xyz)) ∧ abc ≅a xyz ∧ bca ≅a yzx))

Lemma: p6-aux-bet-preserves-angle
∀e:HeytingGeometry. ∀a,b,c,d:Point.  (a # bc ⇒ (B(adb) ∧ a # d) ⇒ cab ≅a cad)

Lemma: p9-tarski-aux
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ ab ≅ cb ⇒ (∃x:Point. a=x=c))

Lemma: triangle-separation-lemma
∀e:HeytingGeometry. ∀A,B,C:Point.  (A # BC ⇒ CA ≅ CB ⇒ (∃P:Point. (C-A-P ∧ P # B)))

Lemma: geo-congruent-mid-exists
∀e:HeytingGeometry. ∀A,B,C:Point.  (A # BC ⇒ CA ≅ CB ⇒ (∃x:Point. A=x=B))

Lemma: tarski-perp-exists
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ (∃x:Point. (Colinear(a;b;x) ∧ ab ⊥ cx)))

Lemma: tarski-perp-in-exists
∀e:HeytingGeometry. ∀a,b,c:Point.  (a # bc ⇒ (∃x:Point. (Colinear(a;b;x) ∧ ab  ⊥x cx)))

Lemma: perp-aux-general-construction
∀e:HeytingGeometry. ∀a,b,c,x:Point.
  (((c # ba ∧ ab  ⊥x cx) ∧ a # x)
  ⇒ (∃c1,c',p:Point. (((c=a=c1 ∧ c=x=c') ∧ c'a ≅ ca) ∧ c' # c1a ∧ ((a # cc' ∧ c1=p=c') ∧ ab  ⊥a pa) ∧ p # ab)))

Lemma: tarski-erect-perp1
∀e:HeytingGeometry. ∀a,b,c:Point.  (c # ba ⇒ (∃p,t,d:Point. ((ab ⊥ pa ∧ Colinear(a;b;t)) ∧ p-t-d)))

Lemma: tarski-erect-perp-in
∀e:HeytingGeometry. ∀a,b,c:Point.  (c # ba ⇒ (∃p:Point. (ab  ⊥a pa ∧ p # ab)))

Lemma: tarski-erect-perp-in-side
∀e:HeytingGeometry. ∀a,b,c:Point.
  (c # ba ⇒ (∃p,t,d:Point. ((((ab  ⊥a pa ∧ Colinear(a;b;t)) ∧ p-t-d) ∧ geo-tar-same-side(e;c;d;a;b)) ∧ p # ba)))

Lemma: tarski-erect-perp-same-side
∀e:HeytingGeometry. ∀a,b,c:Point.
  (c # ba ⇒ (∃p,t,d:Point. (((ab ⊥ pa ∧ Colinear(a;b;t)) ∧ p-t-d) ∧ geo-tar-same-side(e;c;d;a;b))))

Lemma: tarski-erect-perp-same-side2
∀e:HeytingGeometry. ∀a,b,c:Point.
  (c # ba ⇒ (∃p,t,d:Point. ((((ab ⊥ pa ∧ Colinear(a;b;t)) ∧ p-t-d) ∧ geo-tar-same-side(e;c;d;a;b)) ∧ p # ba)))

Lemma: tarski-erect-perp-or
∀e:HeytingGeometry. ∀a,b,c:Point.  (c # ba ⇒ (∃p,t:Point. (((ab ⊥ pa ∨ ab ⊥ pb) ∧ Colinear(a;b;t)) ∧ p-t-c)))

Lemma: Euclid-prop13
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (c-b-d ⇒ a # cd ⇒ abc + abd ≅ cbd)

Definition: mk-eu
primitive=e
Ssquashstable=Sstab
Lorsquashstable=Lstab
SepOr=Gtor
nontriv=nontriv
SS=SS
SC=SC
CC=CC ==
  e["Ssquashstable" := Sstab]["Lorsquashstable" := Lstab]["SepOr" := Gtor]["nontrivial" := nontriv]["SS" := SS]
  ["SS" := SS]["SC" := SC]["CC" := CC]

Lemma: mk-eu_wf
∀[self:GeometryPrimitives]. ∀[Sstab:∀a,b,c,d:Point.  SqStable(ab>cd)]. ∀[Lstab:∀a,b,c:Point.  SqStable(a # bc)].
∀[Sepor:∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (a # c ∨ b # c)]. ∀[nontriv:∃a:Point. (∃b:Point [a # b])].
∀[SS:∀a,b:Point. ∀u:{u:Point| u leftof ab} . ∀v:{v:Point| v leftof ba} .  (∃x:Point [(Colinear(a;b;x) ∧ B(uxv))])].
∀[SC:∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  (∃u:Point [(cu ≅ cd ∧ B(abu) ∧ (b # d ⇒ b # u))])].
∀[CC:∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:{d:Point| StrictOverlap(a;b;c;d)} .
       (∃u:Point [(ab ≅ au ∧ cd ≅ cu ∧ u leftof ac)])].
  (primitive=self
   Ssquashstable=Sstab
   Lorsquashstable=Lstab
   SepOr=Sepor
   nontriv=nontriv
   SS=SS
   SC=SC
   CC=CC ∈ EuclideanPlaneStructure)

Lemma: mk-eu_wf2
∀[self:GeometryPrimitives]. ∀[Sstab:∀a,b,c,d:Point.  SqStable(ab>cd)]. ∀[Lstab:∀a,b,c:Point.  SqStable(a # bc)].
∀[Sepor:∀a:Point. ∀b:{b:Point| a # b} . ∀c:Point.  (a # c ∨ b # c)]. ∀[nontriv:∃a:Point. (∃b:Point [a # b])].
∀[SS:∀a,b:Point. ∀u:{u:Point| u leftof ab} . ∀v:{v:Point| v leftof ba} .  (∃x:Point [(Colinear(a;b;x) ∧ B(uxv))])].
∀[SC:∀c,d,a:Point. ∀b:{b:Point| b # a ∧ B(cbd)} .  (∃u:Point [(cu ≅ cd ∧ B(abu) ∧ (b # d ⇒ b # u))])].
∀[CC:∀a,b:Point. ∀c:{c:Point| a # c} . ∀d:{d:Point| StrictOverlap(a;b;c;d)} .
       (∃u:Point [(ab ≅ au ∧ cd ≅ cu ∧ u leftof ac)])].
  primitive=self
  Ssquashstable=Sstab
  Lorsquashstable=Lstab
  SepOr=Sepor
  nontriv=nontriv
  SS=SS
  SC=SC
  CC=CC ∈ EuclideanPlane 
  supposing BasicGeometryAxioms(self)

Definition: pgeo-point
Point ==  p."Point"

Definition: pgeo-line
Line ==  p."Line"

Definition: pgeo-primitives
ProjGeomPrimitives ==  "Point":Type"Line":Type"PS":Point ⟶ Line ⟶ ℙ

Lemma: pgeo-primitives_wf
ProjGeomPrimitives ∈ 𝕌'

Definition: mk-pgeo-prim
points=P lines=L plsep=S ==  λx.x["Point" := P]["Line" := L]["PS" := S]

Lemma: mk-pgeo-prim_wf
∀[P,L:Type]. ∀[S:P ⟶ L ⟶ ℙ].  (points=P lines=L plsep=S ∈ ProjGeomPrimitives)

Lemma: pgeo-point_wf
∀[g:ProjGeomPrimitives]. (Point ∈ Type)

Lemma: pgeo-line_wf
∀[g:ProjGeomPrimitives]. (Line ∈ Type)

Definition: pgeo-plsep
pgeo-plsep(p; a; b) ==  p."PS" a b

Lemma: pgeo-plsep_wf
∀[p:ProjGeomPrimitives]. ∀[a:Point]. ∀[b:Line].  (pgeo-plsep(p; a; b) ∈ ℙ)

Definition: pgeo-dual-prim
pg* ==  points=Line lines=Point plsep=λl,p. pgeo-plsep(pg; p; l)

Lemma: pgeo-dual-prim_wf
∀[pg:ProjGeomPrimitives]. (pg* ∈ ProjGeomPrimitives)

Definition: pgeo-incident
a I b ==  ¬pgeo-plsep(g; a; b)

Lemma: pgeo-incident_wf
∀[g:ProjGeomPrimitives]. ∀[a:Point]. ∀[b:Line].  (a I b ∈ ℙ)

Lemma: sq_stable__pgeo-incident
∀[g:ProjGeomPrimitives]. ∀[a:Point]. ∀[b:Line].  SqStable(a I b)

Definition: pgeo-psep
a ≠ b ==  ∃l:Line. (a I l ∧ pgeo-plsep(p; b; l))

Lemma: pgeo-psep_wf
∀[p:ProjGeomPrimitives]. ∀[a,b:Point].  (a ≠ b ∈ ℙ)

Definition: pgeo-lsep
l ≠ m ==  ∃a:Point. (a I l ∧ pgeo-plsep(p; a; m))

Lemma: pgeo-lsep_wf
∀[p:ProjGeomPrimitives]. ∀[a,b:Line].  (a ≠ b ∈ ℙ)

Definition: pgeo-lpsep
a ≠ b ==  pgeo-plsep(p; b; a)

Lemma: pgeo-lpsep_wf
∀[p:ProjGeomPrimitives]. ∀[a:Line]. ∀[b:Point].  (a ≠ b ∈ ℙ)

Lemma: pgeo-lpsep-dual
∀[p,l,b:Top].  (l ≠ b ~ pgeo-plsep(p*; l; b))

Definition: pgeo-peq
a ≡ b ==  ¬a ≠ b

Lemma: pgeo-peq_wf
∀[g:ProjGeomPrimitives]. ∀[a,b:Point].  (a ≡ b ∈ ℙ)

Lemma: sq_stable__pgeo-peq
∀[g:ProjGeomPrimitives]. ∀[c,d:Point].  SqStable(c ≡ d)

Definition: pgeo-leq
a ≡ b ==  ¬a ≠ b

Lemma: pgeo-leq_wf
∀[g:ProjGeomPrimitives]. ∀[a,b:Line].  (a ≡ b ∈ ℙ)

Definition: basic-pgeo-axioms
BasicProjectiveGeometryAxioms(g) ==
  ∀m,l:Line. ∀p,q:Point.  (p I l ⇒ q I l ⇒ p I m ⇒ q I m ⇒ (¬((¬p ≡ q) ∧ (¬l ≡ m))))

Lemma: basic-pgeo-axioms_wf
∀[g:ProjGeomPrimitives]. (BasicProjectiveGeometryAxioms(g) ∈ ℙ)

Lemma: sq_stable-pgeo-axioms-if
∀[g:ProjGeomPrimitives]
  ((∀a:Point. ∀L:Line.  SqStable(pgeo-plsep(g; a; L))) ⇒ SqStable(BasicProjectiveGeometryAxioms(g)))

Definition: projective-plane-structure
ProjectivePlaneStructure ==
  ProjGeomPrimitives
  "Ssquashstable":∀l:Line. ∀a:Point.  SqStable(pgeo-plsep(self; a; l))
  "PLSepOr":∀a:Point. ∀l:{l:Line| pgeo-plsep(self; a; l)} . ∀m:Line.  (pgeo-plsep(self; a; m) ∨ m ≠ l)
  "LPSepOr":∀l:Line. ∀a:{a:Point| l ≠ a} . ∀b:Point.  (pgeo-plsep(self; b; l) ∨ b ≠ a)
  "join":∀a,b:Point.  (a ≠ b ⇒ (∃l:Line. (a I l ∧ b I l)))
  "meet":∀l,m:Line.  (l ≠ m ⇒ (∃a:Point. (a I l ∧ a I m)))
  "three-points":∀l:Line. ∃a,b,c:Point. (a I l ∧ b I l ∧ c I l ∧ a ≠ b ∧ b ≠ c ∧ c ≠ a)
  "three-lines":∀a:Point. ∃l,m,n:Line. (a I l ∧ a I m ∧ a I n ∧ l ≠ m ∧ m ≠ n ∧ n ≠ l)

Lemma: projective-plane-structure_wf
ProjectivePlaneStructure ∈ 𝕌'

Lemma: projective-plane-structure_subtype
ProjectivePlaneStructure ⊆r ProjGeomPrimitives

Definition: projective-plane-structure-complete
ProjectivePlaneStructureComplete ==  ProjectivePlaneStructure"non-trivial":∃p:Point. p ≡ p

Lemma: projective-plane-structure-complete_wf
ProjectivePlaneStructureComplete ∈ 𝕌'

Lemma: projective-plane-structure-complete_subtype
ProjectivePlaneStructureComplete ⊆r ProjectivePlaneStructure

Lemma: sq_stable__pgeo-plsep
∀p:ProjectivePlaneStructure. ∀a:Point. ∀b:Line.  SqStable(pgeo-plsep(p; a; b))

Definition: mk-pgeo
mk-pgeo(p; ss; por; lor; j; m; p3; l3) ==
  p["Ssquashstable" := ss]["PLSepOr" := por]["LPSepOr" := lor]["join" := j]["meet" := m]["three-points" := p3]
  ["three-lines" := l3]

Lemma: mk-pgeo_wf
∀[self:ProjGeomPrimitives]. ∀[ss:∀l:Line. ∀a:Point.  SqStable(pgeo-plsep(self; a; l))]. ∀[por:∀a:Point. ∀l:{l:Line| 
                                                                                                            pgeo-plsep
                                                                                                              (self;
                                                                                                               a;
                                                                                                               l)} .
                                                                                              ∀m:Line.
                                                                                                (pgeo-plsep(self; a; m)
                                                                                                ∨ m ≠ l)].
∀[lor:∀l:Line. ∀a:{a:Point| l ≠ a} . ∀b:Point.  (pgeo-plsep(self; b; l) ∨ b ≠ a)]. ∀[j:∀a,b:Point.
                                                                                        (a ≠ b
                                                                                        ⇒ (∃l:Line. (a I l ∧ b I l)))].
∀[m:∀l,m:Line.  (l ≠ m ⇒ (∃a:Point. (a I l ∧ a I m)))]. ∀[p3:∀l:Line
                                                                ∃a,b,c:Point
                                                                 (a I l ∧ b I l ∧ c I l ∧ a ≠ b ∧ b ≠ c ∧ c ≠ a)].
∀[l3:∀a:Point. ∃l,m,n:Line. (a I l ∧ a I m ∧ a I n ∧ l ≠ m ∧ m ≠ n ∧ n ≠ l)].
  (mk-pgeo(self; ss; por; lor; j; m; p3; l3) ∈ ProjectivePlaneStructure)

Definition: mk-complete-pgeo
mk-complete-pgeo(pg;p) ==  pg["non-trivial" := <p, λx.x>]

Lemma: mk-complete-pgeo_wf
∀[pg:ProjectivePlaneStructure]. ∀[p:Point].  (mk-complete-pgeo(pg;p) ∈ ProjectivePlaneStructureComplete)

Definition: pgeo-dual
pg* ==
  mk-pgeo(pg*;
          λp,l. (pg."Ssquashstable" l p);
          pg."LPSepOr";
          pg."PLSepOr";
          pg."meet";
          pg."join";
          pg."three-lines";
          pg."three-points")

Lemma: pgeo-dual_wf
∀[pg:ProjectivePlaneStructure]. (pg* ∈ ProjectivePlaneStructure)

Definition: complete-pgeo-dual
complete-pgeo-dual(pg;l) ==  mk-complete-pgeo(pg*;l)

Lemma: complete-pgeo-dual_wf
∀[pg:ProjectivePlaneStructure]. ∀[l:Line].  (complete-pgeo-dual(pg;l) ∈ ProjectivePlaneStructureComplete)

Definition: pgeo-PLSepOr
PLSepOr(a;l;m) ==  g."PLSepOr" a l m

Lemma: pgeo-PLSepOr_wf
∀g:ProjectivePlaneStructure. ∀a:Point. ∀l:{l:Line| pgeo-plsep(g; a; l)} . ∀m:Line.
  (PLSepOr(a;l;m) ∈ pgeo-plsep(g; a; m) ∨ m ≠ l)

Definition: pgeo-LPSepOr
LPSepOr(l;p;q) ==  g."LPSepOr" l p q

Lemma: pgeo-LPSepOr_wf
∀g:ProjectivePlaneStructure. ∀l:Line. ∀p:{p:Point| l ≠ p} . ∀q:Point.  (LPSepOr(l;p;q) ∈ pgeo-plsep(g; q; l) ∨ q ≠ p)

Lemma: PL-sep-or
∀g:ProjectivePlaneStructure. ∀a:Point. ∀l,m:Line.  (pgeo-plsep(g; a; l) ⇒ (pgeo-plsep(g; a; m) ∨ m ≠ l))

Lemma: LP-sep-or
∀g:ProjectivePlaneStructure. ∀l:Line. ∀p:Point.  (l ≠ p ⇒ (∀q:Point. (pgeo-plsep(g; q; l) ∨ q ≠ p)))

Lemma: LP-sep-or2
∀g:ProjectivePlaneStructure. ∀l:Line. ∀p,q:Point.  (pgeo-plsep(g; p; l) ⇒ (pgeo-plsep(g; q; l) ∨ q ≠ p))

Definition: pgeo-join
p ∨ q ==  fst((g."join" p q s))

Lemma: pgeo-join_wf
∀g:ProjectivePlaneStructure. ∀p,q:Point. ∀s:p ≠ q.  (p ∨ q ∈ {L:Line| p I L ∧ q I L} )

Lemma: Join
∀g:ProjectivePlaneStructure. ∀p,q:Point.  (p ≠ q ⇒ (∃l:Line. (p I l ∧ q I l)))

Definition: pgeo-meet
l ∧ m ==  fst((g."meet" l m s))

Lemma: pgeo-meet_wf
∀g:ProjectivePlaneStructure. ∀l,m:Line. ∀s:l ≠ m.  (l ∧ m ∈ {p:Point| p I l ∧ p I m} )

Lemma: Meet
∀g:ProjectivePlaneStructure. ∀l,m:Line.  (l ≠ m ⇒ (∃p:Point. (p I l ∧ p I m)))

Lemma: pgeo-meet-incident
∀g:ProjectivePlaneStructure. ∀l,m:Line. ∀s:l ≠ m.  (l ∧ m I l ∧ l ∧ m I m)

Definition: pgeo-three-points
pgeo-three-point-axiom(l) ==  g."three-points" l

Lemma: pgeo-three-points_wf
∀g:ProjectivePlaneStructure. ∀l:Line.
  (pgeo-three-point-axiom(l) ∈ ∃a,b,c:Point. (a I l ∧ b I l ∧ c I l ∧ a ≠ b ∧ b ≠ c ∧ c ≠ a))

Lemma: pgeo-three-points-axiom
∀g:ProjectivePlaneStructure. ∀l:Line.  ∃a,b,c:Point. (a I l ∧ b I l ∧ c I l ∧ a ≠ b ∧ b ≠ c ∧ c ≠ a)

Definition: pgeo-three-lines
pgeo-three-line-axiom(p) ==  g."three-lines" p

Lemma: pgeo-three-lines_wf
∀g:ProjectivePlaneStructure. ∀a:Point.
  (pgeo-three-line-axiom(a) ∈ ∃l,m,n:Line. (a I l ∧ a I m ∧ a I n ∧ l ≠ m ∧ m ≠ n ∧ n ≠ l))

Lemma: pgeo-three-lines-axiom
∀g:ProjectivePlaneStructure. ∀p:Point.  ∃l,m,n:Line. (p I l ∧ p I m ∧ p I n ∧ l ≠ m ∧ m ≠ n ∧ n ≠ l)

Definition: pgeo-unique
unique(lm,pq) ==  p I l ⇒ q I l ⇒ p I m ⇒ q I m ⇒ (¬((¬p ≡ q) ∧ (¬l ≡ m)))

Lemma: pgeo-unique_wf
∀g:ProjectivePlaneStructure. ∀l,m:Line. ∀p,q:Point.  (unique(lm,pq) ∈ ℙ)

Definition: point-exists-axiom
point-exists-axiom(g) ==  g."non-trivial"

Lemma: point-exists-axiom_wf
∀[g:ProjectivePlaneStructureComplete]. (point-exists-axiom(g) ∈ ∃p:Point. p ≡ p)

Lemma: pgeo-non-trivial
∀g:ProjectivePlaneStructureComplete. ∃p:Point. p ≡ p

Lemma: sq_stable__pgeo-axioms
∀g:ProjectivePlaneStructure. SqStable(BasicProjectiveGeometryAxioms(g))

Lemma: basic-pgeo-axioms-imply
∀g:ProjectivePlaneStructure. (BasicProjectiveGeometryAxioms(g) ⇒ ((∀a:Point. a ≡ a) ∧ (∀l:Line. l ≡ l)))

Definition: basic-projective-plane
BasicProjectivePlane ==  {g:ProjectivePlaneStructure| BasicProjectiveGeometryAxioms(g)} 

Lemma: basic-projective-plane_wf
BasicProjectivePlane ∈ 𝕌'

Lemma: basic-projective-plane-subtype
BasicProjectivePlane ⊆r ProjectivePlaneStructure

Lemma: basic-projective-plane-axioms
∀g:BasicProjectivePlane. ∀m,l:Line. ∀p,q:Point.  (p I l ⇒ q I l ⇒ p I m ⇒ q I m ⇒ (¬((¬p ≡ q) ∧ (¬l ≡ m))))

Lemma: pgeo-dual_wf2
∀[pg:BasicProjectivePlane]. (pg* ∈ BasicProjectivePlane)

Lemma: dual-point-subtype
∀[pg:BasicProjectivePlane]. (Point ⊆r Line)

Lemma: dual-line-subtype
∀[pg:BasicProjectivePlane]. (Line ⊆r Point)

Lemma: Unique
∀g:BasicProjectivePlane. ∀[l,m:Line]. ∀[p,q:Point].  ¬((¬p ≡ q) ∧ (¬l ≡ m)) supposing p I l ∧ q I l ∧ p I m ∧ q I m

Lemma: pgeo-plsep-to-psep
∀g:ProjectivePlaneStructure. ∀a,b:Point. ∀l:Line.  (pgeo-plsep(g; a; l) ⇒ b I l ⇒ b ≠ a)

Lemma: pgeo-plsep-to-lsep
∀g:ProjectivePlaneStructure. ∀a,b:Line. ∀l:Point.  (pgeo-plsep(g; l; a) ⇒ l I b ⇒ b ≠ a)

Lemma: incident-join-first
∀g:ProjectivePlaneStructure. ∀p,q:Point. ∀s:p ≠ q.  p I p ∨ q

Lemma: psep-join-implies-false
∀g:ProjectivePlaneStructure. ∀p,q:Point. ∀s:p ≠ q.  (pgeo-plsep(g; p; p ∨ q) ⇒ False)

Lemma: incident-join-second
∀g:ProjectivePlaneStructure. ∀p,q:Point. ∀s:p ≠ q.  q I p ∨ q

Lemma: pgeo-join-to-line
∀g:BasicProjectivePlane. ∀p,q:Point. ∀l:Line. ∀s:p ≠ q.  (p I l ⇒ q I l ⇒ p ∨ q ≡ l)

Lemma: pgeo-join-to-line_dual
∀g:BasicProjectivePlane. ∀p,q:Line. ∀l:Point. ∀s:p ≠ q.  (l I p ⇒ l I q ⇒ p ∧ q ≡ l)

Lemma: pgeo-join-to-line-2
∀g:BasicProjectivePlane. ∀p,q:Point. ∀l:Line. ∀s:p ≠ q.  (p I l ⇒ q I l ⇒ l ≡ p ∨ q)

Lemma: pgeo-plsep-implies-join
∀g:BasicProjectivePlane. ∀c:Point. ∀l:Line.
  (pgeo-plsep(g; c; l) ⇒ (∀a,b:Point. ∀s:a ≠ b.  ((a I l ∧ b I l) ⇒ pgeo-plsep(g; c; a ∨ b))))

Lemma: pgeo-meet-to-point
∀g:BasicProjectivePlane. ∀p,q:Line. ∀l:Point. ∀s:p ≠ q.  (l I p ⇒ l I q ⇒ l ≡ p ∧ q)

Lemma: pgeo-meet-incidence
∀g:BasicProjectivePlane. ∀l,m:Line. ∀s:l ≠ m.  (l ∧ m I l ∧ l ∧ m I m)

Lemma: pgeo-join-implies-plsep
∀g:BasicProjectivePlane. ∀a,b,c:Point. ∀s:a ≠ b.
  (pgeo-plsep(g; c; a ∨ b) ⇒ (∀l:Line. ((a I l ∧ b I l) ⇒ pgeo-plsep(g; c; l))))

Lemma: pgeo-meet-implies-plsep
∀g:BasicProjectivePlane. ∀a,b,c:Line. ∀s:a ≠ b.
  (pgeo-plsep(g; a ∧ b; c) ⇒ (∀l:Point. ((l I a ∧ l I b) ⇒ pgeo-plsep(g; l; c))))

Lemma: pgeo-meet-implies-lsep
∀g:BasicProjectivePlane. ∀l,m,n:Line. ∀s:l ≠ m.  (pgeo-plsep(g; l ∧ m; n) ⇒ {l ≠ n ∧ m ≠ n})

Lemma: pgeo-meet-implies-psep
∀g:BasicProjectivePlane. ∀l,m:Line. ∀s:l ≠ m. ∀a:Point. ∀c:{c:Point| c I l ∧ c I m} .  (a ≠ l ∧ m ⇒ a ≠ c)

Definition: triangle-axiom1
triangle-axiom1(g) ==  ∀p,q,r:Point. ∀s:p ≠ q. ∀s1:q ≠ r.  (pgeo-plsep(g; r; p ∨ q) ⇒ pgeo-plsep(g; p; q ∨ r))

Lemma: triangle-axiom1_wf
∀g:BasicProjectivePlane. (triangle-axiom1(g) ∈ ℙ)

Definition: triangle-axiom2
triangle-axiom2(g) ==
  ∀p,q:Point. ∀l,m:Line. ∀s:p ≠ q. ∀s1:l ≠ m.
    (pgeo-plsep(g; p; l) ⇒ pgeo-plsep(g; q; m) ⇒ p I m ⇒ q I l ⇒ pgeo-plsep(g; l ∧ m; p ∨ q))

Lemma: triangle-axiom2_wf
∀g:BasicProjectivePlane. (triangle-axiom2(g) ∈ ℙ)

Definition: projective-plane
ProjectivePlane ==
  {g:ProjectivePlaneStructureComplete| BasicProjectiveGeometryAxioms(g) ∧ triangle-axiom1(g) ∧ triangle-axiom2(g)} 

Lemma: projective-plane_wf
ProjectivePlane ∈ 𝕌'

Lemma: projective-plane-subtype
ProjectivePlane ⊆r ProjectivePlaneStructureComplete

Lemma: projective-plane-subtype-basic
ProjectivePlane ⊆r BasicProjectivePlane

Lemma: projective-plane-axioms
∀g:ProjectivePlane
  ((∀p,q,r:Point. ∀s:p ≠ q. ∀s1:q ≠ r.  (pgeo-plsep(g; r; p ∨ q) ⇒ pgeo-plsep(g; p; q ∨ r)))
  ∧ (∀p,q:Point. ∀l,m:Line. ∀s:p ≠ q. ∀s1:l ≠ m.
       (pgeo-plsep(g; p; l) ⇒ pgeo-plsep(g; q; m) ⇒ p I m ⇒ q I l ⇒ pgeo-plsep(g; l ∧ m; p ∨ q))))

Lemma: use-triangle-axiom1
∀g:ProjectivePlane. ∀p,q,r:Point. ∀s:p ≠ q. ∀s1:q ≠ r.  (pgeo-plsep(g; r; p ∨ q) ⇒ pgeo-plsep(g; p; q ∨ r))

Lemma: use-triangle-axiom2
∀g:ProjectivePlane. ∀p,q:Point. ∀l,m:Line. ∀s:p ≠ q. ∀s1:l ≠ m.
  (pgeo-plsep(g; p; l) ⇒ pgeo-plsep(g; q; m) ⇒ p I m ⇒ q I l ⇒ pgeo-plsep(g; l ∧ m; p ∨ q))

Lemma: plsep-join-implies
∀g:ProjectivePlane. ∀p,q,r:Point. ∀s:p ≠ q.  (pgeo-plsep(g; r; p ∨ q) ⇒ {q ≠ r ∧ p ≠ r})

Lemma: point-implies-plsep-exists
∀g:ProjectivePlane. ∀a:Point.  ∃l:Line. pgeo-plsep(g; a; l)

Lemma: line-implies-plsep-exists
∀g:ProjectivePlane. ∀l:Line.  ∃p:Point. pgeo-plsep(g; p; l)

Lemma: plsep-implies-ptriangle
∀g:ProjectivePlane. ∀p:Point. ∀l:Line. ∀q:Point. ∀s:q ≠ p.
  (pgeo-plsep(g; p; l) ⇒ q I l ⇒ (∃r:Point. (r I l ∧ pgeo-plsep(g; r; q ∨ p))))

Lemma: pgeo-psep-sym
∀g:ProjectivePlane. ∀p,q:Point.  (p ≠ q ⇒ q ≠ p)

Lemma: pgeo-lsep-sym
∀g:ProjectivePlane. ∀l,m:Line.  (l ≠ m ⇒ m ≠ l)

Lemma: pgeo-leq-sym
∀g:ProjectivePlane. ∀l,m:Line.  (l ≡ m ⇒ m ≡ l)

Lemma: pgeo-meet-implies-psep2
∀g:ProjectivePlane. ∀l,m:Line. ∀s:l ≠ m. ∀a:Point. ∀c:{c:Point| c I l ∧ c I m} .  (a ≠ c ⇒ a ≠ l ∧ m)

Lemma: pgeo-lsep-or
∀g:BasicProjectivePlane. ∀l,m,n:Line.  (l ≠ m ⇒ (l ≠ n ∨ n ≠ m))

Lemma: pgeo-lsep-implies-plsep
∀g:ProjectivePlane. ∀p:Point. ∀l,m:Line. ∀s:l ≠ m.  (p I l ⇒ p ≠ l ∧ m ⇒ pgeo-plsep(g; p; m))

Lemma: pgeo-psep-sym-iff
∀g:ProjectivePlane. ∀p,q:Point.  (p ≠ q ⇐⇒ q ≠ p)

Lemma: pgeo-psep-or
∀g:ProjectivePlane. ∀p,q,r:Point.  (p ≠ q ⇒ {p ≠ r ∨ r ≠ q})

Lemma: pgeo-peq-preserves-incidence
∀g:ProjectivePlane. ∀a,b:Point. ∀l:Line.  (a I l ⇒ a ≡ b ⇒ b I l)

Lemma: pgeo-leq-preserves-incidence
∀g:ProjectivePlane. ∀a:Point. ∀l,m:Line.  (a I l ⇒ l ≡ m ⇒ a I m)

Lemma: pgeo-peq-preserves-plsep
∀g:ProjectivePlane. ∀a,b:Point. ∀l:Line.  (pgeo-plsep(g; a; l) ⇒ a ≡ b ⇒ pgeo-plsep(g; b; l))

Lemma: pgeo-leq-preserves-plsep
∀g:ProjectivePlane. ∀a:Point. ∀l,m:Line.  (pgeo-plsep(g; a; l) ⇒ l ≡ m ⇒ pgeo-plsep(g; a; m))

Lemma: pgeo-peq-sym
∀g:ProjectivePlane. ∀a,b:Point.  (a ≡ b ⇒ b ≡ a)

Lemma: pgeo-leq_weakening
∀g:ProjectivePlane. ∀l,m:Line.  ((l = m ∈ Line) ⇒ l ≡ m)

Lemma: pgeo-leq_inversion
∀g:ProjectivePlane. ∀l,m:Line.  (l ≡ m ⇒ m ≡ l)

Lemma: pgeo-leq_transitivity
∀g:ProjectivePlane. ∀l,m,n:Line.  (l ≡ m ⇒ m ≡ n ⇒ l ≡ n)

Lemma: pgeo-leq-equiv
∀g:ProjectivePlane. EquivRel(Line;p,q.p ≡ q)

Lemma: pgeo-leq-test
∀g:ProjectivePlane. ∀l,m,l1,m1:Line.  (l ≡ l1 ⇒ m ≡ m1 ⇒ l ≡ m ⇒ l1 ≡ m1)

Lemma: pgeo-plsep_functionality
∀g:ProjectivePlane. ∀a,a1:Point. ∀l,l1:Line.  (a ≡ a1 ⇒ l ≡ l1 ⇒ {pgeo-plsep(g; a; l) ⇐⇒ pgeo-plsep(g; a1; l1)})

Lemma: pgeo-peq_weakening
∀g:ProjectivePlane. ∀l,m:Point.  ((l = m ∈ Point) ⇒ l ≡ m)

Lemma: pgeo-peq_inversion
∀g:ProjectivePlane. ∀l,m:Point.  (l ≡ m ⇒ m ≡ l)

Lemma: pgeo-peq_transitivity
∀g:ProjectivePlane. ∀a,b,c:Point.  (a ≡ b ⇒ b ≡ c ⇒ a ≡ c)

Lemma: pgeo-peq-equiv
∀g:ProjectivePlane. EquivRel(Point;p,q.p ≡ q)

Lemma: pgeo-psep-test
∀g:ProjectivePlane. ∀a,b,a1,b1:Point.  (a ≡ a1 ⇒ b ≡ b1 ⇒ a ≡ b ⇒ a1 ≡ b1)

Lemma: pgeo-plsep-iff-all-psep
∀g:ProjectivePlane. ∀p:Point. ∀l:Line.  (pgeo-plsep(g; p; l) ⇐⇒ ∀q:Point. (q I l ⇒ p ≠ q))

Lemma: pgeo-meet-psep-sym
∀g:ProjectivePlane. ∀l,m:Line. ∀a:Point. ∀s:l ≠ m. ∀s2:m ≠ l.  (l ∧ m ≠ a ⇒ m ∧ l ≠ a)

Lemma: pgeo-meet-psep-implies-false
∀g:ProjectivePlane. ∀l,m:Line. ∀s:l ≠ m. ∀s2:m ≠ l.  (m ∧ l ≠ l ∧ m ⇒ False)

Lemma: pgeo-meet-plsep-sym
∀g:ProjectivePlane. ∀l,m,n:Line. ∀s:l ≠ m. ∀s2:m ≠ l.  (pgeo-plsep(g; l ∧ m; n) ⇒ pgeo-plsep(g; m ∧ l; n))

Lemma: pgeo-triangle-axiom1-dual
∀g:ProjectivePlane. ∀l,m,n:Line. ∀s:l ≠ m. ∀s1:m ≠ n.  (pgeo-plsep(g; l ∧ m; n) ⇒ pgeo-plsep(g; m ∧ n; l))

Lemma: pgeo-triangle-axiom2-dual
∀g:ProjectivePlane. ∀p,q:Line. ∀l,m:Point. ∀s:p ≠ q. ∀s1:l ≠ m.
  (pgeo-plsep(g; l; p) ⇒ pgeo-plsep(g; m; q) ⇒ m I p ⇒ l I q ⇒ pgeo-plsep(g; p ∧ q; l ∨ m))

Lemma: pgeo-non-trivial-dual
∀g:ProjectivePlane. (∃l:Line [l ≡ l])

Lemma: pgeo-non-trivial-dual-ext
∀g:ProjectivePlane. (∃l:Line [l ≡ l])

Definition: dual-plane
dual-plane(pg) ==  complete-pgeo-dual(pg;let p,_ = pg "non-trivial" in let l,_ = pg "three-lines" p in l)

Lemma: dual-plane_wf
∀[pg:ProjectivePlane]. (dual-plane(pg) ∈ ProjectivePlane)

Lemma: pgeo-lsep-implies-plsep_dual
∀g:ProjectivePlane. ∀p:Line. ∀l,m:Point. ∀s:l ≠ m.  (l I p ⇒ p ≠ l ∨ m ⇒ pgeo-plsep(g; m; p))

Lemma: pgeo-plsep-to-psep2
∀g:ProjectivePlane. ∀a:Point. ∀l:Line.  (pgeo-plsep(g; a; l) ⇒ (∀b:{b:Point| b I l} . a ≠ b))

Definition: distinct-triangles
distinct-triangles(pg;t1;t2) ==
  (fst(t1) ≠ fst(t2) ∧ fst(t1) ≠ fst(snd(t2)) ∧ fst(t1) ≠ fst(snd(snd(t2))))
  ∧ (fst(snd(t1)) ≠ fst(t2) ∧ fst(snd(t1)) ≠ fst(snd(t2)) ∧ fst(snd(t1)) ≠ fst(snd(snd(t2))))
  ∧ fst(snd(snd(t1))) ≠ fst(t2)
  ∧ fst(snd(snd(t1))) ≠ fst(snd(t2))
  ∧ fst(snd(snd(t1))) ≠ fst(snd(snd(t2)))

Lemma: pgeo-join-lsep-sym
∀pg:ProjectivePlane. ∀l,m:Point. ∀a:Line. ∀s:l ≠ m. ∀s2:m ≠ l.  (l ∨ m ≠ a ⇒ m ∨ l ≠ a)

Lemma: pgeo-join-plsep-sym
∀pg:ProjectivePlane. ∀a,b,c:Point. ∀s:a ≠ b. ∀s2:b ≠ a.  (pgeo-plsep(pg; c; a ∨ b) ⇒ pgeo-plsep(pg; c; b ∨ a))

Definition: point-triangle
PΔ(a;b;c) ==  ∀a,b,c:Point. ∀s:b ≠ c.  pgeo-plsep(g; a; b ∨ c)

Lemma: point-triangle_wf
∀g:ProjectivePlane. ∀a,b,c:Point.  (PΔ(a;b;c) ∈ ℙ)

Definition: line-triangle
LΔ(l;m;n) ==  ∀l,m,n:Line. ∀s:m ≠ n.  pgeo-plsep(g; m ∧ n; l)

Lemma: line-triangle_wf
∀g:ProjectivePlane. ∀l,m,n:Line.  (LΔ(l;m;n) ∈ ℙ)

Definition: point-sep-from-line-triangle
p ≠ LΔ(l;m;n) ==
  ∀p:Point. ∀l,m,n:Line.  (((pgeo-plsep(g; p; l) ∧ pgeo-plsep(g; p; m)) ∧ pgeo-plsep(g; p; n)) ∧ LΔ(l;m;n))

Lemma: point-sep-from-line-triangle_wf
∀g:ProjectivePlane. ∀p:Point. ∀l,m,n:Line.  (p ≠ LΔ(l;m;n) ∈ ℙ)

Definition: line-sep-from-point-triangle
l ≠ PΔ(a;b;c) ==
  ∀l:Line. ∀a,b,c:Point.  (((pgeo-plsep(g; a; l) ∧ pgeo-plsep(g; b; l)) ∧ pgeo-plsep(g; c; l)) ∧ PΔ(a;b;c))

Lemma: line-sep-from-point-triangle_wf
∀g:ProjectivePlane. ∀l:Line. ∀a,b,c:Point.  (l ≠ PΔ(a;b;c) ∈ ℙ)

Lemma: pgeo-plsep-cycle
∀g:ProjectivePlane. ∀a,b,c:Point. ∀s:a ≠ b. ∀s1:b ≠ c. ∀s2:a ≠ c.
  (pgeo-plsep(g; a; b ∨ c) ⇒ {pgeo-plsep(g; b; a ∨ c) ∧ pgeo-plsep(g; c; a ∨ b)})

Definition: pgeo-triangle
pgeo-triangle(pg) ==  a:Point × b:Point × c:Point × s:b ≠ c × pgeo-plsep(pg; a; b ∨ c)

Lemma: pgeo-triangle_wf
∀[pg:ProjectivePlane]. (pgeo-triangle(pg) ∈ Type)

Lemma: distinct-triangles_wf
∀pg:ProjectivePlane. ∀t1,t2:pgeo-triangle(pg).  (distinct-triangles(pg;t1;t2) ∈ ℙ)

Lemma: pgeo-triangle-dual
∀pg:ProjectivePlane. ∀t:pgeo-triangle(pg).
  ∃t*:pgeo-triangle(pg*)
   let a,b,c,s,s' = t in let lab,lbc,lca,s1,s2 = t* in a I lab ∧ b I lab ∧ b I lbc ∧ c I lbc ∧ c I lca ∧ a I lca

Definition: point-perspective
pPerspective(PΔ(a;b;c);PΔ(A;B;C);o) ==  ∀t1,t2:pgeo-triangle(g).  fst(t1) ≠ fst(t2)

Lemma: point-perspective_wf
∀g:ProjectivePlane. ∀a,b,c,A,B,C,o:Point.  (pPerspective(PΔ(a;b;c);PΔ(A;B;C);o) ∈ ℙ)

Definition: line-perspective
LPerspective(LΔ(l;m;n);LΔ(L;M;N);y) ==
  ∀l,m,n,L,M,N,y:Line. ∀s1:l ≠ L. ∀s2:m ≠ M. ∀s3:n ≠ N.  ((LΔ(l;m;n) ∧ LΔ(L;M;N)) ∧ (l ∧ L I y ∧ m ∧ M I y) ∧ n ∧ N I y)

Lemma: line-perspective_wf
∀g:ProjectivePlane. ∀l,m,n,L,M,N,y:Line.  (LPerspective(LΔ(l;m;n);LΔ(L;M;N);y) ∈ ℙ)

Lemma: pgeo-meet-line-uniqueness
∀g:ProjectivePlane. ∀a,b:Point. ∀l,m:Line.  (a ≠ b ⇒ (a I l ∧ a I m) ⇒ (b I l ∧ b I m) ⇒ l ≡ m)

Lemma: pgeo-triangle-axiom1-sym
∀g:ProjectivePlane. ∀a,b,c:Point. ∀s:b ≠ a. ∀s1:a ≠ c.  (pgeo-plsep(g; c; b ∨ a) ⇒ pgeo-plsep(g; b; a ∨ c))

Lemma: pgeo-sep-points-exist
∀g:ProjectivePlane. ∃a,b:Point. a ≠ b

Lemma: pgeo-lsep-implies-plsep-or
∀g:ProjectivePlane. ∀p:Point. ∀l,m:Line. ∀s:l ≠ m.  (p ≠ l ∧ m ⇒ (pgeo-plsep(g; p; m) ∨ pgeo-plsep(g; p; l)))

Comment: existence of projective planes doc
From any integral domain with decidable equality, we can construct a 
projective plane. (see rng-pps_wf)⋅

Definition: rng-pp-primitives
rng-pp-primitives(r) ==  points={p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))}  lines={p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))}  plse\000Cp=λp,l. (¬((p . l) = 0 ∈ |r|))

Lemma: rng-pp-primitives_wf
∀[r:Rng]. (rng-pp-primitives(r) ∈ ProjGeomPrimitives)

Lemma: rng-pp-nontrivial-1
∀r:IntegDom{i}
  ((∀x,y:|r|.  Dec(x = y ∈ |r|))
  ⇒ (∀l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
        ∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
         (∃b:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))}  [(((a . l) = 0 ∈ |r|)
                                               ∧ ((b . l) = 0 ∈ |r|)
                                               ∧ (¬((a x b) = 0 ∈ (ℕ3 ⟶ |r|))))])))

Lemma: rng-pp-nontrivial-1-ext
∀r:IntegDom{i}
  ((∀x,y:|r|.  Dec(x = y ∈ |r|))
  ⇒ (∀l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
        ∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
         (∃b:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))}  [(((a . l) = 0 ∈ |r|)
                                               ∧ ((b . l) = 0 ∈ |r|)
                                               ∧ (¬((a x b) = 0 ∈ (ℕ3 ⟶ |r|))))])))

Lemma: rng-pp-nontrivial-2
∀r:IntegDom{i}
  ((∀x,y:|r|.  Dec(x = y ∈ |r|))
  ⇒ (∀l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
        ∃a,b,c:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
         (((a . l) = 0 ∈ |r|)
         ∧ ((b . l) = 0 ∈ |r|)
         ∧ ((c . l) = 0 ∈ |r|)
         ∧ (¬((a x b) = 0 ∈ (ℕ3 ⟶ |r|)))
         ∧ (¬((b x c) = 0 ∈ (ℕ3 ⟶ |r|)))
         ∧ (¬((c x a) = 0 ∈ (ℕ3 ⟶ |r|))))))

Lemma: rng-pp-nontrivial-3
∀r:IntegDom{i}. ∀eq:EqDecider(|r|). ∀l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} .
  ∃a,b,c:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
   ((¬¬((a . l) = 0 ∈ |r|))
   ∧ (¬¬((b . l) = 0 ∈ |r|))
   ∧ (¬¬((c . l) = 0 ∈ |r|))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((b . l) = 0 ∈ |r|))))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((b . l) = 0 ∈ |r|)) ∧ (¬((c . l) = 0 ∈ |r|))))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((c . l) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|)))))

Definition: rng-pp-nontriv1
rng-pp-nontriv1(r;eq;l) ==
  eval x = non-zero-component(r;λx,y. (eq x y);3;l) in
  if x=0
  then <λx.if x=1 then l 0 else if x=0 then -r (l 1) else 0
       , λx.if x=2 then l 0 else if x=0 then -r (l 2) else 0
       , (λx.if x=1 then l 0 else if x=0 then -r (l 1) else 0 + λx.if x=2 then l 0 else if x=0 then -r (l 2) else 0)
       , λ%.Ax
       , λ%.Ax
       , λ%.Ax
       , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=1 then l 0 else if x=0 then -r (l 1) else 0;λx.if x=2
                                                                                                then l 0
                                                                                                else if x=0
                                                                                                     then -r (l 2)
                                                                                                     else 0)
         , λ%.Ax
         , λ%.Ax>
       , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=2
                                            then l 0
                                            else if x=0 then -r (l 2) else 0;(λx.if x=1
                                                                                 then l 0
                                                                                 else if x=0
                                                                                      then -r (l 1)
                                                                                      else 0 + λx.if x=2
                                                                                                  then l 0
                                                                                                  else if x=0
                                                                                                       then -r (l 2)
                                                                                                       else 0))
         , λ%.Ax
         , λ%.Ax>
       , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if x=1
                                            then l 0
                                            else if x=0 then -r (l 1) else 0 + λx.if x=2
                                                                                  then l 0
                                                                                  else if x=0
                                                                                       then -r (l 2)
                                                                                       else 0);λx.if x=1
                                                                                                  then l 0
                                                                                                  else if x=0
                                                                                                       then -r (l 1)
                                                                                                       else 0)
       , λ%.Ax
       , λ%.Ax>
  else if x=1
       then <λx.if x=0 then l 1 else if x=1 then -r (l 0) else 0
            , λx.if x=2 then l 1 else if x=1 then -r (l 2) else 0
            , (λx.if x=0 then l 1 else if x=1 then -r (l 0) else 0 + λx.if x=2
                                                                        then l 1
                                                                        else if x=1 then -r (l 2) else 0)
            , λ%.Ax
            , λ%.Ax
            , λ%.Ax
            , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=0 then l 1 else if x=1 then -r (l 0) else 0;λx.if x=2
                                                                                                     then l 1
                                                                                                     else if x=1
                                                                                                          then -r (l 2)
                                                                                                          else 0)
              , λ%.Ax
              , λ%.Ax>
            , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=2
                                                 then l 1
                                                 else if x=1 then -r (l 2) else 0;(λx.if x=0
                                                                                      then l 1
                                                                                      else if x=1
                                                                                           then -r (l 0)
                                                                                           else 0 + λx.if x=2
                                                                                                       then l 1
                                                                                                       else if x=1
                                                                                                            then -r 
                                                                                                                 (l 2)
                                                                                                            else 0))
              , λ%.Ax
              , λ%.Ax>
            , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if x=0
                                                 then l 1
                                                 else if x=1 then -r (l 0) else 0 + λx.if x=2
                                                                                       then l 1
                                                                                       else if x=1
                                                                                            then -r (l 2)
                                                                                            else 0);λx.if x=0
                                                                                                       then l 1
                                                                                                       else if x=1
                                                                                                            then -r 
                                                                                                                 (l 0)
                                                                                                            else 0)
            , λ%.Ax
            , λ%.Ax>
       else if x=2
            then <λx.if x=0 then l 2 else if x=2 then -r (l 0) else 0
                 , λx.if x=1 then l 2 else if x=2 then -r (l 1) else 0
                 , (λx.if x=0 then l 2 else if x=2 then -r (l 0) else 0 + λx.if x=1
                                                                             then l 2
                                                                             else if x=2 then -r (l 1) else 0)
                 , λ%.Ax
                 , λ%.Ax
                 , λ%.Ax
                 , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=0 then l 2 else if x=2 then -r (l 0) else 0;λx.if x=1
                                                                                                          then l 2
                                                                                                          else if x=2
                                                                                                               then -r 
                                                                                                                    (l 
                                                                                                                     1)
                                                                                                               else 0)
                   , λ%.Ax
                   , λ%.Ax>
                 , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=1
                                                      then l 2
                                                      else if x=2
                                                           then -r (l 1)
                                                           else 0;(λx.if x=0
                                                                      then l 2
                                                                      else if x=2
                                                                           then -r (l 0)
                                                                           else 0 + λx.if x=1
                                                                                       then l 2
                                                                                       else if x=2
                                                                                            then -r (l 1)
                                                                                            else 0))
                   , λ%.Ax
                   , λ%.Ax>
                 , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if ...=... then ... else ... + ...);...)
                 , ...>
            else ...

Lemma: rng-pp-nontrivial-3-ext
∀r:IntegDom{i}. ∀eq:EqDecider(|r|). ∀l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} .
  ∃a,b,c:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
   ((¬¬((a . l) = 0 ∈ |r|))
   ∧ (¬¬((b . l) = 0 ∈ |r|))
   ∧ (¬¬((c . l) = 0 ∈ |r|))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((b . l) = 0 ∈ |r|))))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((b . l) = 0 ∈ |r|)) ∧ (¬((c . l) = 0 ∈ |r|))))
   ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((c . l) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|)))))

Lemma: rng-pp-nontriv1_wf
∀[r:IntegDom{i}]. ∀[eq:EqDecider(|r|)]. ∀[l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} ].
  (rng-pp-nontriv1(r;eq;l) ∈ ∃a,b,c:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                              ((¬¬((a . l) = 0 ∈ |r|))
                              ∧ (¬¬((b . l) = 0 ∈ |r|))
                              ∧ (¬¬((c . l) = 0 ∈ |r|))
                              ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((b . l) = 0 ∈ |r|))))
                              ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((b . l) = 0 ∈ |r|)) ∧ (¬((c . l) = 0 ∈ |r|))))
                              ∧ (∃l:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((c . l) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|))))))

Lemma: rng-pp-nontrivial-4
∀r:IntegDom{i}. ∀eq:EqDecider(|r|). ∀p:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} .
  ∃l,m,n:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
   ((¬¬((p . l) = 0 ∈ |r|))
   ∧ (¬¬((p . m) = 0 ∈ |r|))
   ∧ (¬¬((p . n) = 0 ∈ |r|))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((a . m) = 0 ∈ |r|))))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . m) = 0 ∈ |r|)) ∧ (¬((a . n) = 0 ∈ |r|))))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . n) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|)))))

Definition: rng-pp-nontriv2
rng-pp-nontriv2(r;eq;p) ==
  eval x = non-zero-component(r;λx,y. (eq x y);3;p) in
  if x=0
  then <λx.if x=1 then p 0 else if x=0 then -r (p 1) else 0
       , λx.if x=2 then p 0 else if x=0 then -r (p 2) else 0
       , (λx.if x=1 then p 0 else if x=0 then -r (p 1) else 0 + λx.if x=2 then p 0 else if x=0 then -r (p 2) else 0)
       , λ%.Ax
       , λ%.Ax
       , λ%.Ax
       , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=1 then p 0 else if x=0 then -r (p 1) else 0;λx.if x=2
                                                                                                then p 0
                                                                                                else if x=0
                                                                                                     then -r (p 2)
                                                                                                     else 0)
         , λ%.Ax
         , λ%.Ax>
       , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=2
                                            then p 0
                                            else if x=0 then -r (p 2) else 0;(λx.if x=1
                                                                                 then p 0
                                                                                 else if x=0
                                                                                      then -r (p 1)
                                                                                      else 0 + λx.if x=2
                                                                                                  then p 0
                                                                                                  else if x=0
                                                                                                       then -r (p 2)
                                                                                                       else 0))
         , λ%.Ax
         , λ%.Ax>
       , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if x=1
                                            then p 0
                                            else if x=0 then -r (p 1) else 0 + λx.if x=2
                                                                                  then p 0
                                                                                  else if x=0
                                                                                       then -r (p 2)
                                                                                       else 0);λx.if x=1
                                                                                                  then p 0
                                                                                                  else if x=0
                                                                                                       then -r (p 1)
                                                                                                       else 0)
       , λ%.Ax
       , λ%.Ax>
  else if x=1
       then <λx.if x=0 then p 1 else if x=1 then -r (p 0) else 0
            , λx.if x=2 then p 1 else if x=1 then -r (p 2) else 0
            , (λx.if x=0 then p 1 else if x=1 then -r (p 0) else 0 + λx.if x=2
                                                                        then p 1
                                                                        else if x=1 then -r (p 2) else 0)
            , λ%.Ax
            , λ%.Ax
            , λ%.Ax
            , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=0 then p 1 else if x=1 then -r (p 0) else 0;λx.if x=2
                                                                                                     then p 1
                                                                                                     else if x=1
                                                                                                          then -r (p 2)
                                                                                                          else 0)
              , λ%.Ax
              , λ%.Ax>
            , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=2
                                                 then p 1
                                                 else if x=1 then -r (p 2) else 0;(λx.if x=0
                                                                                      then p 1
                                                                                      else if x=1
                                                                                           then -r (p 0)
                                                                                           else 0 + λx.if x=2
                                                                                                       then p 1
                                                                                                       else if x=1
                                                                                                            then -r 
                                                                                                                 (p 2)
                                                                                                            else 0))
              , λ%.Ax
              , λ%.Ax>
            , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if x=0
                                                 then p 1
                                                 else if x=1 then -r (p 0) else 0 + λx.if x=2
                                                                                       then p 1
                                                                                       else if x=1
                                                                                            then -r (p 2)
                                                                                            else 0);λx.if x=0
                                                                                                       then p 1
                                                                                                       else if x=1
                                                                                                            then -r 
                                                                                                                 (p 0)
                                                                                                            else 0)
            , λ%.Ax
            , λ%.Ax>
       else if x=2
            then <λx.if x=0 then p 2 else if x=2 then -r (p 0) else 0
                 , λx.if x=1 then p 2 else if x=2 then -r (p 1) else 0
                 , (λx.if x=0 then p 2 else if x=2 then -r (p 0) else 0 + λx.if x=1
                                                                             then p 2
                                                                             else if x=2 then -r (p 1) else 0)
                 , λ%.Ax
                 , λ%.Ax
                 , λ%.Ax
                 , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=0 then p 2 else if x=2 then -r (p 0) else 0;λx.if x=1
                                                                                                          then p 2
                                                                                                          else if x=2
                                                                                                               then -r 
                                                                                                                    (p 
                                                                                                                     1)
                                                                                                               else 0)
                   , λ%.Ax
                   , λ%.Ax>
                 , <nonzero-cross-imp(r;λx,y. (eq x y);λx.if x=1
                                                      then p 2
                                                      else if x=2
                                                           then -r (p 1)
                                                           else 0;(λx.if x=0
                                                                      then p 2
                                                                      else if x=2
                                                                           then -r (p 0)
                                                                           else 0 + λx.if x=1
                                                                                       then p 2
                                                                                       else if x=2
                                                                                            then -r (p 1)
                                                                                            else 0))
                   , λ%.Ax
                   , λ%.Ax>
                 , nonzero-cross-imp(r;λx,y. (eq x y);(λx.if ...=... then ... else ... + ...);...)
                 , ...>
            else ...

Lemma: rng-pp-nontrivial-4-ext
∀r:IntegDom{i}. ∀eq:EqDecider(|r|). ∀a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} .
  ∃l,m,n:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
   ((¬¬((a . l) = 0 ∈ |r|))
   ∧ (¬¬((a . m) = 0 ∈ |r|))
   ∧ (¬¬((a . n) = 0 ∈ |r|))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((a . m) = 0 ∈ |r|))))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . m) = 0 ∈ |r|)) ∧ (¬((a . n) = 0 ∈ |r|))))
   ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} . ((¬¬((a . n) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|)))))

Lemma: rng-pp-nontriv2_wf
∀[r:IntegDom{i}]. ∀[eq:EqDecider(|r|)]. ∀[a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} ].
  (rng-pp-nontriv2(r;eq;a) ∈ ∃l,m,n:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                              ((¬¬((a . l) = 0 ∈ |r|))
                              ∧ (¬¬((a . m) = 0 ∈ |r|))
                              ∧ (¬¬((a . n) = 0 ∈ |r|))
                              ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((a . l) = 0 ∈ |r|)) ∧ (¬((a . m) = 0 ∈ |r|))))
                              ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((a . m) = 0 ∈ |r|)) ∧ (¬((a . n) = 0 ∈ |r|))))
                              ∧ (∃a:{p:ℕ3 ⟶ |r|| ¬(p = 0 ∈ (ℕ3 ⟶ |r|))} 
                                  ((¬¬((a . n) = 0 ∈ |r|)) ∧ (¬((a . l) = 0 ∈ |r|))))))

Definition: rng-pps
rng-pps(r;eq) ==
  mk-complete-pgeo(mk-pgeo(rng-pp-primitives(r);
                           λl,a,v,v. Ax;
                           λa,l,m. if eq (a . m) 0 then inr <a, λnp.(np Ax), λ%6.Ax>  else inl (λ%.Ax) fi ;
                           λl,a,b. if eq (b . l) 0 then inr <l, λnp.(np Ax), λ%6.Ax>  else inl (λ%.Ax) fi ;
                           λa,b,_. <(a x b), λ_.Ax, λ_.Ax>;
                           λa,b,_. <(a x b), λ_.Ax, λ_.Ax>;
                           λl.rng-pp-nontriv1(r;eq;l);
                           λa.rng-pp-nontriv2(r;eq;a));λi.1)

Lemma: rng-pps_wf
∀r:IntegDom{i}. ∀[eq:EqDecider(|r|)]. (rng-pps(r;eq) ∈ ProjectivePlane)

Definition: pgeo-point-class
PointClass ==  p,q:Point//p ≡ q

Lemma: pgeo-point-class_wf
∀[g:ProjectivePlane]. (PointClass ∈ Type)

Definition: pgeo-line-class
LineClass ==  l,m:Line//l ≡ m

Lemma: pgeo-line-class_wf
∀[g:ProjectivePlane]. (LineClass ∈ Type)

Definition: pgeo-plsep-class
pc # lc ==  ∃p:Point. ∃l:Line. ((p = pc ∈ PointClass) ∧ (l = lc ∈ LineClass) ∧ pgeo-plsep(g; p; l))

Lemma: pgeo-plsep-class_wf
∀[g:ProjectivePlane]. ∀[pc:PointClass]. ∀[lc:LineClass].  (pc # lc ∈ ℙ)

Definition: pgeo-incident-class
pc I lc ==  ¬pc # lc

Lemma: pgeo-incident-class_wf
∀[g:ProjectivePlane]. ∀[pc:PointClass]. ∀[lc:LineClass].  (pc I lc ∈ ℙ)

Definition: pgeo-lsep-class
pgeo-lsep-class(g;m;n) ==  ∃l',l:Line. ((l' = m ∈ LineClass) ∧ (l = n ∈ LineClass) ∧ l' ≠ l)

Lemma: pgeo-lsep-class_wf
∀[g:ProjectivePlane]. ∀[m,n:LineClass].  (pgeo-lsep-class(g;m;n) ∈ ℙ)

Lemma: pgeo-psep-irrefl
∀e:ProjectivePlane. ∀[a,b:Point].  ¬a ≠ b supposing a = b ∈ Point

Lemma: pgeo-psep-irrefl2
∀e:ProjectivePlane. ∀[a,b:Point].  ¬(a = b ∈ Point) supposing a ≠ b

Definition: pgeo-order
order(pg) = n ==  ∀l:Line. p,q:{p:Point| p I l} //p ≡ q ~ ℕn + 1

Lemma: pgeo-order-equiv_rel
∀pg:ProjectivePlane. ∀l:Line.  EquivRel({p:Point| p I l} ;p,q.p ≡ q)

Lemma: pgeo-order_wf
∀pg:ProjectivePlane. ∀n:ℕ.  (order(pg) = n ∈ ℙ)

Lemma: pgeo-order_2-incidence
∀pg:ProjectivePlane. ∀l:Line.  (order(pg) = 2 ⇒ p,q:{p:Point| p I l} //p ≡ q ~ ℕ3)

Lemma: pgeo-minimum-order
∀pg:ProjectivePlane. ∀n:ℕ.  (order(pg) = n ⇒ (n ≥ 2 ))

Lemma: pgeo-minimum-order-proof2
∀pg:ProjectivePlane. ∀n:ℕ.  (order(pg) = n ⇒ (n ≥ 2 ))

Lemma: pgeo-order-implies2
∀pg:ProjectivePlane. ∀n:ℕ.  (order(pg) = n ⇒ (∃l:Line. p,q:{p:Point| p I l} //p ≡ q ~ ℕn + 1))

Lemma: pgeo-order_incidence-eq
∀pg:ProjectivePlane. ∀n:ℕ. ∀l1,l2:Line.  (order(pg) = n ⇒ p,q:{p:Point| p I l1} //p ≡ q ~ p,q:{p:Point| p I l2} //p ≡ q\000C)

Definition: pgeo-finite-plane
pgeo-finite-plane(pg) ==
  ((∃p_n:ℕ. Point ~ ℕp_n) ∧ (∃l_n:ℕ. Line ~ ℕl_n)) ∧ (∀p:Point. ∀l:Line.  Dec(pgeo-plsep(pg; p; l)))

Lemma: pgeo-finite-plane_wf
∀pg:ProjectivePlane. (pgeo-finite-plane(pg) ∈ ℙ)

Lemma: Euclid-Prop16-construction-lemma
∀g:EuclideanPlane. ∀a,b,c:Point.
  (a # bc ⇒ (∃x:{x:Point| b=x=c} . ∃y:{y:Point| a=x=y} . (abc ≅a ycb ∧ (b # x ∧ x # c) ∧ a # x ∧ x # y)))

Lemma: Euclid-prop16
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ b-c-d ⇒ (cba < acd ∧ bac < acd))

Lemma: Euclid-Prop18-lemma
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ b-c-d ⇒ bac < bad)

Lemma: Euclid-Prop18
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ |ab| < |ac| ⇒ bca < abc)

Lemma: Euclid-Prop19-weak
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ bca < abc ⇒ (¬¬|ab| < |ac|))

Lemma: Euclid-Prop19-lemma1
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ bad ≅a cad ⇒ b-d-c ⇒ |bd| < |cd| ⇒ |ab| < |ac|)

Lemma: angle-bisector-unique
∀e:EuclideanPlane. ∀a,b,c,a',c',x,y:Point.
  (a # bc ⇒ out(b aa') ⇒ out(b cc') ⇒ a-x-c ⇒ a'-y-c' ⇒ abx ≅a cbx ⇒ a'by ≅a c'by ⇒ {out(b xy) ∧ abx ≅a a'by})

Lemma: interior-angles-unique
∀e:EuclideanPlane. ∀a,b,c,d,b',c',p:Point.
  (a # bc ⇒ out(b dc) ⇒ out(a bb') ⇒ out(a cc') ⇒ B(b'pc') ⇒ p # c' ⇒ bad < bac ⇒ bap ≅a bad ⇒ out(a dp))

Lemma: interior-angles-unique2
∀e:EuclideanPlane. ∀a,b,c,d,b',c',p:Point.
  (c leftof ab
  ⇒ d leftof ab
  ⇒ p leftof ab
  ⇒ out(a bb')
  ⇒ out(a cc')
  ⇒ B(b'pc')
  ⇒ p # c'
  ⇒ bad < bac
  ⇒ bap ≅a bad
  ⇒ out(a dp))

Lemma: interior-angles-unique2-symm
∀e:EuclideanPlane. ∀a,b,c,d,a',c',p:Point.
  (c leftof ab
  ⇒ d leftof ab
  ⇒ p leftof ab
  ⇒ out(b aa')
  ⇒ out(b cc')
  ⇒ B(a'pc')
  ⇒ p # c'
  ⇒ abd < abc
  ⇒ abp ≅a abd
  ⇒ out(b dp))

Lemma: lt-angle-implies-between-if-out
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ bad < bac ⇒ out(b dc) ⇒ b-d-c)

Lemma: Euclid-Prop19-lemma2_1
∀e:EuclideanPlane. ∀a,b,c,d,f:Point.  (a # bc ⇒ abd ≅a cbd ⇒ a=d=c ⇒ a-f-c ⇒ cbf < abf ⇒ abd < abf)

Lemma: Euclid-Prop19-lemma2
∀e:EuclideanPlane. ∀a,b,c,d,f:Point.  (a # bc ⇒ cbd < abd ⇒ a=d=c ⇒ a-f-c ⇒ cbf ≅a abf ⇒ |af| < |cf|)

Lemma: Euclid-Prop9-with-between
∀e:EuclideanPlane. ∀a,b:Point. ∀c:{c:Point| c # ba} .  ∃f:Point. (acf ≅a bcf ∧ a-f-b)

Lemma: Euclid-Prop19
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ bca < abc ⇒ |ab| < |ac|)

Lemma: Euclid-Prop20
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ |bc| < |ba| + |ac|)

Lemma: Euclid-Prop20_cycle
∀e:EuclideanPlane. ∀a,b,c:Point.  (a # bc ⇒ (|bc| < |ba| + |ac| ∧ |ac| < |ba| + |bc| ∧ |ba| < |ac| + |bc|))

Definition: geo-interior-point
I(abc;d) ==  a leftof bc ∧ d leftof bc ∧ d leftof ca ∧ d leftof ab

Lemma: geo-interior-point_wf
∀[e:EuclideanPlane]. ∀[a,b,c,d:Point].  (I(abc;d) ∈ ℙ)

Lemma: Euclid-Prop21
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (I(abc;d) ⇒ {|cd| + |bd| < |ba| + |ac| ∧ bac < bdc})

Lemma: geo-perp-is-shortest-path
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ ad  ⊥d bc ⇒ (∀x:{x:Point| Colinear(b;c;x)} . (d # x ⇒ |ad| < |ax|)))

Lemma: greatest-cevian-is-farthest-from-perp
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (a # bc ⇒ ad  ⊥d bc ⇒ (∀x,y:{x:Point| Colinear(b;c;x)} .  (d-x-y ⇒ |ax| < |ay|)))

Lemma: Euclid-Prop22
∀e:EuclideanPlane. ∀a1,a2,b1,b2,c1,c2:Point.
  (|a1a2| < |b1b2| + |c1c2|
  ⇒ |b1b2| < |a1a2| + |c1c2|
  ⇒ |c1c2| < |a1a2| + |b1b2|
  ⇒ (∃a,b,c:Point. (((a # bc ∧ ab ≅ a1a2) ∧ bc ≅ b1b2) ∧ ca ≅ c1c2)))

Lemma: Prop22-symmetric-point-construction-lemma
∀e:EuclideanPlane. ∀a,b,c:Point.
  (a # bc
  ⇒ (∃c1,c1',c1'',c2,c2',c2'':Point
       ((ac1 ≅ ac ∧ out(a bc1))
       ∧ (bc2 ≅ bc ∧ out(b ac2))
       ∧ (b-a-c1' ∧ ac1' ≅ ac1)
       ∧ (a-b-c2' ∧ bc2' ≅ bc2)
       ∧ (B(abc1'') ∧ bc1'' ≅ bc1)
       ∧ (B(bac2'') ∧ ac2'' ≅ ac2)
       ∧ (a-c1-c2' ∧ b-c2-c1')
       ∧ (c1'-a-c1 ∧ c2'-b-c2)
       ∧ (c1'-c2-c2' ∧ c2'-c1-c1')
       ∧ c1'-c2-c1
       ∧ c2'-c1-c2)))

Lemma: Prop22-inequality-to-triangle-construction
∀e:EuclideanPlane. ∀a,b,c:Point.
  (|ac| < |ab| + |bc|
  ⇒ |ab| < |ac| + |bc|
  ⇒ |bc| < |ac| + |ab|
  ⇒ (∃c1,c2:Point. ((ac ≅ ac1 ∧ bc2 > bc1) ∧ bc ≅ bc2 ∧ ac1 > ac2)))

Lemma: Prop22-inequality-implies-triangle
∀e:EuclideanPlane. ∀a,b,c:Point.  (|ac| < |ab| + |bc| ⇒ |ab| < |ac| + |bc| ⇒ |bc| < |ac| + |ab| ⇒ a # bc)

Lemma: cong-angle-preserves-lsep_strong
∀g:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (x # yz ⇒ abc ≅a xyz ⇒ a # bc)

Lemma: hp-angle-sum-lt3
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (a' # b'c'
  ⇒ abc + xyz ≅ ijk
  ⇒ a'b'c' + x'y'z' ≅ i'j'k'
  ⇒ ijk ≅a i'j'k'
  ⇒ a # bc
  ⇒ x # yz
  ⇒ i # jk
  ⇒ abc < a'b'c'
  ⇒ x'y'z' < xyz)

Lemma: hp-angle-sum-lt4
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (x' # y'z'
  ⇒ abc + xyz ≅ ijk
  ⇒ a'b'c' + x'y'z' ≅ i'j'k'
  ⇒ ijk ≅a i'j'k'
  ⇒ a' # b'c'
  ⇒ x # yz
  ⇒ i # jk
  ⇒ x'y'z' < xyz
  ⇒ abc < a'b'c')

Lemma: hp-angle-sum-implies-lsep
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k:Point.  (i-j-k ⇒ abc + xyz ≅ ijk ⇒ a # bc ⇒ x # yz)

Lemma: hp-angle-sum-eq-straight-angle
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,i',j',k':Point.  (abc + xyz ≅ ijk ⇒ abc + xyz ≅ i'j'k' ⇒ i-j-k ⇒ i'-j'-k')

Lemma: hp-angle-sum-eq-straight-angle2
∀e:EuclideanPlane. ∀a,b,c,x,y,z,a',b',c',x',y',z',i,j,k,i',j',k':Point.
  (abc + xyz ≅ ijk ⇒ a'b'c' + x'y'z' ≅ i'j'k' ⇒ abc ≅a a'b'c' ⇒ xyz ≅a x'y'z' ⇒ i-j-k ⇒ i'-j'-k')

Lemma: hp-angle-sum-eq2
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (abc ≅a a'b'c' ⇒ xyz ≅a x'y'z' ⇒ abc + xyz ≅ ijk ⇒ a'b'c' + x'y'z' ≅ i'j'k' ⇒ a # bc ⇒ x # yz ⇒ ijk ≅a i'j'k')

Lemma: hp-angle-sum-eq3
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (abc ≅a a'b'c' ⇒ ijk ≅a i'j'k' ⇒ abc + xyz ≅ ijk ⇒ a'b'c' + x'y'z' ≅ i'j'k' ⇒ a # bc ⇒ i # jk ⇒ xyz ≅a x'y'z')

Lemma: hp-angle-sum-lt
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (abc ≅a a'b'c'
  ⇒ abc + xyz ≅ ijk
  ⇒ a'b'c' + x'y'z' ≅ i'j'k'
  ⇒ i # jk
  ⇒ i' # j'k'
  ⇒ x # yz
  ⇒ xyz < x'y'z'
  ⇒ ijk < i'j'k')

Lemma: geo-lt-angle-in-half-plane-implies-lsep
∀e:EuclideanPlane. ∀w,x,y,z:Point.  (xyz < wyz ⇒ w leftof yz ⇒ x leftof yz ⇒ w # xy)

Lemma: geo-lt-angle-left
∀e:EuclideanPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ y leftof ab ⇒ y leftof xa ⇒ yab < xab)

Lemma: geo-lt-angle-left2
∀e:EuclideanPlane. ∀a,b,x,y:Point.  (x leftof ab ⇒ y leftof ab ⇒ x leftof yb ⇒ yba < xba)

Lemma: geo-lt-angle-in-half-plane-implies-left
∀e:EuclideanPlane. ∀w,x,y,z:Point.  (xyz < wyz ⇒ w leftof yz ⇒ x leftof yz ⇒ w leftof yx)

Lemma: geo-lt-angle-in-half-plane-implies-left2
∀e:EuclideanPlane. ∀w,x,y,z:Point.  (xyz < wyz ⇒ w leftof zy ⇒ x leftof zy ⇒ w leftof xy)

Lemma: geo-lt-angle-in-half-plane-point-exists
∀e:EuclideanPlane. ∀w,x,y,z:Point.  (xyz < wyz ⇒ w leftof yz ⇒ x leftof yz ⇒ (∃q:Point. (w-q-z ∧ out(y qx))))

Lemma: Prop23-construction-lemma
∀e:EuclideanPlane. ∀p,q,r,a,a':Point.
  (p # qr ⇒ a # a' ⇒ (∃b,c1,c2:Point. (((pq ≅ ab ∧ out(a a'b)) ∧ pr ≅ ac1 ∧ bc2 > bc1) ∧ qr ≅ bc2 ∧ ac1 > ac2)))

Lemma: Euclid-Prop23
∀e:EuclideanPlane. ∀a,b,x,y,z:Point.  (z # xy ⇒ a # b ⇒ (∃x',b':Point. (out(a bb') ∧ x' # ab' ∧ x'ab' ≅a zxy)))

Lemma: Euclid-Prop23_half-plane
∀e:EuclideanPlane. ∀a,b,x,y,z:Point.  (z # xy ⇒ a # b ⇒ (∃x',b':Point. (out(a bb') ∧ x' leftof ab' ∧ x'ab' ≅a zxy)))

Lemma: Euclid-Prop23_half-plane2
∀e:EuclideanPlane. ∀a,b,x,y,z:Point.  (z # xy ⇒ a # b ⇒ (∃x',b':Point. (out(a bb') ∧ x' leftof b'a ∧ x'ab' ≅a zxy)))

Lemma: geo-cong-angle-preserves-lt-angle3
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z:Point.  (abc < xyz ⇒ def ≅a xyz ⇒ a # bc ⇒ x-y-z ⇒ abc < def)

Lemma: hp-angle-sum-subst4
∀g:EuclideanPlane. ∀a,b,c,d,e,f,x,y,z,i,j,k:Point.
  (abc + def ≅ xyz ⇒ xyz ≅a ijk ⇒ x-y-z ⇒ a # bc ⇒ d # ef ⇒ abc + def ≅ ijk)

Lemma: lsep-lt-straight-angle
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.  (a # bc ⇒ x-y-z ⇒ abc < xyz)

Lemma: hp-angle-sum-lt2
∀e:EuclideanPlane. ∀a,b,c,x,y,z,i,j,k,a',b',c',x',y',z',i',j',k':Point.
  (abc ≅a a'b'c'
  ⇒ abc + xyz ≅ ijk
  ⇒ a'b'c' + x'y'z' ≅ i'j'k'
  ⇒ i'-j'-k'
  ⇒ a # bc
  ⇒ x # yz
  ⇒ xyz < x'y'z'
  ⇒ ijk < i'j'k')

Lemma: Euclid-Prop17
∀g:EuclideanPlane. ∀a,b,c,i,j,k:Point.  (a # bc ⇒ acb + abc ≅ ijk ⇒ (∀a1,a2,a3:Point.  (a1-a2-a3 ⇒ ijk < a1a2a3)))

Lemma: geo-lt-angle-construction
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (xyz < abc ⇒ x # yz ⇒ a # bc ⇒ (∃a',x',z':Point. (xya' ≅a abc ∧ x'-z'-a' ∧ out(y xx') ∧ out(y zz'))))

Lemma: geo-lt-angle-or
∀e:EuclideanPlane. ∀b,y:Point. ∀a,c:{p:Point| p # b} . ∀x,z:{q:Point| q # y} .  (¬¬(xyz < abc ∨ abc < xyz ∨ abc ≅a xyz))

Lemma: lsep-implies-sep-or-lsep
∀e:EuclideanPlane. ∀a,b,c,x:Point.  (a # bc ⇒ (c # x ∨ x # ab))

Lemma: geo-lt-or
∀e:EuclideanPlane. ∀a,b,c,d,x,y:Point.  (|ab| < |cd| ⇒ (|ab| < |xy| ∨ |xy| < |cd|))

Lemma: geo-lt-lengths-to-sep
∀e:EuclideanPlane. ∀a,b,c:Point.  (|ab| < |ac| ⇒ b # c)

Lemma: Euclid-Prop24
∀p:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (a # bc ⇒ d # ef ⇒ ab ≅ de ⇒ ac ≅ df ⇒ edf < bac ⇒ bc > ef)

Lemma: Euclid-Prop25
∀p:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (a # bc ⇒ d # ef ⇒ ab ≅ de ⇒ ac ≅ df ⇒ |ef| < |bc| ⇒ edf < bac)

Lemma: Euclid-Prop26-1
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (a # bc ⇒ x # yz ⇒ abc ≅a xyz ⇒ bac ≅a yxz ⇒ ab ≅ xy ⇒ (ac ≅ xz ∧ bc ≅ yz ∧ bca ≅a yzx))

Lemma: Euclid-Prop26-2
∀e:EuclideanPlane. ∀a,b,c,x,y,z:Point.
  (a # bc ⇒ x # yz ⇒ abc ≅a xyz ⇒ bac ≅a yxz ⇒ ac ≅ xz ⇒ (ab ≅ xy ∧ bc ≅ yz ∧ bca ≅a yzx))

Lemma: rectangle-sides-cong
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.
  (e # ac
  ⇒ f # eb
  ⇒ ac  ⊥b be
  ⇒ df  ⊥e eb
  ⇒ d-e-f
  ⇒ a-b-c
  ⇒ ab ≅ eb
  ⇒ bc ≅ eb
  ⇒ de ≅ eb
  ⇒ ef ≅ eb
  ⇒ {ad ≅ fc ∧ dc ≅ fa})

Definition: Post5
Post5(e) ==
  ∀a,b,c,d,x,y:Point.
    (((Colinear(x;a;b) ∧ Colinear(y;c;d)) ∧ a leftof yx ∧ c leftof yx ∧ (∀i,j,k:Point.  (axy + cyx ≅ ijk ∧ i # jk)))
    ⇒ ab \/ cd)

Lemma: Post5_wf
∀e:EuclideanPlane. (Post5(e) ∈ ℙ)

Lemma: Euclid-Prop27
∀e:EuclideanPlane. ∀a,b,c,d,x,y:Point.
  (((Colinear(x;a;b) ∧ Colinear(y;c;d)) ∧ (a # b ∧ c # d) ∧ a leftof yx ∧ c leftof xy ∧ axy ≅a cyx)
  ⇒ geo-parallel-points(e;a;b;c;d))

Lemma: Euclid-Prop28_1
∀e:EuclideanPlane. ∀a,b,c,d,x,y,p:Point.
  (((Colinear(x;a;b) ∧ Colinear(y;c;d)) ∧ (a leftof yx ∧ a-x-b) ∧ (c leftof xy ∧ c-y-d) ∧ p-x-y ∧ bxp ≅a cyx)
  ⇒ geo-parallel-points(e;a;b;c;d))

Lemma: Euclid-Prop28_2
∀e:EuclideanPlane. ∀a,b,c,d,x,y,p:Point.
  (((Colinear(x;a;b) ∧ Colinear(y;c;d)) ∧ (a leftof yx ∧ a-x-b) ∧ (c leftof xy ∧ c-y-d) ∧ p-x-y ∧ Ryxa ∧ Rxyc)
  ⇒ geo-parallel-points(e;a;b;c;d))

Lemma: Euclid-Prop31
∀e:EuclideanPlane. ∀a,b,x:Point.  (a # b ⇒ x # ab ⇒ (∃y:Point. geo-parallel-points(e;a;b;x;y)))

Lemma: Euclid-Prop31-sep
∀e:EuclideanPlane. ∀a,b,x:Point.  (a # b ⇒ x # ab ⇒ (∃y:Point. (geo-parallel-points(e;a;b;x;y) ∧ x # y)))

Lemma: parallelogram-construction2
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.
  (a # bc
  ⇒ a-x-b
  ⇒ a-y-c
  ⇒ (∃t:Point
       (geo-parallel-points(e;b;x;y;t)
       ∧ bx ≅ yt
       ∧ xt ≅ by
       ∧ xby ≅a xty
       ∧ (¬¬((a leftof bc ⇒ (t leftof ac ∧ t leftof bc)) ∧ (a leftof cb ⇒ (t leftof ca ∧ t leftof cb)))))))

Lemma: parallelogram-construction
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.
  (a # bc
  ⇒ a-x-b
  ⇒ a-y-c
  ⇒ (∃t:Point
       (geo-parallel-points(e;b;x;y;t)
       ∧ (¬¬((a leftof bc ⇒ (t leftof ac ∧ t leftof bc)) ∧ (a leftof cb ⇒ (t leftof ca ∧ t leftof cb)))))))

Lemma: Steiner-LehmusTheorem
∀e:EuclideanPlane. ∀a,b,c,x,y:Point.  (a # bc ⇒ a-x-b ⇒ c-y-b ⇒ ay ≅ cx ⇒ cay ≅a bay ⇒ acx ≅a bcx ⇒ ab ≅ cb)

Definition: geo-line
Line ==  x:Point × y:Point × x # y

Lemma: geo-line_wf
∀e:GeometryPrimitives. (Line ∈ Type)

Lemma: geo-line-pt-sep
∀eu:EuclideanPlane. ∀l:Line.  fst(l) # fst(snd(l))

Definition: geo-line-sep
(l # m) ==  ∃p:Point. (Colinear(p;fst(l);fst(snd(l))) ∧ p # fst(m)fst(snd(m)))

Lemma: geo-line-sep_wf
∀[g:GeometryPrimitives]. ∀[l,m:Line].  ((l # m) ∈ ℙ)

Definition: geo-line-eq
l ≡ m ==  ¬(l # m)

Lemma: geo-line-eq_wf
∀[g:GeometryPrimitives]. ∀[l,m:Line].  (l ≡ m ∈ ℙ)

Lemma: geo-line-from-points
∀e:EuclideanPlane. ∀a,b:Point.  (a # b ⇒ (∃l:Line. (a ≡ fst(l) ∧ b ≡ fst(snd(l)))))

Lemma: geo-colinear-line-eq
∀e:EuclideanPlane. ∀a,b,c:Point. ∀l:{l:Line| a ≡ fst(l) ∧ b ≡ fst(snd(l))} . ∀m:{m:Line| b ≡ fst(m) ∧ c ≡ fst(snd(m))} .
  (Colinear(a;b;c) ⇒ l ≡ m)

Lemma: geo-colinear-line-eq2
∀e:EuclideanPlane. ∀l1,l2:Line.
  (Colinear(fst(l1);fst(l2);fst(snd(l2))) ⇒ Colinear(fst(snd(l1));fst(l2);fst(snd(l2))) ⇒ l1 ≡ l2)

Lemma: geo-line-eq-to-col
∀g:EuclideanPlane. ∀l,m:Line.
  (l ≡ m ⇒ {Colinear(fst(l);fst(snd(l));fst(m)) ∧ Colinear(fst(l);fst(snd(l));fst(snd(m)))})

Lemma: geo-line-eq_weakening
∀g:EuclideanPlane. ∀l,m:Line.  ((l = m ∈ Line) ⇒ l ≡ m)

Lemma: geo-line-eq_inversion
∀g:EuclideanPlane. ∀l,m:Line.  (l ≡ m ⇒ m ≡ l)

Lemma: geo-line-eq_transitivity
∀g:EuclideanPlane. ∀l,m,n:Line.  (l ≡ m ⇒ m ≡ n ⇒ l ≡ n)

Lemma: geo-line-eq_functionality
∀e:EuclideanPlane. ∀l,m,l1,m1:Line.  (l ≡ l1 ⇒ m ≡ m1 ⇒ (l ≡ m ⇐⇒ l1 ≡ m1))

Lemma: geo-line-eq-equiv
∀g:EuclideanPlane. EquivRel(Line;l,m.l ≡ m)

Lemma: sq_stable__geo-line-eq
∀e:EuclideanPlane. ∀m,l:Line.  SqStable(l ≡ m)

Definition: geoline
LINE ==  l,m:Line//l ≡ m

Lemma: geoline_wf
∀[e:EuclideanPlane]. (LINE ∈ Type)

Lemma: geoline-subtype1
∀[e:EuclideanPlane]. (Line ⊆r LINE)

Lemma: geo-line-eq_weakening2
∀g:EuclideanPlane. ∀l,m:Line.  ((l = m ∈ LINE) ⇒ l ≡ m)

Definition: geo-incident
p I L ==  ∀l:Line. ((l = L ∈ LINE) ⇒ Colinear(p;fst(l);fst(snd(l))))

Lemma: geo-incident_wf
∀[e:EuclideanPlane]. ∀[p:Point]. ∀[l:LINE].  (p I l ∈ ℙ)

Lemma: geo-incident-line
∀[e:EuclideanPlane]. ∀[p:Point]. ∀[l:Line].  uiff(p I l;Colinear(p;fst(l);fst(snd(l))))

Lemma: geo-line-eq-geoline
∀[e:EuclideanPlane]. ∀[P:LINE]. ∀[l:Line].  uiff(fst(l) I P ∧ fst(snd(l)) I P;l = P ∈ LINE)

Lemma: stable__incident
∀e:EuclideanPlane. ∀a:Point. ∀l:LINE.  Stable{a I l}

Lemma: sq_stable__incident
∀e:EuclideanPlane. ∀a:Point. ∀l:LINE.  SqStable(a I l)

Lemma: geo-line-eq-preserves-incidence
∀g:EuclideanPlane. ∀a:Point. ∀l,m:Line.  (a I l ⇒ l ≡ m ⇒ a I m)

Lemma: geo-colinear-incident
∀[e:EuclideanPlane]. ∀[l:LINE]. ∀[a,b,v:Point].  (a # b ⇒ Colinear(a;b;v) ⇒ a I l ⇒ b I l ⇒ v I l)

Lemma: geo-strict-between-incident
∀[e:EuclideanPlane]. ∀[l:LINE]. ∀[a,b,v:Point].  (a-v-b ⇒ a I l ⇒ b I l ⇒ v I l)

Definition: geo-intersect
L \/ M ==
  ∃l,m:Line
   ((l = L ∈ LINE)
   ∧ (m = M ∈ LINE)
   ∧ (∃a,b:{c:Point| c I l} . (a leftof fst(m)fst(snd(m)) ∧ b leftof fst(snd(m))fst(m))))

Lemma: geo-intersect_wf
∀[e:EuclideanPlane]. ∀[p,l:LINE].  (p \/ l ∈ ℙ)

Lemma: geo-intersect-iff
∀e:EuclideanPlane. ∀P,L:LINE.
  (P \/ L ⇐⇒ ∃a,b,c,d,v:Point. (a-v-b ∧ c-v-d ∧ a I P ∧ b I P ∧ c I L ∧ d I L ∧ a leftof cd ∧ b leftof dc))

Lemma: geo-intersect-iff2
∀e:EuclideanPlane. ∀p,l:LINE.
  (p \/ l
  ⇐⇒ ∃a,b,c,d,v:Point
       (a-v-b ∧ c-v-d ∧ a I p ∧ b I p ∧ c I l ∧ d I l ∧ a leftof cd ∧ b leftof dc ∧ c leftof ba ∧ d leftof ab))

Lemma: geo-intersect-iff3
∀e:EuclideanPlane. ∀p,l:LINE.
  (p \/ l
  ⇐⇒ ∃a,b,c,d,v:Point
       ∃sab:a # b
        ∃scd:c # d
         ((p = <a, b, sab> ∈ LINE)
         ∧ (l = <c, d, scd> ∈ LINE)
         ∧ a-v-b
         ∧ c-v-d
         ∧ a leftof cd
         ∧ b leftof dc
         ∧ c leftof ba
         ∧ d leftof ab))

Lemma: geo-intersect-lines
∀e:EuclideanPlane. ∀p,l:Line.
  (p \/ l
  ⇐⇒ ∃a,b:Point
       (Colinear(a;fst(p);fst(snd(p)))
       ∧ Colinear(b;fst(p);fst(snd(p)))
       ∧ a leftof fst(l)fst(snd(l))
       ∧ b leftof fst(snd(l))fst(l)))

Lemma: geo-intersect-lines-iff
∀e:EuclideanPlane. ∀p,l:Line.  (p \/ l ⇐⇒ (p # l) ∧ (∃x:Point. (x I p ∧ x I l)))

Lemma: geo-intersect-symmetry
∀e:EuclideanPlane. ∀l,m:LINE.  (l \/ m ⇒ m \/ l)

Lemma: geo-intersect-irreflexive
∀[g:EuclideanPlane]. ∀[m:LINE].  (¬m \/ m)

Definition: geo-plsep
p # l ==  p # fst(l)fst(snd(l))

Lemma: geo-plsep_wf
∀[e:GeometryPrimitives]. ∀[p:Point]. ∀[l:Line].  (p # l ∈ ℙ)

Lemma: geo-plsep_functionality
∀e:EuclideanPlane. ∀a1,a2:Point. ∀l1,l2:Line.  (a1 ≡ a2 ⇒ l1 ≡ l2 ⇒ (a1 # l1 ⇐⇒ a2 # l2))

Lemma: geo-incident-not-plsep
∀[e:EuclideanPlane]. ∀[x:Point]. ∀[m:Line].  ¬x # m supposing x I m

Lemma: geo-incident-iff-not-plsep
∀[e:EuclideanPlane]. ∀[x:Point]. ∀[m:Line].  (x I m ⇐⇒ ¬x # m)

Definition: geo-Aparallel
l || m ==  ¬l \/ m

Lemma: geo-Aparallel_wf
∀[e:EuclideanPlane]. ∀[l,m:LINE].  (l || m ∈ ℙ)

Lemma: sq_stable__geo-Aparallel
∀[g:EuclideanPlane]. ∀l,m:Line.  SqStable(l || m)

Lemma: Euclid-parallel-exists
∀e:EuclideanPlane. ∀l:Line. ∀p:Point.  ∃m:Line. (m || l ∧ p I m)

Lemma: Euclid-parallel-points-exists
∀e:EuclideanPlane. ∀a:Point. ∀b:{b:Point| a # b} . ∀p:Point.  ∃q:Point. geo-parallel-points(e;a;b;p;q)

Definition: Playfair-axiom
Playfair-axiom(e) ==  ∀p:Point. ∀l,m,n:Line.  ((p I m ∧ m || l) ⇒ (p I n ∧ n || l) ⇒ m ≡ n)

Lemma: Playfair-axiom_wf
∀g:EuclideanPlane. (Playfair-axiom(g) ∈ ℙ)

Lemma: stable__Playfair-axiom
∀g:EuclideanPlane. Stable{Playfair-axiom(g)}

Definition: euclidean-parallel-plane
EuclideanParPlane ==  {g:EuclideanPlane| Playfair-axiom(g)} 

Lemma: euclidean-parallel-plane_wf
EuclideanParPlane ∈ 𝕌'

Lemma: euclidean-planes-subtype
EuclideanParPlane ⊆r EuclideanPlane

Lemma: geo-playfair-axiom
∀e:EuclideanParPlane. ∀p:Point. ∀l,m,n:Line.  ((p I m ∧ m || l) ⇒ (p I n ∧ n || l) ⇒ m ≡ n)

Lemma: geo-Aparallel_functionality
∀[e1:EuclideanPlane]. ∀[l,m,l2,m2:Line].  ({uiff(l || m;l2 || m2)}) supposing (m ≡ m2 and l ≡ l2)

Lemma: geo-incident_functionality
∀[e1:EuclideanPlane]. ∀[l,m:Line]. ∀[p,q:Point].  ({uiff(p I l;q I m)}) supposing (p ≡ q and l ≡ m)

Lemma: geo-Aparallel_sym
∀e:EuclideanPlane. ∀l,m:LINE.  (l || m ⇒ m || l)

Lemma: geo-Aparallel_weakening
∀g:EuclideanPlane. ∀l,m:LINE.  ((l = m ∈ LINE) ⇒ l || m)

Lemma: geo-Aparallel_inversion
∀e:EuclideanPlane. ∀l,m:LINE.  (l || m ⇒ m || l)

Lemma: geo-Aparallel-trans-lines
∀e:EuclideanParPlane. ∀l,m,n:Line.  (l || m ⇒ m || n ⇒ l || n)

Lemma: geo-Aparallel_transitivity
∀e:EuclideanParPlane. ∀l,m,n:LINE.  (l || m ⇒ m || n ⇒ l || n)

Lemma: geo-Aparallel-equiv
∀g:EuclideanParPlane. EquivRel(Line;l,m.l || m)

Lemma: geo-Aparallel-equiv2
∀e:EuclideanParPlane. EquivRel(LINE;l,m.l || m)

Lemma: geoline-subtype2
∀[e:EuclideanParPlane]. (LINE ⊆r (l,m:Line//l || m))

Lemma: geo-Aparallel_weakening2
∀g:EuclideanParPlane. ∀l,m:LINE.  ((l = m ∈ (l,m:Line//l || m)) ⇒ l || m)

Definition: geo-non-parallel
geo-non-parallel(g;l;L) ==  ↓∀a:Line. ((a = L ∈ (l,m:Line//l || m)) ⇒ (∃p:Point. (p I l ∧ p I a)))

Lemma: geo-non-parallel_wf
∀[g:EuclideanParPlane]. ∀[l:Line]. ∀[L:l,m:Line//l || m].  (geo-non-parallel(g;l;L) ∈ ℙ)

Definition: geo-not-parallel
geo-not-parallel(g;l;L) ==  ∀m:Line. ((m = L ∈ (l,m:Line//l || m)) ⇒ (¬l || m))

Lemma: sq_stable__geo-non-parallel
∀[g:EuclideanParPlane]. ∀[l:Line]. ∀[L:l,m:Line//l || m].  SqStable(geo-non-parallel(g;l;L))

Lemma: geo-intersect-all-parallel2
∀e:EuclideanPlane. ∀L,M,N:Line.  ((L \/ N ∧ (∀l,m:LINE.  (l \/ m ⇒ (∀n:LINE. (l \/ n ∨ m \/ n))))) ⇒ L || M ⇒ M \/ N)

Lemma: geo-intersect-unique
∀eu:EuclideanParPlane. ∀l,m:Line. ∀x,y:Point.  (l \/ m ⇒ (x I l ∧ x I m) ⇒ (y I l ∧ y I m) ⇒ x ≡ y)

Definition: pp-sep
pp-sep(eu;p;l) ==
  case p
   of inl(p') =>
   case l of inl(l') => p' # l' | inr(_) => True
   | inr(p') =>
   case l of inl(l') => p' \/ l' | inr(_) => False

Lemma: pp-sep_wf
∀[eu:EuclideanParPlane]. ∀[p:Point + Line]. ∀[l:Line?].  (pp-sep(eu;p;l) ∈ ℙ)

Definition: proj-point-sep
proj-point-sep(eu;p;q) ==
  case p
   of inl(p') =>
   case q of inl(q') => p' # q' | inr(q') => True
   | inr(p') =>
   case q of inl(q') => True | inr(q') => p' \/ q'

Lemma: proj-point-sep_wf
∀[e:EuclideanParPlane]. ∀[p,q:Point + Line].  (proj-point-sep(e;p;q) ∈ ℙ)

Lemma: proj-point-sep-irrefl
∀e:EuclideanParPlane. ∀x:Point + Line.  (¬proj-point-sep(e;x;x))

Lemma: proj-point-sep-symmetry
∀e:EuclideanParPlane. ∀x,y:Point + Line.  (proj-point-sep(e;x;y) ⇒ proj-point-sep(e;y;x))

Lemma: proj-point-sep-cotrans
∀e:EuclideanParPlane
  ((∀l,m:Line.  (l \/ m ⇒ (∀n:Line. (l \/ n ∨ m \/ n))))
  ⇒ (∀x,y:Point + Line.
        (proj-point-sep(e;x;y) ⇒ (∀z:Point + Line. (proj-point-sep(e;x;z) ∨ proj-point-sep(e;y;z))))))

Lemma: not-proj-point-sep-is-equiv
∀e:EuclideanParPlane
  ((∀l,m:Line.  (l \/ m ⇒ (∀n:Line. (l \/ n ∨ m \/ n)))) ⇒ EquivRel(Point + Line;p,q.¬proj-point-sep(e;p;q)))

Lemma: projective-lines-exist
∀e:EuclideanParPlane. ∀p1,p2:Point + Line.
  (proj-point-sep(e;p1;p2) ⇒ (∃l:Line?. ((¬pp-sep(e;p1;l)) ∧ (¬pp-sep(e;p2;l)))))

Definition: proj-line-sep
proj-line-sep(eu;l;m) ==
  case l
   of inl(l') =>
   case m of inl(m') => (l' # m') | inr(_) => True
   | inr(_) =>
   case m of inl(m') => True | inr(_) => False

Lemma: proj-line-sep_wf
∀[e:EuclideanParPlane]. ∀[l,m:Line?].  (proj-line-sep(e;l;m) ∈ ℙ)

Lemma: proj-line-sep-irrefl
∀e:EuclideanParPlane. ∀x:Line?.  (¬proj-line-sep(e;x;x))

Lemma: projective-points-exist
∀e:EuclideanParPlane. ∀l,m:Line?.  (¬¬(∃p:Point + Line. ((¬pp-sep(e;p;l)) ∧ (¬pp-sep(e;p;m)))))

Lemma: not-parallel-implies
∀eu:EuclideanParPlane. ∀l,m,n:Line.  ((¬l || m) ⇒ (¬(l || n ∧ m || n)))

Lemma: p_inf-l_eu-sep-exists
∀eu:EuclideanParPlane. ∀p:l,m:Line//l || m. ∀m:Line.  ((m = p ∈ (l,m:Line//l || m)) ⇒ (∃L:Line. (¬m || L)))

Lemma: canonical-parallel
∀e:EuclideanParPlane. ∀c:l,m:Line//l || m.  (∃l:LINE [(l = c ∈ (l,m:Line//l || m))])

Lemma: proj-point-sep_defA
∀e:EuclideanParPlane. ∀p,q:Point + Line.  (proj-point-sep(e;p;q) ⇒ (∃n:Line?. ((¬pp-sep(e;p;n)) ∧ pp-sep(e;q;n))))

Lemma: proj-point-sep_defB
∀e:EuclideanParPlane. ∀p,q:Point + Line.
  (((∃n:Line?. ((¬pp-sep(e;p;n)) ∧ pp-sep(e;q;n))) ∧ (∀l,m:Line.  (l \/ m ⇒ (∀n:Line. (l \/ n ∨ m \/ n)))))
  ⇒ proj-point-sep(e;p;q))

Lemma: proj-point-sep-iff-pp-sep
∀e:EuclideanParPlane
  ((∀l,m:Line.  (l \/ m ⇒ (∀n:Line. (l \/ n ∨ m \/ n))))
  ⇒ (∀p,q:Point + Line.  (proj-point-sep(e;p;q) ⇐⇒ ∃n:Line?. ((¬pp-sep(e;p;n)) ∧ pp-sep(e;q;n)))))

Definition: eu-pp-prim
pp(eu) ==  points=Point + Line lines=Line? plsep=λp,l. pp-sep(eu;p;l)

Lemma: eu-pp-prim_wf
∀[eu:EuclideanParPlane]. (pp(eu) ∈ ProjGeomPrimitives)

Lemma: geo-pt-swap-preserves-parallel
∀e:EuclideanPlane. ∀a,b,c,d:Point. ∀A:a # b. ∀C:c # d. ∀A':b # a.  (<a, b, A> || <c, d, C> ⇒ <b, a, A'> || <c, d, C>)

Lemma: geo-Aax2
∀g:EuclideanPlane. ∀a,b:Point. ∀l,m:Line.  (a # b ⇒ (a I l ∧ a I m) ⇒ (b I l ∧ b I m) ⇒ l ≡ m)

Lemma: geo-Aax4
∀g:EuclideanPlane. ∀a,b,c:Point. ∀l,m:Line.  (a # b ⇒ (a I l ∧ b I l) ⇒ ((a I m ∧ c I m) ∧ c # l) ⇒ b # m)

Lemma: geo-line-sep-or-lemma
∀g:EuclideanParPlane. ∀l,m,p:Line.  (((∀L,M,N:Line.  (L \/ M ⇒ (L \/ N ∨ M \/ N))) ∧ l \/ m) ⇒ ((p # l) ∨ (p # m)))

Lemma: geo-line-sep-symmetry
∀g:EuclideanParPlane. ∀l,m:Line.  (((l # m) ∧ (∀L,M,N:Line.  (L \/ M ⇒ (L \/ N ∨ M \/ N)))) ⇒ (m # l))

Lemma: geo-line-exists
∀g:EuclideanPlane. Line

Lemma: geo-intersect-LINE-iff-line
∀eu:EuclideanParPlane. ∀L,M:LINE.  (L \/ M ⇐⇒ ∃l:{l:Line| l = L ∈ LINE} . ∃m:{m:Line| m = M ∈ LINE} . l \/ m)

Definition: dist
D(a;b;c;d;e;f) ==  ∃a',b',c':Point. ∃u:{u:Point| c' # u} . (B(a'b'c') ∧ B(a'uc') ∧ ab ≅ a'b' ∧ cd ≅ b'c' ∧ ef ≅ a'u)

Lemma: dist_wf
∀[g:EuclideanPlaneStructure]. ∀[a,b,c,d,e,f:Point].  (D(a;b;c;d;e;f) ∈ ℙ)

Definition: dist-axiomsA
dist-axiomsA(g) ==
  (∀a,b,c,d,e,f,h:Point.  (D(a;b;c;d;e;f) ⇒ D(a;b;c;d;h;h)))
  ∧ (∀a,b,c,d,e,f:Point.  (D(a;b;c;c;e;f) ⇒ D(a;b;d;d;e;f)))
  ∧ (∀a,b,c,d,e,f:Point.  (D(a;b;c;d;e;f) ⇒ (D(b;a;c;d;e;f) ∧ D(a;b;c;d;f;e))))
  ∧ (∀a,b,c,d,e,f:Point.  (D(a;b;c;d;e;f) ⇒ D(c;d;a;b;e;f)))
  ∧ (∀a,b,c,d:Point.  (D(a;b;b;b;c;d) ⇒ (¬D(c;d;d;d;a;b))))
  ∧ (∀a,b,c,d,e,f,x,y:Point.  ((D(a;b;c;d;e;f) ∧ (¬D(x;y;y;y;e;f))) ⇒ D(a;b;c;d;x;y)))
  ∧ (∀a,b,c,d,e,f,x,y:Point.  ((D(a;b;c;d;e;f) ∧ (¬D(a;b;b;b;x;y))) ⇒ D(x;y;c;d;e;f)))
  ∧ (∀a,b,c,d,e,f:Point.  (D(a;b;b;b;c;d) ⇒ (D(a;b;b;b;e;f) ∨ D(e;f;f;f;c;d))))

Lemma: dist-axiomsA_wf
∀[g:EuclideanPlane]. (dist-axiomsA(g) ∈ ℙ)

Definition: dist-sep
Dsep(g;a;b) ==  D(a;b;b;b;b;b)

Lemma: dist-sep_wf
∀[g:EuclideanPlane]. ∀[a,b:Point].  (Dsep(g;a;b) ∈ ℙ)

Definition: dist-tri
Dtri(g;a;b;c) ==  D(a;b;b;c;a;c) ∧ D(a;c;b;c;a;b) ∧ D(a;c;a;b;b;c)

Lemma: dist-tri_wf
∀[g:EuclideanPlane]. ∀[a,b,c:Point].  (Dtri(g;a;b;c) ∈ ℙ)

Definition: dist-bet
Dbet(g;a;b;c) ==  ¬D(a;b;b;c;a;c)

Lemma: dist-bet_wf
∀[g1:EuclideanPlane]. ∀[a,b,c:Point].  (Dbet(g1;a;b;c) ∈ ℙ)

Definition: dist-cong
Dcong(g;a;b;c;d) ==  (¬D(a;b;b;b;c;d)) ∧ (¬D(c;d;d;d;a;b))

Lemma: dist-cong_wf
∀[g1:EuclideanPlane]. ∀[a,b,c,d:Point].  (Dcong(g1;a;b;c;d) ∈ ℙ)

Definition: dist-axiomsB
dist-axiomsB(g) ==
  (∀a,b,c,d:Point.  ((Dbet(g;a;b;c) ∧ Dbet(g;a;c;d)) ⇒ Dbet(g;b;c;d)))
  ∧ (∀a,b,c,d:Point.  ((Dbet(g;a;b;d) ∧ Dbet(g;b;c;d)) ⇒ Dbet(g;a;c;d)))
  ∧ (∀a,b,c,d:Point.  (((Dsep(g;b;c) ∧ Dbet(g;a;b;c)) ∧ Dbet(g;b;c;d)) ⇒ Dbet(g;a;b;d)))
  ∧ (∀a,b,c:Point.  ((Dbet(g;a;b;c) ∧ Dsep(g;b;c)) ⇒ D(a;c;c;c;a;b)))
  ∧ (∀a,b,c,d:Point.
       (((Dbet(g;a;b;c) ∧ Dbet(g;a;b;d)) ∧ Dsep(g;a;b) ∧ Dsep(g;c;d)) ⇒ (Dbet(g;a;c;d) ∨ Dbet(g;a;d;c))))
  ∧ (∀a,b,c,d,e:Point.  (Dbet(g;a;b;c) ⇒ (D(a;b;b;c;d;e) ⇐⇒ D(a;c;c;c;d;e))))
  ∧ (∀a,b,c,x:Point.  (Dtri(g;a;b;c) ⇒ (Dsep(g;c;x) ∨ Dtri(g;a;b;x))))

Lemma: dist-axiomsB_wf
∀[g:EuclideanPlane]. (dist-axiomsB(g) ∈ ℙ)

Lemma: not-dist-lemma
∀g:EuclideanPlane. ∀a,b,c,d:Point.  ((¬D(a;b;b;b;c;d)) ⇒ (¬ab > cd))

Lemma: dist-lemma-le
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (D(a;b;c;d;e;f) ⇒ |ef| ≤ |ab| + |cd|)

Lemma: dist-lemma-lt
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (D(a;b;c;d;e;f) ⇒ |ef| < |ab| + |cd|)

Lemma: dist-lemma-lt-2
∀g:EuclideanPlane. ∀a,b,e,f:Point.  (D(a;b;b;b;e;f) ⇒ |ef| < |ab|)

Lemma: dist-to-gt
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (D(a;b;b;b;c;d) ⇒ ab > cd)

Lemma: geo-lt-not-congruent
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (|ab| < |cd| ⇒ (¬ab ≅ cd))

Lemma: geo-bet-or
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (((B(abc) ∧ B(abd)) ∧ a # b) ⇒ (¬¬(B(bcd) ∨ B(bdc))))

Lemma: geo-lt-implies-gt
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (|cd| < |ab| ⇒ (¬¬ab > cd))

Lemma: dist-lemma-lt2
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (|ef| < |ab| + |cd| ⇒ D(a;b;c;d;e;f))

Lemma: dist-iff-lt
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  (|ef| < |ab| + |cd| ⇐⇒ D(a;b;c;d;e;f))

Lemma: not-dist-lemma-lt
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  ((¬D(a;b;c;d;e;f)) ⇒ (¬|ef| < |ab| + |cd|))

Lemma: not-dist-cong
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (((¬D(a;b;b;b;c;d)) ∧ (¬D(c;d;d;d;a;b))) ⇒ ab ≅ cd)

Lemma: geo-ge-between-sep
∀g:EuclideanPlane. ∀a,b,c,a1,a2,x,y,t:Point.  (B(abc) ⇒ b # c ⇒ ab ≅ a1a2 ⇒ a1a2 ≥ xy ⇒ B(atc) ⇒ at ≅ xy ⇒ t # c)

Lemma: geo-not-gt-to-ge
∀g:EuclideanPlane. ∀x,y,e,f:Point.  ((¬xy > ef) ⇒ ef ≥ xy)

Lemma: geo-not-lt-to-le
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  ((¬|ef| < |ab| + |cd|) ⇒ |ab| + |cd| ≤ |ef|)

Lemma: not-dist-to-le
∀g:EuclideanPlane. ∀a,b,c,d,e,f:Point.  ((¬D(a;b;c;d;e;f)) ⇒ |ab| + |cd| ≤ |ef|)

Lemma: Dbet-to-le
∀g:EuclideanPlane. ∀a,b,c:Point.  (Dbet(g;a;b;c) ⇒ |ab| + |bc| ≤ |ac|)

Lemma: Dbet-to-between
∀e:EuclideanPlane. ∀a,b,c:Point.  ((∀A,B,C:Point.  (A # BC ⇒ |AC| < |AB| + |BC|)) ⇒ Dbet(e;a;b;c) ⇒ B(abc))

Lemma: Dbet-iff-between
∀e:EuclideanPlane. ∀a,b,c:Point.  ((∀A,B,C:Point.  (A # BC ⇒ |AC| < |AB| + |BC|)) ⇒ (Dbet(e;a;b;c) ⇐⇒ B(abc)))

Lemma: Dsep-to-sep
∀e:EuclideanPlane. ∀a,b:Point.  (Dsep(e;a;b) ⇒ a # b)

Lemma: Dsep-iff-sep
∀e:EuclideanPlane. ∀a,b:Point.  (Dsep(e;a;b) ⇐⇒ a # b)

Lemma: Dtri-iff-lsep
∀e:EuclideanPlane. ∀a,b,c:Point.  (Dtri(e;a;b;c) ⇐⇒ a # bc)

Lemma: Dtri-cycle
∀e:EuclideanPlane. ∀a,b,c:Point.
  (Dtri(e;a;b;c) ⇒ {(Dtri(e;a;c;b) ∧ Dtri(e;c;a;b)) ∧ (Dtri(e;c;b;a) ∧ Dtri(e;b;a;c)) ∧ Dtri(e;b;c;a)})

Lemma: Dcong-iff-cong
∀g:EuclideanPlane. ∀a,b,c,d:Point.  (Dcong(g;a;b;c;d) ⇐⇒ ab ≅ cd)

Lemma: lsep-implies-sep-or-not-colinear
∀e:EuclideanPlane. ∀a,b,c,x:Point.  (a # bc ⇒ (c # x ∨ (¬Colinear(a;b;x))))

Lemma: eu-eq_dist-axiomsB
∀g:EuclideanPlane. ((∀a,b,c:Point.  (a # bc ⇒ |ac| < |ab| + |bc|)) ⇒ dist-axiomsB(g))

Lemma: eu-eq_dist-axiomsA
∀g:EuclideanPlane. dist-axiomsA(g)

Lemma: geo-lt-or2
∀e:EuclideanPlane. ∀a,b,c,d:Point.  (|ab| < |ac| ⇒ (|ab| < |ad| ∨ |ad| < |ac|))

Lemma: eu-eq_dist-axiomA9
∀e:EuclideanPlane. ∀a1,a2,a3,a4,a5,a6,b:Point.  (D(a1;a2;a3;a4;a5;a6) ⇒ (a4 # b ∨ D(a1;a2;a3;b;a5;a6)))

Lemma: eu-eq_dist-axiomA10
∀G:EuclideanPlane. ∀a,b,c,d,e,f,g:Point.  (D(a;b;c;d;e;f) ⇒ D(c;d;e;f;a;b) ⇒ c # d)

Lemma: eu-eq_dist-axiomsC-Pasch
∀e:EuclideanPlane. ∀x,y,z,u,t:Point.
  (((((Dbet(e;x;t;u) ∧ Dsep(e;x;t)) ∧ Dbet(e;y;u;z)) ∧ Dtri(e;x;y;u)) ∧ Dtri(e;u;z;t))
  ⇒ (∃v:Point. ((Dbet(e;x;v;y) ∧ Dsep(e;x;v) ∧ Dsep(e;v;y)) ∧ Dbet(e;z;t;v) ∧ Dsep(e;z;t) ∧ Dsep(e;t;v))))

Lemma: eu-eq_dist-axiomsC-five-segment
∀e:EuclideanPlane. ∀x,y,z,x',y',z',u,u':Point.
  (Dcong(e;x;y;x';y')
  ⇒ Dcong(e;y;z;y';z')
  ⇒ Dcong(e;x;u;x';u')
  ⇒ Dcong(e;y;u;y';u')
  ⇒ (Dbet(e;x;y;z) ∧ Dsep(e;x;y) ∧ Dsep(e;y;z))
  ⇒ (Dbet(e;x';y';z') ∧ Dsep(e;x';y') ∧ Dsep(e;y';z'))
  ⇒ Dcong(e;z;u;z';u'))

Definition: P_point
P_point(eu) ==  p:Point × l:Line × n:Line × (p I n ∧ p # l)

Lemma: P_point_wf
∀eu:EuclideanParPlane. (P_point(eu) ∈ Type)

Definition: P_line
P_line(eu) ==  l:Line × p:Point × n:{n:Line| p I n}  × p # l

Lemma: P_line_wf
∀e:EuclideanParPlane. (P_line(e) ∈ Type)

Definition: P_point-line-sep
P_point-line-sep(e;P;L) ==
  (fst(snd(P)) \/ fst(L) ∨ fst(snd(snd(P))) \/ fst(L))
  ∧ (∀x:{x:Point| x I fst(snd(P)) ∧ x I fst(snd(snd(P)))} . x # fst(L))

Lemma: P_point-line-sep_wf
∀[eu:EuclideanParPlane]. ∀P:P_point(eu). ∀n:P_line(eu).  (P_point-line-sep(eu;P;n) ∈ ℙ)

Definition: P_point-sep
P_point-sep(eu;P;Q) ==  ∃L:P_line(eu). ((¬P_point-line-sep(eu;P;L)) ∧ P_point-line-sep(eu;Q;L))

Lemma: P_point-sep_wf
∀[eu:EuclideanParPlane]. ∀P,Q:P_point(eu).  (P_point-sep(eu;P;Q) ∈ ℙ)

Lemma: P_point-apartness-relation1
∀e:EuclideanParPlane. ∀P:P_point(e).  (¬P_point-sep(e;P;P))

Definition: P_line-sep
P_line-sep(eu;L;M) ==  ∃P:P_point(eu). ((¬P_point-line-sep(eu;P;L)) ∧ P_point-line-sep(eu;P;M))

Lemma: P_line-sep_wf
∀[eu:EuclideanParPlane]. ∀[l,m:P_line(eu)].  (P_line-sep(eu;l;m) ∈ ℙ)

Lemma: common-P_point-intersecting-P_lines
∀e:EuclideanParPlane. ∀P:P_point(e). ∀L:P_line(e).
  ((¬P_point-line-sep(e;P;L))
  ⇒ (fst(snd(P)) \/ fst(snd(snd(P))) ∧ (∀l,m,n:Line.  (l \/ m ⇒ (l \/ n ∨ m \/ n))))
  ⇒ (∃x:Point. ((x I fst(snd(P)) ∧ x I fst(snd(snd(P)))) ∧ x I fst(L))))

Lemma: common-P_point-intersecting-P_lines2
∀e:EuclideanParPlane. ∀P:P_point(e). ∀L,L1:P_line(e).
  (((¬P_point-line-sep(e;P;L)) ∧ (¬P_point-line-sep(e;P;L1)))
  ⇒ fst(L) \/ fst(L1)
  ⇒ (∀l,m,n:Line.  (l \/ m ⇒ (l \/ n ∨ m \/ n)))
  ⇒ (∃x:Point. ((x I fst(snd(P)) ∧ x I fst(snd(snd(P)))) ∧ x I fst(L) ∧ x I fst(L1))))

Lemma: common-P_point-parallel-P_lines
∀e:EuclideanParPlane. ∀P:P_point(e). ∀L:P_line(e).
  ((¬P_point-line-sep(e;P;L))
  ⇒ (fst(snd(P)) || fst(snd(snd(P))) ∧ (∀l,m,n:Line.  (l \/ m ⇒ (l \/ n ∨ m \/ n))))
  ⇒ fst(L) || fst(snd(snd(P))))

Lemma: AX3
∀e:EuclideanParPlane. ∀l,m:P_line(e).
  ((P_line-sep(e;l;m) ∧ (∀l,m,n:Line.  (l \/ m ⇒ (l \/ n ∨ m \/ n))))
  ⇒ (∃P:P_point(e). ((¬P_point-line-sep(e;P;l)) ∧ (¬P_point-line-sep(e;P;m)))))

Lemma: canonical-parallel2
∀e:EuclideanParPlane. ∀c:l,m:Line//l || m. ∀a:Point.  (∃l:{l:LINE| a I l}  [(l = c ∈ (l,m:Line//l || m))])

Lemma: P_ptsep-apartness2
∀eu:EuclideanParPlane
  ((∀l,m,n:Line.  (l \/ m ⇒ (l \/ n ∨ m \/ n)))
  ⇒ (∀p,q,r:l,m:Line//l || m. ∀P:{P:Line| p = P ∈ (l,m:Line//l || m)} . ∀Q:{Q:Line| q = Q ∈ (l,m:Line//l || m)} .
      ∀R:{R:Line| r = R ∈ (l,m:Line//l || m)} .
        (P \/ Q ⇒ (P \/ R ∨ Q \/ R))))

Lemma: parallel-preserves-intersection
∀eu:EuclideanParPlane. ∀l,m,n:Line.  ((l \/ m ⇒ (l \/ n ∨ m \/ n)) ⇒ (l \/ m ∧ l || n) ⇒ m \/ n)



Home Index