Theory Tarski_Neutral

(* IsageoCoq - Tarski_Neutral.thy
Port part of GeoCoq 3.4.0 (https://geocoq.github.io/GeoCoq/)

Version 2.0.0 IsaGeoCoq
Copyright (C) 2021-2025 Roland Coghetto roland.coghetto ( a t ) cafr-msa2p.be

History
Version 1.0.0 IsaGeoCoq
Port part of GeoCoq 3.4.0 (https://geocoq.github.io/GeoCoq/) in Isabelle/Hol (Isabelle2021)
Copyright (C) 2021  Roland Coghetto roland_coghetto (at) hotmail.com

License: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*)

theory Tarski_Neutral

imports
  Main

begin

section "Neutral geometry dimensionless"

subsection "Tarski's axiom system for neutral geometry: dimensionless"

locale Tarski_neutral_dimensionless =
  fixes Bet  :: "'p ⇒ 'p ⇒ 'p ⇒ bool" ("(_ ─ _ ─ _) ")
    and Cong :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
    and TPA TPB TPC :: 'p
  assumes cong_pseudo_reflexivity: "∀ a b. 

Cong a b b a"

and   cong_inner_transitivity: "∀ a b p q r s.

Cong a b p q ∧
Cong a b r s
⟶
Cong p q r s"

and   cong_identity: "∀ a b c.

Cong a b c c
⟶
a = b"

and   segment_construction: "∀ a b c q.

∃x. (Bet q a x ∧ Cong a x b c)"

and   five_segment: "∀ a b c d a' b' c' d'.

a ≠ b ∧
Bet a b c ∧
Bet a' b' c'∧
Cong a b a' b' ∧
Cong b c b' c' ∧
Cong a d a' d' ∧
Cong b d b' d'
⟶
Cong c d c' d'"

and   between_identity: "∀ a b.

Bet a b a
⟶
a = b"

and   inner_pasch: "∀ a b c p q.

Bet a p c ∧
Bet b q c
⟶
(∃ x. Bet p x b ∧ Bet q x a)"

and   lower_dim:  "¬ Bet TPA TPB TPC ∧ ¬ Bet TPB TPC TPA ∧ ¬ Bet TPC TPA TPB"

context Tarski_neutral_dimensionless

begin

subsection "Definitions"

definition OFSC ::
  "['p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool"
  ("_ _ _ _ OFSC _ _ _ _" [99,99,99,99,99,99,99,99] 50)
  where
    "A B C D OFSC A' B' C' D' 
≡
Bet A B C ∧
Bet A' B' C' ∧
Cong A B A' B' ∧
Cong B C B' C' ∧
Cong A D A' D' ∧
Cong B D B' D'"

definition Cong3 ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool"
  ("_ _ _ Cong3 _ _ _" [99,99,99,99,99,99] 50)
  where
    "A B C Cong3 A' B' C' 
≡
Cong A B A' B' ∧
Cong A C A' C' ∧
Cong B C B' C'"

definition Col ::
  "['p,'p,'p] ⇒ bool"
  ("Col _ _ _" [99,99,99] 50)
  where
    "Col A B C 
≡
Bet A B C ∨ Bet B C A ∨ Bet C A B"

definition Bet4 ::
  "['p,'p,'p,'p] ⇒ bool"
  ("Bet4 _ _ _ _" [99,99,99,99] 50)
  where
    "Bet4 A1 A2 A3 A4 
≡
Bet A1 A2 A3 ∧
Bet A2 A3 A4 ∧
Bet A1 A3 A4 ∧
Bet A1 A2 A4"

definition BetS ::
  "['p,'p,'p] ⇒ bool" ("BetS _ _ _" [99,99,99] 50)
  where
    "BetS A B C 
≡
Bet A B C ∧
A ≠ B ∧
B ≠ C"

(** Definition of the sum of segments.
SumS A B C D E F means that AB + CD = EF. *)

definition SumS ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ _ SumS _ _" [99,99,99,99,99,99] 50)
  where
    "A B C D SumS E F 
≡
∃ P Q R. Bet P Q R ∧ Cong P Q A B ∧ Cong Q R C D ∧ Cong P R E F"

definition FSC ::
  "['p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool"
  ("_ _ _ _ FSC _ _ _ _" [99,99,99,99,99,99,99,99] 50)
  where
    "A B C D FSC A' B' C' D' 
≡
Col A B C ∧
A B C Cong3 A' B' C' ∧
Cong A D A' D' ∧
Cong B D B' D'"

definition IFSC ::
  "['p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool"
  ("_ _ _ _ IFSC _ _ _ _" [99,99,99,99,99,99,99,99] 50)
  where
    "A B C D IFSC A' B' C' D' 
≡
Bet A B C ∧
Bet A' B' C' ∧
Cong A C A' C' ∧
Cong B C B' C' ∧
Cong A D A' D' ∧
Cong C D C' D'"

definition Le ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Le _ _" [99,99,99,99] 50)
  where 
    "A B Le C D 
≡
∃ E. (Bet C E D ∧ Cong A B C E)"

definition Lt ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Lt _ _" [99,99,99,99] 50)
  where 
    "A B Lt C D 
≡
A B Le C D ∧ ¬ Cong A B C D"

definition Ge ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _Ge _ _" [99,99,99,99] 50)
  where 
    "A B Ge C D 
≡
C D Le A B"

definition Gt ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Gt _ _" [99,99,99,99] 50)
  where 
    "A B Gt C D 
≡
C D Lt A B"

definition Out ::
  "['p,'p,'p] ⇒ bool" 
  ("_ Out _ _" [99,99,99] 50)
  where 
    "P Out A B 
≡
A ≠ P ∧
B ≠ P ∧
(Bet P A B ∨ Bet P B A)"

definition Midpoint ::
  "['p,'p,'p] ⇒ bool" 
  ("_ Midpoint _ _" [99,99,99] 50)
  where 
    "M Midpoint A B 
≡
Bet A M B ∧
Cong A M M B"

definition Per ::
  "['p,'p,'p] ⇒ bool" 
  ("Per _ _ _" [99,99,99] 50)
  where 
    "Per A B C 
≡
∃ C'. (B Midpoint C C' ∧ Cong A C A C')"

definition PerpAt ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ PerpAt _ _ _ _ " [99,99,99,99,99] 50)
  where 
    "X PerpAt A B C D 
≡
A ≠ B ∧
C ≠ D ∧
Col X A B ∧
Col X C D ∧
(∀ U V. ((Col U A B ∧ Col V C D) ⟶ Per U X V))"

definition Perp ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Perp _ _" [99,99,99,99] 50)
  where 
    "A B Perp C D 
≡
∃ X::'p. X PerpAt A B C D"

definition Coplanar ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Coplanar _ _ _ _" [99,99,99,99] 50)
  where 
    "Coplanar A B C D 
≡
∃ X. (Col A B X ∧ Col C D X) ∨
(Col A C X ∧ Col B D X) ∨
(Col A D X ∧ Col B C X)"

definition TS ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ TS _ _" [99,99,99,99] 50)
  where 
    "A B TS P Q 
≡
¬ Col P A B ∧ ¬ Col Q A B ∧ (∃ T::'p. Col T A B ∧ Bet P T Q)"

definition ReflectL ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ ReflectL _ _" [99,99,99,99] 50)
  where 
    "P' P ReflectL A B 
≡
(∃ X. X Midpoint P P' ∧ Col A B X) ∧ (A B Perp P P' ∨ P = P')"

definition Reflect ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Reflect _ _" [99,99,99,99] 50)
  where 
    "P' P Reflect A B 
≡
(A ≠ B ∧ P' P ReflectL A B) ∨ (A = B ∧ A Midpoint P P')"

definition InAngle ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ InAngle _ _ _" [99,99,99,99] 50)
  where 
    "P InAngle A B C 
≡
A ≠ B ∧ C ≠ B ∧ P ≠ B ∧
(∃ X. Bet A X C ∧ (X = B ∨ B Out X P))"

definition ParStrict::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ ParStrict _ _" [99,99,99,99] 50)
  where 
    "A B ParStrict C D 
≡  
Coplanar A B C D ∧ 
¬ (∃ X. Col X A B ∧ Col X C D)"

definition Par::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Par _ _" [99,99,99,99] 50)
  where 
    "A B Par C D 
≡
A B ParStrict C D ∨ (A ≠ B ∧ C ≠ D ∧ Col A C D ∧ Col B C D)"

definition Plg::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Plg _ _ _ _" [99,99,99,99] 50)
  where 
    "Plg  A B C D 
≡
(A ≠ C ∨ B ≠ D) ∧ (∃ M. M Midpoint A C ∧ M Midpoint B D)"

definition ParallelogramStrict::
  "['p,'p,'p,'p] ⇒ bool" 
  ("ParallelogramStrict _ _ _ _" [99,99,99,99] 50)
  where 
    "ParallelogramStrict A B A' B' 
≡
A A' TS B B' ∧ 
A B Par A' B' ∧ 
Cong A B A' B'"

definition ParallelogramFlat::
  "['p,'p,'p,'p] ⇒ bool" 
  ("ParallelogramFlat _ _ _ _" [99,99,99,99] 50)
  where
    "ParallelogramFlat A B A' B' 
≡
Col A B A' ∧ 
Col A B B' ∧
Cong A B A' B' ∧ 
Cong A B' A' B ∧
(A ≠ A' ∨ B ≠ B')"

definition Parallelogram::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Parallelogram _ _ _ _" [99,99,99,99] 50)
  where 
    "Parallelogram A B A' B' 
≡
ParallelogramStrict A B A' B' ∨ ParallelogramFlat A B A' B'"

definition Rhombus::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Rhombus _ _ _ _" [99,99,99,99] 50)
  where 
    "Rhombus A B C D 
≡ 
Plg A B C D ∧ Cong A B B C"

definition Rectangle::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Rectangle _ _ _ _" [99,99,99,99] 50)
  where 
    "Rectangle A B C D 
≡ 
Plg A B C D ∧ Cong A C B D"

definition Square::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Square _ _ _ _" [99,99,99,99] 50)
  where 
    "Square A B C D 
≡ 
Rectangle A B C D ∧ Cong A B B C"

definition Kite::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Kite _ _ _ _" [99,99,99,99] 50)
  where 
    "Kite A B C D 
≡ 
Cong B C C D ∧ Cong D A A B"

definition Lambert::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Lambert _ _ _ _" [99,99,99,99] 50)
  where 
    "Lambert A B C D 
≡
A ≠ B ∧ B ≠ C ∧ C ≠ D ∧ A ≠ D ∧ 
Per B A D ∧ 
Per A D C ∧ 
Per A B C ∧ 
Coplanar A B C D"

definition OS ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ OS _ _" [99,99,99,99] 50)
  where 
    "A B OS P Q 
≡
∃ R::'p. A B TS P R ∧ A B TS Q R"

definition TSP ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ TSP _ _" [99,99,99,99,99] 50)
  where 
    "A B C TSP P Q 
≡
(¬ Coplanar A B C P) ∧ (¬ Coplanar A B C Q) ∧
(∃ T. Coplanar A B C T ∧ Bet P T Q)"

definition OSP ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ OSP _ _" [99,99,99,99,99] 50)
  where 
    "A B C OSP P Q 
≡
∃ R. ((A B C TSP P R) ∧ (A B C TSP Q R))"

definition Saccheri::
  "['p,'p,'p,'p] ⇒ bool" 
  ("Saccheri _ _ _ _" [99,99,99,99] 50)
  where 
    "Saccheri A B C D 
≡
Per B A D ∧ 
Per A D C ∧ 
Cong A B C D ∧ A D OS B C"

definition ReflectLAt ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ ReflectLAt _ _ _ _" [99,99,99,99,99] 50)
  where 
    "M ReflectLAt P' P A B 
≡
(M Midpoint P P' ∧ Col A B M) ∧ (A B Perp P P' ∨ P = P')"

definition ReflectAt ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ ReflectAt _ _ _ _" [99,99,99,99,99] 50)
  where 
    "M ReflectAt P' P A B 
≡
(A ≠ B ∧ M ReflectLAt P' P A B) ∨ (A = B ∧ A = M ∧ M Midpoint P P')"

definition upper_dim_axiom ::
  "bool" 
  ("UpperDimAxiom" [] 50)
  where
    "upper_dim_axiom 
≡ 
∀ A B C P Q.
P ≠ Q ∧
Cong A P A Q ∧
Cong B P B Q ∧
Cong C P C Q
⟶
(Bet A B C ∨ Bet B C A ∨ Bet C A B)"

definition all_coplanar_axiom ::
  "bool" 
  ("AllCoplanarAxiom" [] 50)
  where
    "AllCoplanarAxiom 
≡ 
∀ A B C P Q.
P ≠ Q ∧
Cong A P A Q ∧
Cong B P B Q ∧
Cong C P C Q
⟶
(Bet A B C ∨ Bet B C A ∨ Bet C A B)"

(** If three points A, B and C are equidistant to three distinct points P, Q and R,
    then A, B and C are collinear. *)

definition upper_dim_3_axiom :: 
  "bool" 
  where
    "upper_dim_3_axiom 
≡ 
∀ A B C P Q R. P ≠ Q ∧ Q ≠ R ∧ P ≠ R ∧
  Cong A P A Q ∧ Cong B P B Q ∧ Cong C P C Q ∧
  Cong A P A R ∧ Cong B P B R ∧ Cong C P C R ⟶
  (Bet A B C ∨ Bet B C A ∨ Bet C A B)"

(** If four points are equidistant to two distinct points, then they are coplanar. *)

definition median_planes_axiom :: 
  "bool" 
  where
    "median_planes_axiom 
≡ 
∀ A B C D P Q. P ≠ Q ∧
  Cong A P A Q ∧ Cong B P B Q ∧ Cong C P C Q ∧ Cong D P D Q ⟶
  Coplanar A B C D"

(** If two planes meet in some point, then they also meet in another point. *)

definition plane_intersection_axiom :: 
  "bool" 
  where
    "plane_intersection_axiom 
≡ 
∀ A B C D E F P.
  Coplanar A B C P ∧ Coplanar D E F P ⟶
(∃ Q. Coplanar A B C Q ∧ Coplanar D E F Q ∧ P ≠ Q)"

(** If two points do not lie on a plane, then they are either
    on opposite sides or on the same side of the plane. *)

definition space_separation_axiom :: 
  "bool" 
  where 
    "space_separation_axiom 
≡ 
∀ A B C P Q.
  ¬ Coplanar A B C P ∧ ¬ Coplanar A B C Q ⟶
  (A B C TSP P Q ∨ A B C OSP P Q)"

(** The line segments SU1, SU2, SU3 and SU4 can not form an orthonormal family *)

definition orthonormal_family_axiom :: 
  "bool" 
  where
    "orthonormal_family_axiom 
≡ 
∀ S U1' U1 U2 U3 U4.
  ¬ (S ≠ U1' ∧ Bet U1 S U1' ∧
     Cong S U1 S U1' ∧ Cong S U2 S U1' ∧ Cong S U3 S U1' ∧ Cong S U4 S U1' ∧
     Cong U1 U2 U1' U2 ∧ Cong U1 U3 U1' U2 ∧ Cong U1 U4 U1' U2 ∧
     Cong U2 U3 U1' U2 ∧ Cong U2 U4 U1' U2 ∧ Cong U3 U4 U1' U2)"

definition CongA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ CongA _ _ _" [99,99,99,99,99,99] 50)
  where 
    "A B C CongA D E F 
≡
A ≠ B ∧ C ≠ B ∧ D ≠ E ∧ F ≠ E ∧
(∃ A' C' D' F'. Bet B A A' ∧ Cong A A' E D ∧ Bet B C C' ∧ Cong C C' E F ∧
Bet E D D' ∧ Cong D D' B A ∧ Bet E F F' ∧ Cong F F' B C ∧
Cong A' C' D' F')"

definition LeA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ LeA _ _ _" [99,99,99,99,99,99] 50)
  where 
    "A B C LeA D E F 
≡
∃ P. (P InAngle D E F ∧ A B C CongA D E P)"

definition LtA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ LtA _ _ _" [99,99,99,99,99,99] 50)
  where 
    "A B C LtA D E F 
≡ 
A B C LeA D E F ∧ ¬ A B C CongA D E F"

definition GtA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ GtA _ _ _" [99,99,99,99,99,99] 50)
  where 
    "A B C GtA D E F 
≡ 
D E F LtA A B C"

definition Acute ::
  "['p,'p,'p] ⇒ bool" 
  ("Acute _ _ _" [99,99,99] 50)
  where 
    "Acute A B C 
≡
∃ A' B' C'. (Per A' B' C' ∧ A B C LtA A' B' C')"

definition Obtuse ::
  "['p,'p,'p] ⇒ bool" 
  ("Obtuse _ _ _" [99,99,99] 50)
  where 
    "Obtuse A B C 
≡
∃ A' B' C'. (Per A' B' C' ∧ A' B' C' LtA A B C)"

definition OrthAt ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ OrthAt _ _ _ _ _" [99,99,99,99,99,99] 50)
  where 
    "X OrthAt A B C U V 
≡
¬ Col A B C ∧ U ≠ V ∧ Coplanar A B C X ∧ Col U V X ∧
(∀ P Q. (Coplanar A B C P ∧ Col U V Q) ⟶ Per P X Q)"

definition Orth ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ Orth _ _" [99,99,99,99,99] 50)
  where 
    "A B C Orth U V 
≡
∃ X. X OrthAt A B C U V"

definition SuppA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool"
  ("_ _ _ SuppA _ _ _ " [99,99,99,99,99,99] 50)
  where
    "A B C SuppA D E F 
≡
A ≠ B ∧ (∃ A'. Bet A B A' ∧  D E F CongA C B A')"

definition SumA ::
  "['p,'p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ _ _ _ SumA _ _ _" [99,99,99,99,99,99,99,99,99] 50)
  where
    "A B C D E F SumA G H I 
≡
∃ J. (C B J CongA D E F ∧ ¬ B C OS A J ∧ Coplanar A B C J ∧ A B J CongA G H I)"

definition TriSumA ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ _ TriSumA _ _ _" [99,99,99,99,99,99] 50)
  where
    "A B C TriSumA D E F 
≡
∃ G H I. (A B C B C A SumA G H I ∧ G H I C A B SumA D E F)"

definition SAMS ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("SAMS _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "SAMS A B C D E F 
≡
(A ≠ B ∧
(E Out D F ∨ ¬ Bet A B C)) ∧
(∃ J. (C B J CongA D E F ∧ ¬ (B C OS A J) ∧ ¬ (A B TS C J) ∧ Coplanar A B C J))"

definition Inter ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ Inter _ _ _ _" [99,99,99,99,99] 50)
  where 
    "X Inter A1 A2 B1 B2 
≡
B1 ≠ B2 ∧
(∃ P::'p. (Col P B1 B2 ∧ ¬ Col P A1 A2)) ∧
Col A1 A2 X ∧ Col B1 B2 X"

definition Perp2 :: (*GeoCoq 'Perp2 A B C D E' = IsaGeoCoq 'E Perp2 A B C D'*)
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("_ Perp2 _ _ _ _" [99,99,99,99,99] 50)
  where
    "P Perp2 A B C D 
≡
∃ X Y. (Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D)"

definition Perp_bisect ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ PerpBisect _ _" [99,99,99,99] 50)
  where 
    "P Q PerpBisect A B 
≡
A B ReflectL P Q ∧ A ≠ B"

definition Perp_bisect_bis ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ PerpBisectBis _ _" [99,99,99,99] 50)
  where 
    "P Q PerpBisectBis A B 
≡
∃ I. I PerpAt P Q A B ∧ I Midpoint A B"

definition Is_on_perp_bisect ::
  "['p,'p,'p] ⇒ bool" 
  ("_ IsOnPerpBisect _ _" [99,99,99] 50)
  where 
    "P IsOnPerpBisect A B 
≡
Cong A P P B"

definition isosceles::
  "['p,'p,'p] ⇒ bool"
  ("_ _ _ isosceles" [99,99,99] 50)
  where
    "A B C isosceles 
≡
Cong A B B C"

definition equilateral::
  "['p,'p,'p] ⇒ bool"
  ("_ _ _ equilateral" [99,99,99] 50)
  where
    "A B C equilateral 
≡
Cong A B B C ∧ Cong B C C A"

definition equilateralStrict::
  "['p,'p,'p] ⇒ bool"
  ("_ _ _ equilateralStrict" [99,99,99] 50)
  where
    "A B C equilateralStrict 
≡
A B C equilateral ∧ A ≠ B"

definition QCong::
  "(['p,'p] ⇒ bool) ⇒ bool" 
  ("QCong _" [99] 50)
  where
    "QCong l 
≡
∃ A B. (∀ X Y. (Cong A B X Y ⟷ l X Y))"

definition TarskiLen::
  "['p,'p,(['p,'p] ⇒ bool)] ⇒ bool" 
  ("TarskiLen _ _ _" [99,99,99] 50)
  where
    "TarskiLen A B l 
≡
QCong l ∧ l A B"

definition QCongNull ::
  "(['p,'p] ⇒ bool) ⇒ bool" 
  ("QCongNull _" [99] 50)
  where
    "QCongNull l 
≡
QCong l ∧ (∃ A. l A A)"

definition QCongA ::
  "(['p, 'p, 'p] ⇒ bool) ⇒ bool" 
  ("QCongA _" [99] 50)
  where
    "QCongA a 
≡
∃ A B C. (A ≠ B ∧ C ≠ B ∧ (∀ X Y Z. A B C CongA X Y Z ⟷ a X Y Z))"

definition Ang ::
  "['p,'p,'p, (['p, 'p, 'p] ⇒ bool) ] ⇒ bool" 
  ("_ _ _ Ang _" [99,99,99,99] 50)
  where
    "A B C Ang a 
≡
QCongA a ∧
a A B C"

definition QCongAAcute ::
  "(['p, 'p, 'p] ⇒ bool) ⇒ bool" 
  ("QCongAACute _" [99] 50)
  where
    "QCongAAcute a 
≡
∃ A B C. (Acute A B C ∧ (∀ X Y Z. (A B C CongA X Y Z ⟷ a X Y Z)))"

definition AngAcute ::
  "['p,'p,'p, (['p,'p,'p] ⇒ bool)] ⇒ bool" 
  ("_ _ _ AngAcute _" [99,99,99,99] 50)
  where
    "A B C AngAcute a 
≡
((QCongAAcute a) ∧ (a A B C))"

definition QCongANullAcute ::
  "(['p,'p,'p] ⇒ bool) ⇒ bool" 
  ("QCongANullAcute _" [99] 50)
  where
    "QCongANullAcute a 
≡
QCongAAcute a ∧
(∀ A B C. (a A B C ⟶ B Out A C))"

definition QCongAnNull ::
  "(['p,'p,'p] ⇒ bool) ⇒ bool" 
  ("QCongAnNull _" [99] 50)
  where
    "QCongAnNull a 
≡
QCongA a ∧
(∀ A B C. (a A B C ⟶ ¬ B Out A C))"

definition QCongAnFlat ::
  "(['p,'p,'p] ⇒ bool) ⇒ bool" 
  ("QCongAnFlat _" [99] 50)
  where
    "QCongAnFlat a 
≡
QCongA a ∧
(∀ A B C. (a A B C ⟶ ¬ Bet A B C))"

definition IsNullAngaP ::
  "(['p,'p,'p] ⇒ bool) ⇒ bool" 
  ("IsNullAngaP _" [99] 50)
  where
    "IsNullAngaP a
≡
QCongAAcute a ∧
(∃ A B C. (a A B C ∧ B Out A C))"

definition QCongANull ::
  "(['p,'p,'p] ⇒ bool) ⇒ bool" 
  ("QCongANull _" [99] 50)
  where
    "QCongANull a 
≡
QCongA a ∧
(∀ A B C. (a A B C ⟶ B Out A C))"

definition AngFlat ::
  "(['p, 'p, 'p] ⇒ bool) ⇒ bool" 
  ("AngFlat _" [99] 50)
  where
    "AngFlat a 
≡
QCongA a ∧
(∀ A B C. (a A B C ⟶ Bet A B C))"

definition EqLTarski ::
  "(['p, 'p] ⇒ bool) ⇒ (['p, 'p] ⇒ bool) ⇒ bool" 
  ("_ EqLTarski _" [99,99] 50)
  where
    "l1 EqLTarski l2 
≡ 
∀ A B. l1 A B ⟷ l2 A B"

definition EqA ::
  "(['p, 'p, 'p] ⇒ bool) ⇒ (['p, 'p, 'p] ⇒ bool) ⇒ bool" 
  ("_ EqA _" [99,99] 50)
  where
    "a1 EqA a2 
≡ 
∀ A B C. a1 A B C ⟷ a2 A B C"

definition hypothesis_of_right_saccheri_quadrilaterals ::
  "bool"
  ("HypothesisRightSaccheriQuadrilaterals")
  where
    "hypothesis_of_right_saccheri_quadrilaterals 
≡
∀ A B C D. Saccheri A B C D ⟶ Per A B C"

definition hypothesis_of_acute_saccheri_quadrilaterals ::
  "bool"
  ("HypothesisAcuteSaccheriQuadrilaterals")
  where
    "hypothesis_of_acute_saccheri_quadrilaterals 
≡
∀ A B C D. Saccheri A B C D ⟶ Acute A B C"

definition hypothesis_of_obtuse_saccheri_quadrilaterals ::
  "bool"
  ("HypothesisObtuseSaccheriQuadrilaterals")
  where
    "hypothesis_of_obtuse_saccheri_quadrilaterals 
≡
∀ A B C D. Saccheri A B C D ⟶ Obtuse A B C"

definition Defect ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Defect _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where
    "Defect A B C D E F
≡
(∃ G H I. (A B C TriSumA G H I ∧ G H I SuppA D E F))"

(** Definition 14.1 **)

definition Ar1 ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("Ar1 _ _ _ _ _" [99,99,99,99,99] 50)
  where 
    "Ar1 PO E A B C 
≡
PO ≠ E ∧ Col PO E A ∧ Col PO E B ∧ Col PO E C"

definition Ar2 ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Ar2 _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where 
    "Ar2 PO E E' A B C 
≡
¬ Col PO E E' ∧ Col PO E A ∧ Col PO E B ∧ Col PO E C"

(** Definition 14.2 **)

definition Pj ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("_ _ Pj _ _" [99,99,99,99] 50)
  where 
    "A B Pj C D
≡
A B Par C D ∨ C = D"

(** Definition 14.3. **)

definition Sum ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Sum _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where 
    "Sum PO E E' A B C 
≡
Ar2 PO E E' A B C ∧
(∃ A' C'. E E' Pj A  A' ∧ Col PO E' A' ∧ PO E Pj A' C' ∧ 
         PO E' Pj B  C' ∧ E' E Pj C' C)"

definition Proj ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("_ _ Proj _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "P Q Proj A B X Y
≡
A ≠ B ∧ X ≠ Y ∧ ¬ A B Par X Y ∧ Col A B Q ∧ (P Q Par X Y ∨ P = Q)"

definition Sump ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Sump _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "Sump PO E E' A B C
≡  
Col PO E A ∧ Col PO E B ∧
(∃ A' C' P'. A A' Proj PO E' E E' ∧ PO E Par A' P' ∧
             B C' Proj A' P' PO E' ∧ C' C Proj PO E E E')"

(** Definition 14.4. *)

definition Prod ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Prod _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "Prod PO E E' A B C 
≡
Ar2 PO E E' A B C ∧
 (∃ B'. E E' Pj B B' ∧ Col PO E' B' ∧ E' A Pj B' C)"

definition Prodp ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Prodp _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "Prodp PO E E' A B C 
≡
Col PO E A ∧ Col PO E B ∧
 (∃ B'. B B' Proj PO E' E E' ∧ B' C Proj PO E A E')"

(** Definition 14.8. *)

definition Opp ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("Opp _ _ _ _ _" [99,99,99,99,99] 50)
  where 
    "Opp PO E E' A B 
≡
Sum PO E E' B A PO"

(** Definition 14.38. *)

definition Diff ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Diff _ _ _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "Diff PO E E' A B C
≡
∃ B'. Opp PO E E' B B' ∧ Sum PO E E' A B' C"

definition sum3 ::
  "['p,'p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("sum3 _ _ _ _ _ _ _" [99,99,99,99,99,99,99] 50)
  where
    "sum3 PO E E' A B C S
≡
∃ AB. Sum PO E E' A B AB ∧ Sum PO E E' AB C S"

definition sum4 ::
  "['p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Sum4 _ _ _ _ _ _ _ _" [99,99,99,99,99,99,99,99] 50)
  where
    "Sum4 PO E E' A B C D S 
≡
∃ ABC. sum3 PO E E' A B C ABC ∧ Sum PO E E' ABC D S"

definition sum22 ::
  "['p,'p,'p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("sum22 _ _ _ _ _ _ _ _" [99,99,99,99,99,99,99,99] 50)
  where
    "sum22 PO E E' A B C D S 
≡
∃ AB CD. Sum PO E E' A B AB ∧ Sum PO E E' C D CD ∧ Sum PO E E' AB CD S"

definition Ar2p4 :: (* Ar2_4 *)
  "['p,'p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Ar2p4 _ _ _ _ _ _ _" [99,99,99,99,99,99,99] 50)
  where
    "Ar2p4 PO E E' A B C D
≡
¬ Col PO E E' ∧ Col PO E A ∧ Col PO E B ∧ Col PO E C ∧ Col PO E D" 

(** Definition 14.34. *)

definition Ps ::
  "['p,'p,'p] ⇒ bool" 
  ("Ps _ _ _" [99,99,99] 50)
  where 
    "Ps X E A 
≡ 
 X Out A E"

definition Ng ::
  "['p,'p,'p] ⇒ bool" 
  ("Ng _ _ _" [99,99,99] 50)
  where 
    "Ng X E A 
≡
 A ≠ X ∧ E ≠ X ∧ Bet A X E"

(** Definition 14.38. *)

definition LtP ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("LtP _ _ _ _ _ " [99,99,99,99,99] 50)
  where 
    "LtP X E E' A B
≡
∃ D. Diff X E E' B A D ∧ Ps X E D"

definition LeP :: 
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("LeP _ _ _ _ _" [99,99,99,99,99] 50)
  where 
    "LeP X E E' A B
≡ 
LtP X E E' A B ∨ A = B"

definition Length ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Length _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where 
    "Length X E E' A B L
≡
 X ≠ E ∧ Col X E L ∧ LeP X E E' X L ∧ Cong X L A B"

(** Definition 15.1. *)

definition IsLength ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("IsLength _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where 
    "IsLength X E E' A B L 
≡  
Length X E E' A B L ∨ (X = E ∧ X = L)"

definition Sumg ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Sumg _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where 
    "Sumg X E E' A B C 
≡
Sum X E E' A B C ∨ (¬ Ar2 X E E' A B B ∧ C = X)"

definition Prodg ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("Prodg _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where 
    "Prodg X E E' A B C 
≡
Prod X E E' A B C ∨ (¬ Ar2 X E E' A B B ∧ C = X)"

definition PythRel ::
  "['p,'p,'p,'p,'p,'p] ⇒ bool" 
  ("PythRel _ _ _ _ _ _ " [99,99,99,99,99,99] 50)
  where 
    "PythRel X E E' A B C 
≡
Ar2 X E E' A B C ∧
((X = B ∧ (A = C ∨ Opp X E E' A C)) ∨ (∃ B'. X B' Perp X B ∧ Cong X B' X B ∧ Cong X C A B'))"

definition SignEq ::
  "['p,'p,'p,'p] ⇒ bool" 
  ("SignEq _ _ _ _ " [99,99,99,99] 50)
  where 
    "SignEq X E A B 
≡
Ps X E A ∧ Ps X E B ∨ Ng X E A ∧ Ng X E B" 

definition LtPs ::
  "['p,'p,'p,'p,'p] ⇒ bool" 
  ("LtPs _ _ _ _ _" [99,99,99,99,99] 50)
  where 
    "LtPs X E E' A B 
≡
∃ D. Ps X E D ∧ Sum X E E' A D B" 

definition IsOrthocenter ::
  "['p,'p,'p,'p] ⇒ bool"
  ("_ IsOrthocenter _ _ _" [99,99,99,99] 50)
  where
    "H IsOrthocenter A B C ≡ ¬ Col A B C ∧ 
                              A H Perp B C ∧ 
                              B H Perp A C ∧ 
                              C H Perp A B"

definition IsCircumcenter ::
  "['p,'p,'p,'p] ⇒ bool"
  ("_ IsCircumcenter _ _ _" [99,99,99,99] 50)
  where
    "G IsCircumcenter A B C ≡
Cong A G B G ∧ 
Cong B G C G ∧ 
Coplanar G A B C"

definition IsGravityCenter ::
  "['p,'p,'p,'p] ⇒ bool"
  ("_ IsGravityCenter _ _ _" [99,99,99,99] 50)
  where
    "G IsGravityCenter A B C ≡ ¬ Col A B C ∧ 
                               (∃ I J. I Midpoint B C ∧ 
                                       J Midpoint A C ∧ 
                                       Col G A I ∧ 
                                       Col G B J)"

(** Definition 13.9. *)

definition Lcos :: "(['p,'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "Lcos lb lc a ≡
  QCong lb ∧ QCong lc ∧ QCongAAcute a ∧
  (∃ A B C. (Per C B A ∧ lb A B ∧ lc A C ∧ a B A C))"

definition EqLcos :: "(['p,'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "EqLcos la a lb b ≡ (∃ lp. Lcos lp la a ∧ Lcos lp lb b)"

definition Lcos2 :: "(['p,'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "Lcos2 lp l a b ≡ ∃ la. Lcos la l a ∧ Lcos lp la b" 

definition EqLcos2 :: "(['p,'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "EqLcos2 l1 a b l2 c d ≡ (∃ lp. Lcos2 lp l1 a b ∧ Lcos2 lp l2 c d)" 

definition Lcos3 :: "(['p,'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "Lcos3 lp l a b c ≡ ∃ la lab. Lcos la l a ∧
Lcos lab la b ∧ Lcos lp lab c"

definition EqLcos3 :: "(['p,'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p,'p] ⇒ bool) ⇒
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
(['p, 'p, 'p] ⇒ bool) ⇒ 
bool"
  where
    "EqLcos3 l1 a b c l2 d e f ≡ (∃ lp. Lcos3 lp l1 a b c ∧ Lcos3 lp l2 d e f)" 

(** Vector *)

definition EqV :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ EqV _ _ " [99,99,99,99] 50)
  where
    "A B EqV C D ≡ Parallelogram A B D C ∨ (A = B ∧ C = D)"

definition SumV :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ _ _ SumV _ _ " [99,99,99,99,99,99] 50)
  where
    "A B C D SumV E F ≡ ∀ D'. C D EqV B D' ⟶ A D' EqV E F"

definition SumVExists :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ _ _ SumVExists _ _ " [99,99,99,99,99,99] 50)
  where
    "A B C D SumVExists E F ≡ (∃ D'. B D' EqV C D ∧ A D' EqV E F)"

definition SameDir :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ SameDir _ _ " [99,99,99,99] 50)
  where
    "A B SameDir C D  ≡ 
(A = B ∧ C = D) ∨ (∃ D'. C Out D D' ∧ A B EqV C D')" 

definition OppDir :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ OppDir _ _ " [99,99,99,99] 50)
  where
    "A B OppDir C D  ≡ A B SameDir D C"

(* definition Proj :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ Proj _ _ _ _" [99,99,99,99,99,99] 50)
  where
    "P Q Proj A B X Y ≡

  A ≠ B ∧ X ≠ Y ∧ ¬ A B Par X Y ∧ Col A B Q ∧ (P Q Par X Y ∨ P = Q)"
*)

definition CongA3 :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ _ CongA3 _ _ _" [99,99,99,99,99,99] 50)
  where
    "A B C CongA3 A' B' C' ≡
  A B C CongA A' B' C' ∧ B C A CongA B' C' A' ∧ C A B CongA C' A' B'" 

(** Q is the orthogonal projection of P on the line AB. *)
definition Projp :: "'p ⇒ 'p ⇒ 'p ⇒ 'p ⇒ bool"
  ("_ _ Projp _ _" [99,99,99,99] 50)
  where
    "P Q Projp A B ≡
  A ≠ B ∧ ((Col A B Q ∧ A B Perp P Q) ∨ (Col A B P ∧ P = Q))"

subsection "Propositions"

lemma cong_reflexivity:
  shows "Cong A B A B"
  using cong_inner_transitivity cong_pseudo_reflexivity by blast

lemma cong_symmetry:
  assumes "Cong A B C D"
  shows "Cong C D A B"
  using assms cong_inner_transitivity cong_reflexivity by blast

lemma cong_transitivity:
  assumes "Cong A B C D" and "Cong C D E F"
  shows "Cong A B E F"
  by (meson assms(1) assms(2) cong_inner_transitivity cong_pseudo_reflexivity)

lemma cong_left_commutativity:
  assumes "Cong A B C D"
  shows "Cong B A C D"
  using assms cong_inner_transitivity cong_pseudo_reflexivity by blast

lemma cong_right_commutativity:
  assumes "Cong A B C D"
  shows "Cong A B D C"
  using assms cong_left_commutativity cong_symmetry by blast

lemma cong_3421:
  assumes "Cong A B C D"
  shows "Cong C D B A"
  using assms cong_left_commutativity cong_symmetry by blast

lemma cong_4312:
  assumes "Cong A B C D"
  shows "Cong D C A B"
  using assms cong_left_commutativity cong_symmetry by blast

lemma cong_4321:
  assumes "Cong A B C D"
  shows "Cong D C B A"
  using assms cong_3421 cong_left_commutativity by blast

lemma cong_trivial_identity:
  shows "Cong A A B B"
  using cong_identity segment_construction by blast

lemma cong_reverse_identity:
  assumes "Cong A A C D"
  shows "C = D"
  using assms cong_3421 cong_identity by blast

lemma cong_commutativity:
  assumes "Cong A B C D"
  shows "Cong B A D C"
  using assms cong_3421 by blast

lemma not_cong_2134:
  assumes " ¬ Cong A B C D"
  shows "¬ Cong B A C D"
  using assms cong_left_commutativity by blast

lemma not_cong_1243:
  assumes "¬ Cong A B C D"
  shows "¬ Cong A B D C"
  using assms cong_right_commutativity by blast

lemma not_cong_2143:
  assumes "¬ Cong A B C D"
  shows "¬ Cong B A D C"
  using assms cong_commutativity by blast

lemma not_cong_3412:
  assumes "¬ Cong A B C D"
  shows "¬ Cong C D A B"
  using assms cong_symmetry by blast

lemma not_cong_4312:
  assumes "¬ Cong A B C D"
  shows "¬ Cong D C A B"
  using assms cong_3421 by blast

lemma not_cong_3421:
  assumes "¬ Cong A B C D"
  shows "¬ Cong C D B A"
  using assms cong_4312 by blast

lemma not_cong_4321:
  assumes "¬ Cong A B C D"
  shows "¬ Cong D C B A"
  using assms cong_4321 by blast

lemma five_segment_with_def:
  assumes "A B C D OFSC A' B' C' D'" and "A ≠ B"
  shows "Cong C D C' D'"
  using assms(1) assms(2) OFSC_def five_segment by blast

lemma cong_diff:
  assumes "A ≠ B" and "Cong A B C D"
  shows "C ≠ D"
  using assms(1) assms(2) cong_identity by blast

lemma cong_diff_2:
  assumes "B ≠ A" and "Cong A B C D"
  shows "C ≠ D"
  using assms(1) assms(2) cong_identity by blast

lemma cong_diff_3:
  assumes "C ≠ D" and "Cong A B C D"
  shows "A ≠ B"
  using assms(1) assms(2) cong_reverse_identity by blast

lemma cong_diff_4:
  assumes "D ≠ C" and "Cong A B C D"
  shows "A ≠ B"
  using assms(1) assms(2) cong_reverse_identity by blast

lemma cong_3_sym:
  assumes "A B C Cong3 A' B' C'"
  shows "A' B' C' Cong3 A B C"
  using assms Cong3_def not_cong_3412 by blast

lemma cong_3_swap:
  assumes "A B C Cong3 A' B' C'"
  shows "B A C Cong3 B' A' C'"
  using assms Cong3_def cong_commutativity by blast

lemma cong_3_swap_2:
  assumes "A B C Cong3 A' B' C'"
  shows "A C B Cong3 A' C' B'"
  using assms Cong3_def cong_commutativity by blast

lemma cong3_transitivity:
  assumes "A0 B0 C0 Cong3 A1 B1 C1" and
    "A1 B1 C1 Cong3 A2 B2 C2"
  shows "A0 B0 C0 Cong3 A2 B2 C2"
  by (meson assms(1) assms(2) Cong3_def cong_inner_transitivity not_cong_3412)

lemma eq_dec_points:
  shows "A = B ∨ ¬ A = B"
  by simp

lemma distinct:
  assumes "P ≠ Q"
  shows "R ≠ P ∨ R ≠ Q"
  using assms by simp

lemma l2_11:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "Cong A C A' C'"
proof cases
  assume "A = B"
  thus ?thesis 
    using assms(3) assms(4) cong_reverse_identity by blast
next
  assume "A ≠ B"
  thus ?thesis 
    using five_segment Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) assms(4) 
      cong_commutativity cong_trivial_identity by blast
qed

lemma bet_cong3:
  assumes "Bet A B C" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C'"
  by (meson assms(1) assms(2) Cong3_def l2_11 not_cong_3412 segment_construction)

lemma construction_uniqueness:
  assumes "Q ≠ A" and
    "Bet Q A X" and
    "Cong A X B C" and
    "Bet Q A Y" and
    "Cong A Y B C"
  shows "X = Y"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) cong_identity cong_inner_transitivity 
      cong_reflexivity five_segment)

lemma Cong_cases:
  assumes "Cong A B C D ∨ Cong A B D C ∨ Cong B A C D ∨ Cong B A D C ∨ Cong C D A B ∨ 
Cong C D B A ∨ Cong D C A B ∨ Cong D C B A"
  shows "Cong A B C D"
  using assms not_cong_3421 not_cong_4321 by blast

lemma Cong_perm :
  assumes "Cong A B C D"
  shows "Cong A B C D ∧ Cong A B D C ∧ Cong B A C D ∧ Cong B A D C ∧ Cong C D A B ∧ 
Cong C D B A ∧ Cong D C A B ∧ Cong D C B A"
  using assms not_cong_1243 not_cong_3412 by blast

lemma bet_col:
  assumes "Bet A B C"
  shows "Col A B C"
  by (simp add: assms Col_def)

lemma between_trivial:
  shows "Bet A B B"
  using cong_identity segment_construction by blast

lemma between_symmetry:
  assumes "Bet A B C"
  shows "Bet C B A"
  using assms between_identity between_trivial inner_pasch by blast

lemma Bet_cases:
  assumes "Bet A B C ∨ Bet C B A"
  shows "Bet A B C"
  using assms between_symmetry by blast

lemma Bet_perm:
  assumes "Bet A B C"
  shows "Bet A B C ∧ Bet C B A"
  using assms Bet_cases by blast

lemma between_trivial2:
  shows "Bet A A B"
  using Bet_perm between_trivial by blast

lemma between_equality:
  assumes "Bet A B C" and "Bet B A C"
  shows "A = B"
  using assms(1) assms(2) between_identity inner_pasch by blast

lemma between_equality_2:
  assumes "Bet A B C" and
    "Bet A C B"
  shows "B = C"
  using assms(1) assms(2) between_equality between_symmetry by blast

lemma between_exchange3:
  assumes "Bet A B C" and
    "Bet A C D"
  shows "Bet B C D"
  by (metis Bet_perm assms(1) assms(2) between_identity inner_pasch)

lemma bet_neq12__neq:
  assumes "Bet A B C" and
    "A ≠ B"
  shows "A ≠ C"
  using assms(1) assms(2) between_identity by blast

lemma bet_neq21__neq:
  assumes "Bet A B C" and
    "B ≠ A"
  shows "A ≠ C"
  using assms(1) assms(2) between_identity by blast

lemma bet_neq23__neq:
  assumes "Bet A B C" and
    "B ≠ C"
  shows "A ≠ C"
  using assms(1) assms(2) between_identity by blast

lemma bet_neq32__neq:
  assumes "Bet A B C" and
    "C ≠ B"
  shows "A ≠ C"
  using assms(1) assms(2) between_identity by blast

lemma not_bet_distincts:
  assumes "¬ Bet A B C"
  shows "A ≠ B ∧ B ≠ C"
  using assms between_trivial between_trivial2 by blast

lemma between_inner_transitivity:
  assumes "Bet A B D" and
    "Bet B C D"
  shows "Bet A B C"
  using assms(1) assms(2) Bet_perm between_exchange3 by blast

lemma outer_transitivity_between2:
  assumes "Bet A B C" and
    "Bet B C D" and
    "B ≠ C"
  shows "Bet A C D"
proof -
  obtain X where "Bet A C X" and "Cong C X C D"
    using segment_construction by blast
  thus ?thesis
    using assms(1) assms(2) assms(3) between_exchange3 cong_inner_transitivity 
      construction_uniqueness by blast
qed

lemma between_exchange2:
  assumes "Bet A B D" and
    "Bet B C D"
  shows "Bet A C D"
  using assms(1) assms(2) between_inner_transitivity outer_transitivity_between2 by blast

lemma outer_transitivity_between:
  assumes "Bet A B C" and
    "Bet B C D" and
    "B ≠ C"
  shows "Bet A B D"
  using assms(1) assms(2) assms(3) between_symmetry outer_transitivity_between2 by blast

lemma between_exchange4:
  assumes "Bet A B C" and
    "Bet A C D"
  shows "Bet A B D"
  using assms(1) assms(2) between_exchange2 between_symmetry by blast

lemma l3_9_4:
  assumes "Bet4 A1 A2 A3 A4"
  shows "Bet4 A4 A3 A2 A1"
  using assms Bet4_def Bet_cases by blast

lemma l3_17:
  assumes "Bet A B C" and
    "Bet A' B' C" and
    "Bet A P A'"
  shows "∃ Q. Bet P Q C ∧ Bet B Q B'"
proof -
  obtain X where "Bet B' X A" and "Bet P X C"
    using Bet_perm assms(2) assms(3) inner_pasch by blast
  moreover then obtain Y where "Bet X Y C" and "Bet B Y B'"
    using Bet_perm assms(1) inner_pasch by blast
  ultimately show ?thesis
    using between_exchange2 by blast
qed

lemma lower_dim_ex:
  "∃ A B C. ¬ (Bet A B C ∨ Bet B C A ∨ Bet C A B)"
  using lower_dim by auto

lemma two_distinct_points:
  "∃ X::'p. ∃ Y::'p. X ≠ Y"
  using lower_dim_ex not_bet_distincts by blast

lemma point_construction_different:
  "∃ C. Bet A B C ∧ B ≠ C"
  using two_distinct_points Tarski_neutral_dimensionless_axioms 
    cong_reverse_identity segment_construction by blast

lemma another_point:
  "∃ B::'p. A ≠ B"
  using point_construction_different by blast

lemma Cong_stability:
  assumes "¬ ¬ Cong A B C D"
  shows "Cong A B C D"
  using assms by simp

lemma l2_11_b:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "Cong A C A' C'"
  using assms(1) assms(2) assms(3) assms(4) l2_11 by auto

lemma cong_dec_eq_dec_b:
  assumes "¬ A ≠ B"
  shows "A = B"
  using assms(1) by simp

lemma BetSEq:
  assumes "BetS A B C"
  shows "Bet A B C ∧ A ≠ B ∧ A ≠ C ∧ B ≠ C"
  using assms BetS_def between_identity by auto

lemma l4_2:
  assumes "A B C D IFSC A' B' C' D'"
  shows "Cong B D B' D'"
proof cases
  assume "A = C"
  thus ?thesis
    by (metis IFSC_def between_identity assms cong_diff_3)
next
  assume "A ≠ C"
  have "Bet A B C" and "Bet A' B' C'" and
    "Cong A C A' C'" and "Cong B C B' C'"
    "Cong A D A' D'" and "Cong C D C' D'"
    using IFSC_def assms by auto
  obtain E where "Bet A C E" and "Cong C E A C"
    using segment_construction by blast
  obtain E' where "Bet A' C' E'" and "Cong C' E' C E"
    using segment_construction by blast
  hence "Cong C E C' E'" 
    using Cong_cases by blast
  hence "Cong E D E' D'" 
    using ‹A ≠ C› ‹Bet A C E› ‹Bet A' C' E'› ‹Cong A C A' C'› 
      ‹Cong A D A' D'› ‹Cong C D C' D'› 
      five_segment by blast
  moreover
  have "E ≠ C" 
    using ‹A ≠ C› ‹Cong C E A C› cong_reverse_identity by blast
  moreover
  have "Bet E C B" 
    using ‹Bet A B C› ‹Bet A C E› between_exchange3 between_symmetry by blast
  moreover
  have "Bet E' C' B'" 
    using ‹Bet A' B' C'› ‹Bet A' C' E'› between_exchange3 between_symmetry by blast
  moreover
  have "Cong E C E' C'" 
    by (simp add: ‹Cong C E C' E'› cong_commutativity)
  moreover
  have "Cong C B C' B' " 
    using Cong_cases ‹Cong B C B' C'› by blast
  ultimately show ?thesis
    using ‹Cong C D C' D'› five_segment by blast
qed

lemma l4_3:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "Cong A C A' C'"
    and "Cong B C B' C'"
  shows "Cong A B A' B'"
proof -
  have "A B C A IFSC A' B' C' A'"
    using IFSC_def assms(1) assms(2) assms(3) assms(4) cong_trivial_identity 
      not_cong_2143 by blast
  thus ?thesis
    using l4_2 not_cong_2143 by blast
qed


lemma l4_3_1:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong A C A' C'"
  shows "Cong B C B' C'"
  by (meson assms(1) assms(2) assms(3) assms(4) between_symmetry cong_4321 l4_3)

lemma l4_5:
  assumes "Bet A B C" and
    "Cong A C A' C'"
  shows  "∃ B'. (Bet A' B' C' ∧ A B C Cong3 A' B' C')"
proof -
  obtain X' where "Bet C' A' X'" and "A' ≠ X'"
    using point_construction_different by auto
  obtain B' where "Bet X' A' B'" and "Cong A' B' A B"
    using segment_construction by blast
  obtain C'' where "Bet X' B' C''" and "Cong B' C'' B C"
    using segment_construction by blast
  hence "Bet A' B' C''"
    using ‹Bet X' A' B'› between_exchange3 by blast
  moreover
  have "A B C Cong3 A' B' C''" 
    using Cong3_def ‹Cong A' B' A B› ‹Cong B' C'' B C› assms(1) calculation cong_symmetry l2_11_b 
    by blast
  moreover
  have "C'' = C'"
  proof -
    have "Bet X' A' C''" 
      using ‹Bet X' A' B'› ‹Bet X' B' C''› between_exchange4 by blast
    moreover have "Bet X' A' C'" 
      using Bet_cases ‹Bet C' A' X'› by auto
    moreover have "Cong A' C'' A C" 
      using ‹Bet A' B' C''› ‹Cong A' B' A B› ‹Cong B' C'' B C› assms(1) l2_11_b by blast
    ultimately show ?thesis 
      by (metis ‹A' ≠ X'› assms(2) cong_symmetry construction_uniqueness)
  qed
  ultimately show ?thesis
    by auto
qed

lemma l4_6:
  assumes "Bet A B C" and
    "A B C Cong3 A' B' C'"
  shows "Bet A' B' C'"
proof -
  obtain x where P1: "Bet A' x C' ∧ A B C Cong3 A' x C'"
    using Cong3_def assms(1) assms(2) l4_5 by blast
  hence "A' x C' Cong3 A' B' C'"
    using assms(2) cong3_transitivity cong_3_sym by blast
  hence "A' x C' x IFSC A' x C' B'"
    by (meson Cong3_def Cong_perm IFSC_def P1 cong_reflexivity)
  hence "Cong x x x B'"
    using l4_2 by auto
  thus ?thesis
    using P1 cong_reverse_identity by blast
qed

lemma cong3_bet_eq:
  assumes "Bet A B C" and
    "A B C Cong3 A X C"
  shows "X = B"
proof -
  have "A B C B IFSC A B C X"
    by (meson Cong3_def Cong_perm IFSC_def assms(1) assms(2) cong_reflexivity)
  thus ?thesis
    using cong_reverse_identity l4_2 by blast
qed

lemma col_permutation_1:
  assumes "Col A B C"
  shows "Col B C A"
  using assms(1) Col_def by blast

lemma col_permutation_2:
  assumes "Col A B C"
  shows "Col C A B"
  using assms(1) col_permutation_1 by blast

lemma col_permutation_3:
  assumes "Col A B C"
  shows "Col C B A"
  using assms(1) Bet_cases Col_def by auto

lemma col_permutation_4:
  assumes "Col A B C"
  shows "Col B A C"
  using assms(1) Bet_perm Col_def by blast

lemma col_permutation_5:
  assumes "Col A B C"
  shows "Col A C B"
  using assms(1) col_permutation_1 col_permutation_3 by blast

lemma not_col_permutation_1:
  assumes "¬ Col A B C"
  shows "¬ Col B C A"
  using assms col_permutation_2 by blast

lemma not_col_permutation_2:
  assumes "¬ Col A B C"
  shows  "¬ Col C A B"
  using assms col_permutation_1 by blast

lemma not_col_permutation_3:
  assumes "¬ Col A B C"
  shows "¬ Col C B A"
  using assms col_permutation_3 by blast

lemma not_col_permutation_4:
  assumes "¬ Col A B C"
  shows "¬ Col B A C"
  using assms col_permutation_4 by blast

lemma not_col_permutation_5:
  assumes "¬ Col A B C"
  shows "¬ Col A C B"
  using assms col_permutation_5 by blast

lemma Col_cases:
  assumes "Col A B C ∨ Col A C B ∨ Col B A C ∨ Col B C A ∨ Col C A B ∨ Col C B A"
  shows "Col A B C"
  using assms not_col_permutation_4 not_col_permutation_5 by blast

lemma Col_perm:
  assumes "Col A B C"
  shows "Col A B C ∧ Col A C B ∧ Col B A C ∧ Col B C A ∧ Col C A B ∧ Col C B A"
  using Col_cases assms by blast

lemma col_trivial_1:
  "Col A A B"
  using bet_col not_bet_distincts by blast

lemma col_trivial_2:
  "Col A B B"
  by (simp add: Col_def between_trivial2)

lemma col_trivial_3:
  "Col A B A"
  by (simp add: Col_def between_trivial2)

lemma l4_13:
  assumes "Col A B C" and
    "A B C Cong3 A' B' C'"
  shows "Col A' B' C'"
  by (metis Col_def cong_3_swap cong_3_swap_2 assms(1) assms(2) l4_6)

lemma l4_14R1:
  assumes "Bet A B C" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C'"
  by (simp add: assms(1) assms(2) bet_cong3)

lemma l4_14R2:
  assumes "Bet B C A" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C'"
  by (meson assms(1) assms(2) between_symmetry cong_3_swap_2 l4_5)

lemma l4_14R3:
  assumes "Bet C A B" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C'"
  by (meson assms(1) assms(2) between_symmetry cong_3_swap l4_14R1 not_cong_2143)

lemma l4_14:
  assumes "Col A B C" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C'"
  using Col_def assms(1) assms(2) l4_14R1 l4_14R2 l4_14R3 by blast

lemma l4_16R1:
  assumes "A B C D FSC A' B' C' D'" and
    "A ≠ B" and
    "Bet A B C"
  shows "Cong C D C' D'"
proof -
  have "A B C Cong3 A' B' C'"
    using FSC_def assms(1) by blast
  hence "Bet A' B' C'"
    using assms(3) l4_6 by blast
  hence "A B C D OFSC A' B' C' D'"
    by (meson Cong3_def FSC_def OFSC_def assms(1) cong_3_sym l4_6)
  thus ?thesis
    using assms(2) five_segment_with_def by blast
qed

lemma l4_16R2:
  assumes "A B C D FSC A' B' C' D'"
    and "Bet B C A"
  shows "Cong C D C' D'"
proof -
  have "A B C Cong3 A' B' C'"
    using FSC_def assms(1) by blast
  hence "Bet B' C' A'"
    using Bet_perm assms(2) cong_3_swap_2 l4_6 by blast
  hence "B C A D IFSC B' C' A' D'"
    by (meson Cong3_def FSC_def IFSC_def assms(1) assms(2) not_cong_2143)
  thus ?thesis
    using l4_2 by auto
qed

lemma l4_16R3:
  assumes "A B C D FSC A' B' C' D'" and 
    "A ≠ B" and 
    "Bet C A B"
  shows "Cong C D C' D'"
proof -
  have "A B C Cong3 A' B' C'"
    using FSC_def assms(1) by blast
  hence "Bet C' A' B'"
    using assms(3) between_symmetry cong_3_swap l4_6 by blast
  thus ?thesis 
    by (metis Bet_cases Col_def FSC_def cong_3_swap assms(1) assms(2) assms(3) l4_16R1)
qed

lemma l4_16:
  assumes "A B C D FSC A' B' C' D'" and
    "A ≠ B"
  shows "Cong C D C' D'"
  by (meson Col_def FSC_def assms(1) assms(2) l4_16R1 l4_16R2 l4_16R3)

lemma l4_17:
  assumes "A ≠ B" and
    "Col A B C" and
    "Cong A P A Q" and
    "Cong B P B Q"
  shows "Cong C P C Q"
proof -
  {
    assume "¬ Bet B C A"
    hence "∃p pa. Bet p pa C ∧ Cong pa P pa Q ∧ Cong p P p Q ∧ p ≠ pa"
      using Col_def assms(1) assms(2) assms(3) assms(4) between_symmetry by blast
    hence ?thesis
      using cong_reflexivity five_segment by blast
  }
  thus ?thesis
    by (meson IFSC_def assms(3) assms(4) cong_reflexivity l4_2)
qed

lemma l4_18:
  assumes "A ≠ B" and
    "Col A B C" and
    "Cong A C A C'" and
    "Cong B C B C'"
  shows "C = C'"
  using assms(1) assms(2) assms(3) assms(4) cong_diff_3 l4_17 by blast

lemma l4_19:
  assumes "Bet A C B" and
    "Cong A C A C'" and
    "Cong B C B C'"
  shows "C = C'"
  by (metis Col_def assms(1) assms(2) assms(3) between_equality between_trivial cong_identity 
      l4_18 not_cong_3421)

lemma not_col_distincts:
  assumes "¬ Col A B C"
  shows "¬ Col A B C ∧ A ≠ B ∧ B ≠ C ∧ A ≠ C"
  using Col_def assms between_trivial by blast

lemma NCol_cases:
  assumes "¬ Col A B C ∨ ¬ Col A C B ∨ ¬ Col B A C ∨ ¬ Col B C A ∨ ¬ Col C A B ∨ ¬ Col C B A"
  shows  "¬ Col A B C"
  using assms not_col_permutation_2 not_col_permutation_3 by blast

lemma NCol_perm:
  assumes "¬ Col A B C"
  shows "¬ Col A B C ∧ ¬ Col A C B ∧ ¬ Col B A C ∧ ¬ Col B C A ∧ ¬ Col C A B ∧ ¬ Col C B A"
  using NCol_cases assms by blast

lemma col_cong_3_cong_3_eq:
  assumes "A ≠ B"
    and "Col A B C"
    and "A B C Cong3 A' B' C1"
    and  "A B C Cong3 A' B' C2"
  shows  "C1 = C2"
  using Cong3_def cong_diff l4_18 assms(1) assms(2) assms(3) assms(4) cong_inner_transitivity 
    l4_13 by meson

lemma l5_1:
  assumes "A ≠ B" and
    "Bet A B C" and
    "Bet A B D"
  shows "Bet A C D ∨ Bet A D C"
proof -
  obtain C' where "Bet A D C'" and "Cong D C' C D"
    using segment_construction by blast
  obtain D' where "Bet A C D'" and "Cong C D' C D"
    using segment_construction by blast
  obtain B' where "Bet A C' B'" and "Cong C' B' C B"
    using segment_construction by blast
  obtain B'' where "Bet A D' B''" and "Cong D' B'' D B"
    using segment_construction by blast
  hence "Cong B C' B'' C"
    using assms(3) between_exchange3 between_symmetry cong_4312 cong_inner_transitivity l2_11_b
      ‹Bet A C D'› ‹Bet A D C'› ‹Cong C D' C D› ‹Cong D C' C D› by meson
  hence "Cong B B' B'' B"
    by (meson Bet_cases assms(2) assms(3) between_exchange4 between_inner_transitivity l2_11_b
        ‹Bet A C D'› ‹Bet A C' B'› ‹Bet A D C'› ‹Bet A D' B''› ‹Cong C' B' C B›)
  hence "B'' = B'"
    by (meson assms(1) assms(2) assms(3) between_exchange4 cong_inner_transitivity 
        construction_uniqueness not_cong_2134 ‹Bet A C D'› ‹Bet A C' B'› ‹Bet A D C'› 
        ‹Bet A D' B''›)
  have "B C D' Cong3 B' C' D" 
  proof -
    have "Cong B C B' C'" 
      using ‹Cong C' B' C B› not_cong_4321 by blast
    moreover
    have "Bet B' C' D" 
      using ‹Bet A C' B'› ‹Bet A D C'› between_exchange3 between_symmetry by blast
    have "Bet B C D'" 
      using ‹Bet A C D'› assms(2) between_exchange3 by blast
    moreover have "Cong B D' B' D" 
      using l2_11  Cong_cases ‹Bet B C D'› ‹Bet B' C' D› ‹Cong C D' C D› ‹Cong D C' C D› 
        cong_transitivity ‹Cong B C B' C'› by blast
    moreover have "Cong C D' C' D" 
      by (metis Cong_cases ‹Cong C D' C D› ‹Cong D C' C D› cong_transitivity)
    ultimately show ?thesis 
      using Cong3_def by blast
  qed
  have "Bet B C D'"
    using assms(2) between_exchange3 ‹Bet A C D'› by blast
  have "Cong C D' C' D" 
    by (metis Cong_perm cong_transitivity ‹Cong C D' C D› ‹Cong D C' C D›)
  hence "B C D' C' FSC B' C' D C" 
    using FSC_def ‹B C D' Cong3 B' C' D› ‹B'' = B'› ‹Bet B C D'› ‹Cong B C' B'' C› 
      bet_col cong_pseudo_reflexivity by presburger
  hence "Cong D' C' D C"
    using cong_identity l4_16 ‹B'' = B'› ‹Cong C' B' C B› ‹Cong D' B'' D B› by blast
  obtain E where "Bet C E C'" and "Bet D E D'"
    using between_trivial2 l3_17 ‹Bet A C D'› ‹Bet A D C'› by blast
  hence "D E D' C IFSC D E D' C'"
    by (meson IFSC_def cong_reflexivity cong_3421 cong_inner_transitivity ‹Cong C D' C D› 
        ‹Cong D C' C D› ‹Cong D' C' D C›)
  hence "Cong E C E C'"
    using l4_2 by auto
  have "C E C' D IFSC C E C' D'"
    using IFSC_def cong_reflexivity cong_3421 cong_inner_transitivity
    by (meson ‹Bet C E C'› ‹Cong C D' C' D› ‹D E D' C IFSC D E D' C'›)
  hence "Cong E D E D'"
    using l4_2 by auto
  obtain P where "Bet C' C P" and "Cong C P C D'"
    using segment_construction by blast
  obtain R where "Bet D' C R" and "Cong C R C E"
    using segment_construction by blast
  obtain Q where "Bet P R Q" and "Cong R Q R P"
    using segment_construction by blast
  have "D' C R P FSC P C E D'"
    by (meson Bet_perm Cong3_def FSC_def ‹Bet C E C'› ‹Bet C' C P› ‹Cong C P C D'›  ‹Bet D' C R› 
        ‹Cong C R C E› bet_col between_exchange3 cong_pseudo_reflexivity l2_11_b not_cong_4321)
  have "Cong R P E D'" 
    by (metis ‹Cong C P C D'› ‹Cong C R C E› ‹D' C R P FSC P C E D'› cong_commutativity 
        cong_diff l4_16)
  have "Cong R Q E D" 
    by (metis cong_symmetry cong_transitivity ‹Cong E D E D'› ‹Cong R P E D'› ‹Cong R Q R P›)
  have "D' E D C FSC P R Q C" 
    by (meson Cong3_def FSC_def ‹Bet D E D'› ‹Bet P R Q› ‹Cong C P C D'› ‹Cong C R C E› 
        ‹Cong R P E D'› ‹Cong R Q E D› bet_col between_symmetry l2_11_b not_cong_3412 
        not_cong_4321)
  have "Cong D C Q C" 
    by (metis ‹Cong E D E D'› ‹D' E D C FSC P R Q C› between_trivial2 cong_identity l4_16 l4_16R2)
  have "Cong C P C Q" 
    by (meson ‹Cong C D' C D› ‹Cong C P C D'› ‹Cong D C Q C› cong_transitivity not_cong_2143)
  have "Bet A C D ∨ Bet A D C"
  proof cases
    assume "R = C"
    thus ?thesis 
      using ‹Bet A D C'› ‹Cong C R C E› ‹Cong E C E C'› cong_reverse_identity by blast
  next
    assume "R ≠ C"
    {
      have "Cong D' P D' Q"
      proof -
        have "Col R C D'"
          by (simp add: ‹Bet D' C R› ‹Cong C R C E› bet_col between_symmetry)
        have "Cong R P R Q" 
          by (metis Cong_cases ‹Cong R Q R P›)
        have "Cong C P C Q"
          by (simp add: ‹Cong C P C Q›)
        thus ?thesis
          using ‹Col R C D'› ‹Cong R P R Q› ‹R ≠ C› l4_17 by blast
      qed
      hence "Cong B P B Q"  
        by (metis Col_def ‹Bet B C D'› ‹Cong C P C D'› ‹Cong C P C Q› cong_identity 
            cong_reflexivity l4_17 l4_19 not_bet_distincts)
      have "Cong B' P B' Q" 
        by (metis cong_diff_2 cong_diff_4 ‹B'' = B'› ‹Bet A C D'› ‹Bet A D' B''› ‹Bet C E C'› 
            ‹Cong C D' C D› ‹Cong C D' C' D› ‹Cong C P C Q› ‹Cong C R C E› ‹Cong D' P D' Q› ‹R ≠ C› 
            between_exchange3 between_identity cong_reflexivity five_segment)
      have "Cong C' P C' Q"
      proof -
        have "Bet B C' B'" 
          using ‹Bet A C' B'› ‹Bet A D C'› assms(3) between_exchange3 between_exchange4 by blast
        thus ?thesis
          by (metis Col_def ‹Cong B P B Q› ‹Cong B' P B' Q› between_equality l4_17 
              not_bet_distincts)
      qed
      have "Cong P P P Q" 
        by (metis cong_diff ‹Bet C E C'› ‹Bet C' C P› ‹Cong C P C Q› ‹Cong C R C E› 
            ‹Cong C' P C' Q› ‹R ≠ C› bet_col between_equality_2 between_trivial2 l4_17)
      thus ?thesis 
        using ‹Bet A C D'› ‹Bet P R Q› ‹Cong R P E D'› ‹Cong R Q E D› between_identity 
          cong_reverse_identity by blast
    }
    hence "R ≠ C ⟶ Bet A C D ∨ Bet A D C" by blast
  qed
  thus ?thesis
    by simp
qed

lemma l5_2:
  assumes "A ≠ B" and
    "Bet A B C" and
    "Bet A B D"
  shows  "Bet B C D ∨ Bet B D C"
  using assms(1) assms(2) assms(3) between_exchange3 l5_1 by blast

lemma segment_construction_2:
  assumes  "A ≠ Q"
  shows "∃ X. ((Bet Q A X ∨ Bet Q X A) ∧ Cong Q X B C)"
proof -
  obtain A' where "Bet A Q A'" and "Cong Q A' A Q"
    using segment_construction by blast
  obtain X where "Bet A' Q X" and "Cong Q X B C"
    using segment_construction by blast
  thus ?thesis
    by (metis ‹Bet A Q A'› ‹Cong Q A' A Q› cong_diff_4 between_symmetry l5_2)
qed

lemma l5_3:
  assumes "Bet A B D" and
    "Bet A C D"
  shows "Bet A B C ∨ Bet A C B"
  by (metis Bet_perm assms(1) assms(2) between_inner_transitivity l5_2 
      point_construction_different)

lemma bet3__bet:
  assumes "Bet A B E" and
    "Bet A D E" and
    "Bet B C D"
  shows "Bet A C E"
  by (meson assms(1) assms(2) assms(3) between_exchange2 between_symmetry l5_3)

lemma le_bet:
  assumes "C D Le A B"
  shows "∃ X. (Bet A X B ∧ Cong A X C D)"
  by (meson Le_def assms cong_symmetry)

lemma l5_5_1:
  assumes "A B Le C D"
  shows "∃ X. (Bet A B X ∧ Cong A X C D)"
proof -
  obtain P where "Bet C P D" and "Cong A B C P"
    using Le_def assms by blast
  obtain X where "Bet A B X" and "Cong B X P D"
    using segment_construction by blast
  thus ?thesis 
    by (meson ‹Bet C P D› ‹Cong A B C P› l2_11_b)
qed

lemma l5_5_2:
  assumes "∃ X. (Bet A B X ∧ Cong A X C D)"
  shows "A B Le C D"
proof -
  obtain P where "Bet A B P" and "Cong A P C D"
    using assms by blast
  then obtain B' where "Bet C B' D" and "A B P Cong3 C B' D"
    using l4_5 by blast
  thus ?thesis
    using Cong3_def Le_def by blast
qed

lemma l5_6:
  assumes "A B Le C D" and
    "Cong A B A' B'" and
    "Cong C D C' D'"
  shows "A' B' Le C' D'"
  by (meson Cong3_def Le_def assms(1) assms(2) assms(3) cong_inner_transitivity l4_5)

lemma le_reflexivity:
  shows "A B Le A B"
  using between_trivial cong_reflexivity l5_5_2 by blast

lemma le_transitivity:
  assumes "A B Le C D" and
    "C D Le E F"
  shows "A B Le E F"
  by (meson assms(1) assms(2) between_exchange4 cong_reflexivity l5_5_1 l5_5_2 l5_6 le_bet)

lemma between_cong:
  assumes "Bet A C B" and
    "Cong A C A B"
  shows "C = B" 
  by (metis assms(1) assms(2) between_trivial cong_diff_2 cong_reflexivity l4_3_1)

lemma cong3_symmetry:
  assumes "A B C Cong3 A' B' C'"
  shows "A' B' C' Cong3 A B C"
  by (simp add: assms cong_3_sym)

lemma between_cong_2:
  assumes "Bet A D B" and
    "Bet A E B" and 
    "Cong A D A E"
  shows "D = E" 
  using l5_3 by (metis Cong_cases assms(1) assms(2) assms(3) between_cong)

lemma between_cong_3:
  assumes "A ≠ B"
    and "Bet A B D"
    and "Bet A B E"
    and "Cong B D B E"
  shows "D = E"
  by (meson assms(1) assms(2) assms(3) assms(4) cong_reflexivity construction_uniqueness)

lemma le_anti_symmetry:
  assumes "A B Le C D" and
    "C D Le A B"
  shows "Cong A B C D" 
proof -
  obtain Y where "Bet C Y D" and "Cong A B C Y" 
    using Le_def assms(1) by blast
  obtain T where "Bet C D T" and "Cong C T A B" 
    using assms(2) l5_5_1 by blast
  have "Cong C Y C T" 
    by (metis cong_transitivity ‹Cong A B C Y› ‹Cong C T A B› cong_symmetry)
  have "Bet C Y T" 
    using ‹Bet C D T› ‹Bet C Y D› between_exchange4 by blast
  have "Y = T" 
    using ‹Bet C Y T› ‹Cong C Y C T› between_cong by auto
  moreover have "T = D" 
    using ‹Bet C D T› ‹Bet C Y D› between_equality_2 calculation by auto
  ultimately show ?thesis 
    using ‹Cong A B C Y› by auto
qed

lemma cong_dec:
  shows "Cong A B C D ∨ ¬ Cong A B C D"
  by simp

lemma bet_dec:
  shows "Bet A B C  ∨ ¬ Bet A B C"
  by simp

lemma col_dec:
  shows "Col A B C ∨ ¬ Col A B C"
  by simp

lemma le_trivial:
  shows "A A Le C D"
  using Le_def between_trivial2 cong_trivial_identity by blast

lemma le_cases:
  shows "A B Le C D ∨ C D Le A B" 
  by (metis Cong_cases Le_def l5_5_2 le_trivial segment_construction_2)

lemma le_zero:
  assumes "A B Le C C"
  shows "A = B"
  by (metis assms cong_diff_4 le_anti_symmetry le_trivial)

lemma le_diff:
  assumes "A ≠ B" and "A B Le C D"
  shows "C ≠ D"
  using assms(1) assms(2) le_zero by blast

lemma lt_diff:
  assumes "A B Lt C D"
  shows "C ≠ D"
  using Lt_def assms cong_trivial_identity le_zero by blast

lemma bet_cong_eq:
  assumes "Bet A B C" and
    "Bet A C D" and
    "Cong B C A D"
  shows "C = D ∧ A = B"
proof -
  have "Bet C B A"
    using Bet_perm assms(1) by blast
  thus ?thesis
    by (metis Cong_perm Le_def assms(2) assms(3) between_cong cong_pseudo_reflexivity 
        le_anti_symmetry)
qed

lemma cong__le:
  assumes "Cong A B C D"
  shows "A B Le C D"
  using Le_def assms between_trivial by blast

lemma cong__le3412:
  assumes "Cong A B C D"
  shows "C D Le A B"
  using assms cong__le cong_symmetry by blast

lemma le1221:
  shows "A B Le B A"
  by (simp add: cong__le cong_pseudo_reflexivity)

lemma le_left_comm:
  assumes "A B Le C D"
  shows "B A Le C D"
  using assms le1221 le_transitivity by blast

lemma le_right_comm:
  assumes "A B Le C D"
  shows "A B Le D C"
  by (meson assms cong_right_commutativity l5_5_1 l5_5_2)

lemma le_comm:
  assumes "A B Le C D"
  shows "B A Le D C"
  using assms le_left_comm le_right_comm by blast

lemma ge_left_comm:
  assumes "A B Ge C D"
  shows "B A Ge C D"
  by (meson Ge_def assms le_right_comm)

lemma ge_right_comm:
  assumes "A B Ge C D"
  shows "A B Ge D C"
  using Ge_def assms le_left_comm by presburger

lemma ge_comm0:
  assumes "A B Ge C D"
  shows "B A Ge D C"
  by (meson assms ge_left_comm ge_right_comm)

lemma lt_right_comm:
  assumes "A B Lt C D"
  shows "A B Lt D C"
  using Lt_def assms le_right_comm not_cong_1243 by blast

lemma lt_left_comm:
  assumes "A B Lt C D"
  shows "B A Lt C D"
  using Lt_def assms le_comm lt_right_comm not_cong_2143 by blast

lemma lt_comm:
  assumes "A B Lt C D"
  shows "B A Lt D C"
  using assms lt_left_comm lt_right_comm by blast

lemma gt_left_comm0:
  assumes "A B Gt C D"
  shows "B A Gt C D"
  by (meson Gt_def assms lt_right_comm)

lemma gt_right_comm:
  assumes "A B Gt C D"
  shows "A B Gt D C"
  using Gt_def assms lt_left_comm by presburger

lemma gt_comm:
  assumes "A B Gt C D"
  shows "B A Gt D C"
  by (meson assms gt_left_comm0 gt_right_comm)

lemma cong2_lt__lt:
  assumes "A B Lt C D" and
    "Cong A B A' B'" and
    "Cong C D C' D'"
  shows "A' B' Lt C' D'"
  by (meson Lt_def assms(1) assms(2) assms(3) l5_6 le_anti_symmetry not_cong_3412)

lemma fourth_point:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Col A B P" and
    "Bet A B C"
  shows "Bet P A B ∨ Bet A P B ∨ Bet B P C ∨ Bet B C P"
  by (metis Col_def l5_2 assms(3) assms(4) between_symmetry)

lemma third_point:
  assumes "Col A B P"
  shows "Bet P A B ∨ Bet A P B ∨ Bet A B P"
  using Col_def assms between_symmetry by blast

lemma l5_12_a:
  assumes "Bet A B C"
  shows "A B Le A C ∧ B C Le A C"
  using assms between_symmetry cong_left_commutativity cong_reflexivity l5_5_2 le_left_comm 
  by blast

lemma bet__le1213:
  assumes "Bet A B C"
  shows "A B Le A C"
  using assms l5_12_a by blast

lemma bet__le2313:
  assumes "Bet A B C"
  shows "B C Le A C"
  by (simp add: assms l5_12_a)

lemma bet__lt1213:
  assumes "B ≠ C" and
    "Bet A B C"
  shows "A B Lt A C"
  using Lt_def assms(1) assms(2) bet__le1213 between_cong by blast

lemma bet__lt2313:
  assumes "A ≠ B" and
    "Bet A B C"
  shows "B C Lt A C"
  using Lt_def assms(1) assms(2) bet__le2313 bet_cong_eq l5_1 by blast

lemma l5_12_b:
  assumes "Col A B C" and
    "A B Le A C" and
    "B C Le A C"
  shows "Bet A B C"
proof -
  {
    assume "Bet B C A"
    hence ?thesis 
      using assms(2) between_cong between_symmetry l5_12_a le_anti_symmetry by blast
  }
  moreover
  {
    assume "Bet C A B"
    hence ?thesis 
      by (metis assms(3) bet_cong_eq between_trivial2 l5_12_a le_anti_symmetry le_comm)
  }
  ultimately show ?thesis 
    using Col_def assms(1) by blast
qed

lemma bet_le_eq:
  assumes "Bet A B C"
    and "A C Le B C"
  shows "A = B"
  by (meson assms(1) assms(2) bet__le2313 bet_cong_eq l5_1 le_anti_symmetry)

lemma or_lt_cong_gt:
  "A B Lt C D ∨ A B Gt C D ∨ Cong A B C D"
  by (meson Gt_def Lt_def cong_symmetry local.le_cases)

lemma lt__le:
  assumes "A B Lt C D"
  shows "A B Le C D"
  using Lt_def assms by blast

lemma le1234_lt__lt:
  assumes "A B Le C D" and
    "C D Lt E F"
  shows "A B Lt E F"
  by (meson Lt_def assms(1) assms(2) cong__le3412 le_anti_symmetry le_transitivity)

lemma le3456_lt__lt:
  assumes "A B Lt C D" and
    "C D Le E F"
  shows "A B Lt E F"
  by (meson Lt_def assms(1) assms(2) cong2_lt__lt cong_reflexivity le1234_lt__lt)

lemma lt_transitivity:
  assumes "A B Lt C D" and
    "C D Lt E F"
  shows "A B Lt E F"
  using Lt_def assms(1) assms(2) le1234_lt__lt by blast

lemma not_and_lt:
  "¬ (A B Lt C D ∧ C D Lt A B)"
  by (simp add: Lt_def le_anti_symmetry)

lemma nlt:
  "¬ A B Lt A B"
  using not_and_lt by blast

lemma le__nlt:
  assumes "A B Le C D"
  shows "¬ C D Lt A B"
  using assms le3456_lt__lt nlt by blast

lemma cong__nlt:
  assumes "Cong A B C D"
  shows "¬ A B Lt C D"
  by (simp add: Lt_def assms)

lemma nlt__le:
  assumes "¬ A B Lt C D"
  shows "C D Le A B"
  using Lt_def assms cong__le3412 local.le_cases by blast

lemma lt__nle:
  assumes "A B Lt C D"
  shows "¬ C D Le A B"
  using assms le__nlt by blast

lemma nle__lt:
  assumes "¬ A B Le C D"
  shows "C D Lt A B"
  using assms nlt__le by blast

lemma lt1123:
  assumes "B ≠ C"
  shows "A A Lt B C"
  using assms le_diff nle__lt by blast

lemma bet2_le2__le_R1:
  assumes "Bet a P b" and
    "Bet A Q B" and
    "P a Le Q A" and
    "P b Le Q B" and
    "B = Q"
  shows "a b Le A B"
  by (metis assms(3) assms(4) assms(5) le_comm le_diff)

lemma bet2_le2__le_R2:
  assumes "Bet a Po b" and
    "Bet A PO B" and
    "Po a Le PO A" and
    "Po b Le PO B" and
    "A ≠ PO" and
    "B ≠ PO"
  shows "a b Le A B"
proof -
  obtain b' where "Bet A PO b'" and "Cong PO b' b Po"
    using segment_construction by blast
  obtain a' where "Bet B PO a'" and "Cong PO a' a Po"
    using segment_construction by blast
  obtain a'' where "Bet PO a'' A" and "Cong Po a PO a''"
    using Le_def assms(3) by blast
  have "Cong PO a'' a Po" 
    using Cong_cases ‹Cong Po a PO a''› by blast
  hence "a' = a''" 
    by (meson Bet_perm ‹Bet B PO a'› ‹Bet PO a'' A› ‹Cong PO a' a Po› assms(2) assms(6) 
        between_inner_transitivity construction_uniqueness)
  have "B a' Le B A" 
    by (metis ‹Bet B PO a'› ‹Bet PO a'' A› ‹a' = a''› assms(2) bet__le1213 bet_le_eq le_comm 
        le_cases outer_transitivity_between2)
  obtain b'' where "Bet PO b'' B" and "Cong Po b PO b''"
    using Le_def assms(4) by blast
  hence "b' = b''"
    using assms(2) assms(5) between_inner_transitivity cong_right_commutativity 
      construction_uniqueness not_cong_3412 by (meson ‹Bet A PO b'› ‹Cong PO b' b Po›)
  hence "a' b' Le a' B"
    using Bet_cases bet__le1213 between_exchange2 ‹Bet B PO a'› ‹Bet PO b'' B› by blast
  hence "a' b' Le A B"
    using le_comm le_transitivity by (meson ‹B a' Le B A›)
  have "Cong a' b' a b" 
  proof -
    have "Bet a' PO b'" 
      using Bet_cases ‹Bet A PO b'› ‹Bet PO a'' A› ‹a' = a''› between_exchange3 by blast
    moreover have "Cong a' PO a Po" 
      using Cong_cases ‹Cong PO a' a Po› by auto
    moreover have "Cong PO b' Po b" 
      using ‹Cong PO b' b Po› not_cong_1243 by blast
    ultimately show ?thesis 
      using assms(1) l2_11_b by blast
  qed
  thus ?thesis
    using ‹a' b' Le A B› cong_reflexivity l5_6 by blast
qed

lemma bet2_le2__le:
  assumes "Bet a P b" and
    "Bet A Q B" and
    "P a Le Q A" and
    "P b Le Q B"
  shows "a b Le A B"
proof cases
  assume "A = Q"
  thus ?thesis
    using assms(3) assms(4) le_diff by force
next
  assume "¬ A = Q"
  thus ?thesis
    using assms(1) assms(2) assms(3) assms(4) bet2_le2__le_R1 bet2_le2__le_R2 by blast
qed

lemma Le_cases:
  assumes "A B Le C D ∨ B A Le C D ∨ A B Le D C ∨ B A Le D C"
  shows "A B Le C D"
  using assms le_left_comm le_right_comm by blast

lemma Lt_cases:
  assumes "A B Lt C D ∨ B A Lt C D ∨ A B Lt D C ∨ B A Lt D C"
  shows "A B Lt C D"
  using assms lt_comm lt_left_comm by blast

lemma bet_out:
  assumes "B ≠ A" and
    "Bet A B C"
  shows  "A Out B C"
  using Out_def assms(1) assms(2) bet_neq12__neq by fastforce

lemma bet_out_1:
  assumes "B ≠ A" and
    "Bet C B A"
  shows "A Out B C"
  by (simp add: assms(1) assms(2) bet_out between_symmetry)

lemma out_dec:
  shows "P Out A B ∨ ¬ P Out A B"
  by simp

lemma out_diff1:
  assumes "A Out B C"
  shows "B ≠ A"
  using Out_def assms by auto

lemma out_diff2:
  assumes "A Out B C"
  shows "C ≠ A"
  using Out_def assms by auto

lemma out_distinct:
  assumes "A Out B C"
  shows  "B ≠ A ∧ C ≠ A"
  using assms out_diff1 out_diff2 by auto

lemma out_col:
  assumes "A Out B C"
  shows "Col A B C"
  using Col_def Out_def assms between_symmetry by auto

lemma l6_2:
  assumes "A ≠ P" and
    "B ≠ P" and
    "C ≠ P" and
    "Bet A P C"
  shows "Bet B P C ⟷ P Out A B"
proof -
  {
    assume "Bet B P C"
    hence "P Out A B" 
      using Out_def assms(1) assms(2) assms(3) assms(4) between_symmetry l5_2 by presburger
  }
  moreover
  {
    assume "P Out A B" 
    hence "Bet B P C" 
      by (metis Bet_perm Out_def between_exchange3 outer_transitivity_between2 assms(4))
  }
  ultimately show ?thesis 
    by auto
qed

lemma bet_out__bet:
  assumes "Bet A P C" and
    "P Out A B"
  shows "Bet B P C"
  by (metis l6_2 assms(1) assms(2) not_bet_distincts out_diff1)

lemma l6_3_1:
  assumes "P Out A B"
  shows "A ≠ P ∧ B ≠ P ∧ (∃ C. (C ≠ P ∧ Bet A P C ∧ Bet B P C))"
  using assms bet_out__bet out_diff1 out_diff2 point_construction_different by fastforce

lemma l6_3_2:
  assumes "A ≠ P" and
    "B ≠ P" and
    "∃ C. (C ≠ P ∧ Bet A P C ∧ Bet B P C)"
  shows "P Out A B"
  using assms(1) assms(2) assms(3) l6_2 by blast

lemma l6_4_1:
  assumes "P Out A B" and
    "Col A P B"
  shows "¬ Bet A P B"
  using Out_def assms(1) between_equality between_symmetry by fastforce

lemma l6_4_2:
  assumes "Col A P B"
    and "¬ Bet A P B"
  shows "P Out A B"
  by (metis Out_def assms(1) assms(2) bet_out col_permutation_1 third_point)

lemma out_trivial:
  assumes "A ≠ P"
  shows "P Out A A"
  by (simp add: assms bet_out_1 between_trivial2)

lemma l6_6:
  assumes "P Out A B"
  shows "P Out B A"
  using Out_def assms by auto

lemma l6_7:
  assumes "P Out A B" and
    "P Out B C"
  shows "P Out A C" 
  by (metis assms(1) assms(2) l6_2 l6_6 out_diff2 point_construction_different)

lemma bet_out_out_bet:
  assumes "Bet A B C" and
    "B Out A A'" and
    "B Out C C'"
  shows "Bet A' B C'"
  by (metis Out_def assms(1) assms(2) assms(3) bet_out__bet between_inner_transitivity 
      outer_transitivity_between)

lemma out2_bet_out:
  assumes "B Out A C" and
    "B Out X P" and
    "Bet A X C"
  shows "B Out A P ∧ B Out C P"
proof -
  have "Bet B A C ∨ Bet B C A" 
    using Out_def assms(1) by auto
  {
    assume "Bet B A C"
    have "B Out A P ∧ B Out C P" 
      by (metis Out_def between_inner_transitivity l6_7 ‹Bet B A C› assms(1) assms(2) assms(3))
  }
  moreover
  {
    assume "Bet B C A" 
    hence "B Out A P" 
      by (metis Bet_perm bet3__bet bet_out_1 l5_1 l6_6 l6_7 out_distinct assms(2) assms(3))
  }
  moreover
  {
    assume "Bet B C A" 
    hence "B Out C P" 
      using ‹Bet B C A› assms(1) calculation(2) l6_6 l6_7 by blast
  }
  ultimately show ?thesis 
    using ‹Bet B A C ∨ Bet B C A› by blast
qed

lemma l6_11_uniqueness:
  assumes "A Out X R" and
    "Cong A X B C" and
    "A Out Y R" and
    "Cong A Y B C"
  shows "X = Y"
  by (metis Out_def assms(1) assms(2) assms(3) assms(4) between_cong cong_symmetry 
      cong_transitivity l6_6 l6_7)

lemma l6_11_existence:
  assumes "R ≠ A" and
    "B ≠ C"
  shows "∃ X. (A Out X R ∧ Cong A X B C)"
  by (metis Out_def assms(1) assms(2) cong_reverse_identity segment_construction_2)


lemma segment_construction_3:
  assumes "A ≠ B" and
    "X ≠ Y"
  shows "∃ C. (A Out B C ∧ Cong A C X Y)"
  by (metis assms(1) assms(2) l6_11_existence l6_6)

lemma l6_13_1:
  assumes "P Out A B" and
    "P A Le P B"
  shows "Bet P A B"
  by (metis Out_def assms(1) assms(2) bet__lt1213 le__nlt)

lemma l6_13_2:
  assumes "P Out A B" and
    "Bet P A B"
  shows "P A Le P B"
  by (simp add: assms(2) bet__le1213)

lemma l6_16_1:
  assumes "P ≠ Q" and
    "Col S P Q" and
    "Col X P Q"
  shows "Col X P S"
proof cases
  assume "S = P"
  thus ?thesis 
    using col_trivial_2 by blast
next
  assume "S ≠ P" 
  {
    assume "Bet S P Q" and "Bet X P Q"  
    hence "Col X P S" 
      by (metis Col_cases assms(1) col_trivial_1 l6_2 out_col)
  }
  moreover
  {
    assume "Bet P Q S" and "Bet X P Q"  
    hence "Col X P S" 
      using assms(1) bet_col outer_transitivity_between by blast
  }
  moreover
  {
    assume "Bet Q S P" and "Bet X P Q"  
    hence "Col X P S" 
      using bet_col between_inner_transitivity between_symmetry by blast
  }
  moreover
  {
    assume "Bet P Q S" and "Bet P Q X"  
    hence "Col X P S" 
      by (meson Col_def assms(1) l5_1 not_col_permutation_5)
  }
  moreover
  {
    assume "Bet Q S P" and "Bet P Q X"  
    hence "Col X P S" 
      using Col_def between_exchange4 between_symmetry by blast
  }
  moreover
  {
    assume "Bet S P Q" and "Bet P Q X"  
    hence "Col X P S" 
      using Bet_cases assms(1) bet_col outer_transitivity_between by blast
  }
  moreover
  {
    assume "Bet P Q S" and "Bet Q X P"  
    hence "Col X P S" 
      using Bet_cases Col_def between_exchange2 by blast
  }
  moreover
  {
    assume "Bet Q S P" and "Bet Q X P"  
    hence "Col X P S"
      by (meson Col_def between_exchange3 l5_3 not_col_permutation_3)
  }
  moreover
  {
    assume "Bet S P Q" and "Bet Q X P"  
    hence "Col X P S" 
      using bet_col between_exchange3 between_symmetry by blast
  }
  ultimately show ?thesis 
    by (metis Col_def assms(2) assms(3))
qed

lemma col_transitivity_1:
  assumes "P ≠ Q" and
    "Col P Q A" and
    "Col P Q B"
  shows "Col P A B"
  by (meson l6_16_1 assms(1) assms(2) assms(3) not_col_permutation_2)

lemma col_transitivity_2:
  assumes "P ≠ Q" and
    "Col P Q A" and
    "Col P Q B"
  shows "Col Q A B"
  by (metis col_transitivity_1 assms(1) assms(2) assms(3) not_col_permutation_4)

lemma l6_21:
  assumes "¬ Col A B C" and
    "C ≠ D" and
    "Col A B P" and
    "Col A B Q" and
    "Col C D P" and
    "Col C D Q"
  shows "P = Q"
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) col_transitivity_1 l6_16_1 
      not_col_distincts)

lemma col2__eq:
  assumes "Col A X Y" and
    "Col B X Y" and
    "¬ Col A X B"
  shows  "X = Y"
  using assms(1) assms(2) assms(3) l6_16_1 by blast

lemma not_col_exists:
  assumes  "A ≠ B"
  shows "∃ C. ¬ Col A B C"
  by (metis Col_def assms col_transitivity_2 lower_dim_ex)

lemma col3:
  assumes "X ≠ Y" and
    "Col X Y A" and
    "Col X Y B" and
    "Col X Y C"
  shows "Col A B C"
  by (metis assms(1) assms(2) assms(3) assms(4) col_transitivity_2)

lemma colx:
  assumes "A ≠ B" and
    "Col X Y A" and
    "Col X Y B" and
    "Col A B C"
  shows "Col X Y C"
  by (metis assms(1) assms(2) assms(3) assms(4) l6_21 not_col_distincts)

lemma out2__bet:
  assumes "A Out B C" and
    "C Out A B"
  shows "Bet A B C"
  by (metis Out_def assms(1) assms(2) between_equality between_symmetry)

lemma bet2_le2__le1346:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "A B Le A' B'" and
    "B C Le B' C'"
  shows "A C Le A' C'"
  using Le_cases assms(1) assms(2) assms(3) assms(4) bet2_le2__le by blast

lemma bet2_le2__le2356_R1:
  assumes "Bet A A C" and
    "Bet A' B' C'" and
    "A A Le A' B'" and
    "A' C' Le A C"
  shows "B' C' Le A C"
  using assms(2) assms(4) bet__le2313 le3456_lt__lt lt__nle nlt__le by blast

lemma bet2_le2__le2356_R2:
  assumes "A ≠ B" and
    "Bet A B C" and
    "Bet A' B' C'" and
    "A B Le A' B'" and
    "A' C' Le A C"
  shows "B' C' Le B C"
proof -
  obtain B0 where "Bet A B B0" and "Cong A B0 A' B'"
    using assms(4) l5_5_1 by blast
  hence "A ≠ B0"
    using assms(1) bet_neq12__neq by blast
  obtain C0 where "Bet A C0 C" and "Cong A' C' A C0"
    using Le_def assms(5) by blast
  hence "A ≠ C0"
    using assms(1) assms(3) assms(4) bet_neq12__neq cong_diff le_diff by blast
  hence "Bet A B0 C0" 
    by (metis Bet_cases Cong_cases ‹A ≠ B0› ‹Bet A B B0› ‹Bet A C0 C› ‹Cong A B0 A' B'› 
        ‹Cong A' C' A C0› assms(1) assms(2) assms(3) bet__le1213 between_inner_transitivity 
        cong__nlt l6_13_1 l6_2 le_transitivity nlt__le outer_transitivity_between 
        point_construction_different)
  have "B0 C0 Le B C0" 
    using ‹Bet A B B0› ‹Bet A B0 C0› bet__le2313 between_exchange3 by blast
  moreover have "B C0 Le B C" 
    by (meson ‹Bet A B B0› ‹Bet A B0 C0› ‹Bet A C0 C› bet__le1213 between_exchange3 
        between_exchange4)
  moreover have "Cong B0 C0 B' C'" 
    using ‹Bet A B0 C0› ‹Cong A B0 A' B'› ‹Cong A' C' A C0› assms(3) l4_3_1 not_cong_3412 by blast
  ultimately show ?thesis 
    using cong__le3412 le_transitivity by blast
qed

lemma bet2_le2__le2356:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "A B Le A' B'" and
    "A' C' Le A C"
  shows "B' C' Le B C"
proof (cases)
  assume "A = B"
  thus ?thesis
    using assms(1) assms(2) assms(3) assms(4) bet2_le2__le2356_R1 by blast
next
  assume "¬ A = B"
  thus ?thesis
    using assms(1) assms(2) assms(3) assms(4) bet2_le2__le2356_R2 by blast
qed

lemma bet2_le2__le1245:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "B C Le B' C'" and
    "A' C' Le A C"
  shows "A' B' Le A B"
  using assms(1) assms(2) assms(3) assms(4) bet2_le2__le2356 between_symmetry le_comm by blast

lemma cong_preserves_bet:
  assumes "Bet B A' A0" and
    "Cong B A' E D'" and
    "Cong B A0 E D0" and
    "E Out D' D0"
  shows "Bet E D' D0"
  using l6_13_1 Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) assms(4)
    bet__le1213 l5_6 by fastforce

lemma out_cong_cong:
  assumes "B Out A A0" and
    "E Out D D0" and
    "Cong B A E D" and
    "Cong B A0 E D0"
  shows "Cong A A0 D D0"
  by (meson Out_def assms(1) assms(2) assms(3) assms(4) cong_4321 cong_symmetry l4_3_1 l5_6 
      l6_13_1 l6_13_2)

lemma not_out_bet:
  assumes "Col A B C" and
    "¬ B Out A C"
  shows "Bet A B C"
  using assms(1) assms(2) l6_4_2 by blast

lemma or_bet_out:
  shows "Bet A B C ∨ B Out A C ∨ ¬ Col A B C"
  using not_out_bet by blast

lemma not_bet_out:
  assumes "Col A B C" and
    "¬ Bet A B C"
  shows "B Out A C"
  by (simp add: assms(1) assms(2) l6_4_2)

lemma not_bet_and_out:
  shows  "¬ (Bet A B C ∧ B Out A C)"
  using bet_col l6_4_1 by blast

lemma out_to_bet:
  assumes "Col A' B' C'" and
    "B Out A C ⟷ B' Out A' C'" and
    "Bet A B C"
  shows "Bet A' B' C'"
  using assms(1) assms(2) assms(3) not_bet_and_out or_bet_out by blast

lemma col_out2_col:
  assumes "Col A B C" and
    "B Out A AA" and
    "B Out C CC"
  shows "Col AA B CC" 
  by (metis Col_cases assms(1) assms(2) assms(3) col_transitivity_1 out_col out_diff1)

lemma bet2_out_out:
  assumes "B ≠ A" and
    "B' ≠ A" and
    "A Out C C'" and
    "Bet A B C" and
    "Bet A B' C'"
  shows "A Out B B'"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) bet_out l6_6 l6_7)

lemma bet2__out:
  assumes "A ≠ B" and
    "A ≠ B'" and
    "Bet A B C"
    and "Bet A B' C"
  shows "A Out B B'"
  using Out_def assms(1) assms(2) assms(3) assms(4) l5_3 by auto

lemma out_bet_out_1:
  assumes "P Out A C" and
    "Bet A B C"
  shows "P Out A B"
  by (metis assms(1) assms(2) not_bet_and_out out2_bet_out out_trivial)

lemma out_bet_out_2:
  assumes "P Out A C" and
    "Bet A B C"
  shows "P Out B C"
  using assms(1) assms(2) l6_6 l6_7 out_bet_out_1 by blast

lemma out_bet__out:
  assumes "Bet P Q A" and
    "Q Out A B"
  shows "P Out A B"
  by (smt (verit, best) Out_def assms(1,2) bet3__bet l5_1 not_bet_and_out
      outer_transitivity_between2) 

lemma segment_reverse:
  assumes "Bet A B C "
  shows "∃ B'. Bet A B' C ∧ Cong C B' A B"
  by (metis Bet_perm Cong_perm assms bet_cong_eq cong_reflexivity segment_construction_2)

lemma diff_col_ex:
  shows "∃ C. A ≠ C ∧ B ≠ C ∧ Col A B C"
  by (metis bet_col bet_neq12__neq point_construction_different)

lemma diff_bet_ex3:
  assumes "Bet A B C"
  shows "∃ D. A ≠ D ∧ B ≠ D ∧ C ≠ D ∧ Col A B D"
  by (metis Col_def bet_out_1 between_trivial2 col_transitivity_1 l6_4_1 
      point_construction_different)

lemma diff_col_ex3:
  assumes "Col A B C"
  shows "∃ D. A ≠ D ∧ B ≠ D ∧ C ≠ D ∧ Col A B D"
  by (metis Bet_perm Col_def between_equality between_trivial2 point_construction_different)

lemma Out_cases:
  assumes "A Out B C ∨ A Out C B"
  shows "A Out B C"
  using assms l6_6 by blast

(** Existence of the sum *)

lemma ex_sums: 
  shows "∃ E F. A B C D SumS E F" 
proof -
  obtain R where "Bet A B R" and "Cong B R C D" 
    using segment_construction by blast
  thus ?thesis 
    using SumS_def cong_reflexivity by blast
qed

(** Commutativity of the sum. *)

lemma sums_sym:
  assumes "A B C D SumS E F" 
  shows "C D A B SumS E F" 
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and "Cong Q R C D" and "Cong P R E F" 
    using SumS_def assms by auto
  thus ?thesis 
    by (meson Cong_cases SumS_def between_symmetry)
qed

(** Unicity of the sum. *)

lemma sums2__cong56:
  assumes "A B C D SumS E F" and
    "A B C D SumS E' F'"
  shows "Cong E F E' F'" 
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and "Cong Q R C D" and "Cong P R E F"
    using SumS_def assms(1) by blast
  obtain P' Q' R' where "Bet P' Q' R'" and "Cong P' Q' A B" and "Cong Q' R' C D" and "Cong P' R' E' F'"
    using SumS_def assms(2) by blast
  have "Cong P Q P' Q'" 
    using Cong_cases ‹Cong P Q A B› ‹Cong P' Q' A B› cong_transitivity by blast
  have "Cong Q R Q' R'" 
    using Cong_cases ‹Cong Q R C D› ‹Cong Q' R' C D› cong_transitivity by blast
  hence "Cong P R P' R'" 
    using ‹Bet P Q R› ‹Bet P' Q' R'› ‹Cong P Q P' Q'› l2_11_b by blast
  hence "Cong P R E' F'" 
    using ‹Cong P' R' E' F'› cong_transitivity by blast
  thus ?thesis 
    using ‹Cong P R E F› cong_inner_transitivity by blast
qed
  (** Unicity of the difference of segments. *)

lemma sums2__cong12: 
  assumes "A B C D SumS E F" 
    and "A' B' C D SumS E F" 
  shows "Cong A B A' B'" 
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and "Cong Q R C D" and "Cong P R E F"
    using SumS_def assms(1) by blast
  obtain P' Q' R' where "Bet P' Q' R'" and "Cong P' Q' A' B'" and "Cong Q' R' C D" and "Cong P' R' E F"
    using SumS_def assms(2) by blast
  have "Cong P R P' R'" 
    using Cong_cases ‹Cong P R E F› ‹Cong P' R' E F› cong_transitivity by blast
  moreover have "Cong Q R Q' R'" 
    using ‹Cong Q R C D› ‹Cong Q' R' C D› cong_inner_transitivity cong_symmetry by blast
  ultimately have "Cong P Q P' Q'" 
    using ‹Bet P Q R› ‹Bet P' Q' R'› l4_3 by blast
  hence "Cong P Q A' B'" 
    using ‹Cong P' Q' A' B'› cong_transitivity by blast
  thus ?thesis 
    using ‹Cong P Q A B› cong_inner_transitivity by blast
qed
  (** Unicity of the difference of segments on the right. *)

lemma sums2__cong34: 
  assumes "A B C D SumS E F" and
    "A B C' D' SumS E F"
  shows "Cong C D C' D'" 
  using assms(1) assms(2) sums2__cong12 sums_sym by blast

(** Cong preserves SumS *)

lemma cong3_sums__sums:
  assumes "Cong A B A' B'" and
    "Cong C D C' D'" and 
    "Cong E F E' F'" and 
    "A B C D SumS E F" 
  shows "A' B' C' D' SumS E' F'" 
  by (meson SumS_def assms(1) assms(2) assms(3) assms(4) cong_inner_transitivity cong_symmetry)

(** The degenerate segments represent the additive identity *)

lemma sums123312:
  shows "A B C C SumS A B" 
  using SumS_def between_trivial cong_reflexivity cong_trivial_identity by blast

lemma sums__cong1245: 
  assumes "A B C C SumS D E"
  shows "Cong A B D E" 
  using assms sums123312 sums2__cong56 by blast

lemma sums__eq34: 
  assumes "A B C D SumS A B"
  shows "C = D" 
  using assms cong_reverse_identity sums123312 sums2__cong34 by blast

lemma sums112323: 
  shows "A A B C SumS B C" 
  by (simp add: sums123312 sums_sym)

lemma sums__cong2345: 
  assumes "A A B C SumS D E"
  shows "Cong B C D E" 
  using assms sums112323 sums2__cong56 by blast

lemma sums__eq12: 
  assumes "A B C D SumS C D" 
  shows "A = B" 
  using assms sums__eq34 sums_sym by blast

(** Some permutation properties *)

lemma sums_left_comm:
  assumes "A B C D SumS E F"
  shows "B A C D SumS E F" 
  using assms cong3_sums__sums cong_pseudo_reflexivity cong_reflexivity by blast

lemma sums_middle_comm: 
  assumes "A B C D SumS E F"
  shows "A B D C SumS E F" 
  using assms sums_left_comm sums_sym by blast

lemma sums_right_comm: 
  assumes "A B C D SumS E F" 
  shows "A B C D SumS F E" 
  using assms cong3_sums__sums cong_pseudo_reflexivity cong_reflexivity by blast

lemma sums_comm: 
  assumes "A B C D SumS E F"
  shows "B A D C SumS F E" 
  using assms cong3_sums__sums cong_pseudo_reflexivity by blast

(** Basic case of sum *)

lemma bet__sums: 
  assumes "Bet A B C" 
  shows "A B B C SumS A C"
  using SumS_def assms cong_reflexivity by blast

lemma sums_assoc_1:
  assumes "A B C D SumS G H" and
    "C D E F SumS I J" and
    "G H E F SumS K L" 
  shows "A B I J SumS K L" 
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and 
    "Cong Q R C D" and "Cong P R G H"
    using assms(1) SumS_def by fastforce
  obtain S where "Bet P R S" and "Cong R S E F" 
    using segment_construction by blast
  hence "Bet P Q S" 
    using ‹Bet P Q R› between_exchange4 by blast
  moreover have "Cong Q S I J" 
    using SumS_def ‹Bet P Q R› ‹Bet P R S› ‹Cong Q R C D› ‹Cong R S E F› assms(2) between_exchange3 cong_reflexivity sums2__cong56 by blast
  moreover have "Cong P S K L" 
    using SumS_def ‹Bet P R S› ‹Cong P R G H› ‹Cong R S E F› assms(3) cong_reflexivity sums2__cong56 by blast
  ultimately show ?thesis 
    using SumS_def ‹Cong P Q A B› by blast
qed

lemma sums_assoc_2:
  assumes "A B C D SumS G H" and
    "C D E F SumS I J" and
    "A B I J SumS K L"
  shows "G H E F SumS K L"
proof -
  have "E F G H SumS K L"
  proof -
    have "E F C D SumS I J" 
      by (simp add: assms(2) sums_sym)
    moreover have "C D A B SumS G H" 
      by (simp add: assms(1) sums_sym)
    moreover have "I J A B SumS K L" 
      using assms(3) sums_sym by blast
    ultimately show ?thesis
      using sums_assoc_1 by blast
  qed
  thus ?thesis     
    using sums_sym by blast
qed

(** Associativity of the sum. *)

lemma sums_assoc:
  assumes "A B C D SumS G H" and
    "C D E F SumS I J"
  shows "G H E F SumS K L ⟷ A B I J SumS K L" 
  by (meson assms(1) assms(2) sums_assoc_1 sums_assoc_2)

(** AB <= AB + CD *)

lemma sums__le1256: 
  assumes "A B C D SumS E F"
  shows "A B Le E F" 
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and 
    "Cong Q R C D" and "Cong P R E F" 
    using SumS_def assms by blast
  thus ?thesis 
    using bet__le1213 l5_6 by blast
qed

(** CD <= AB + CD *)

lemma sums__le3456: 
  assumes "A B C D SumS E F" 
  shows "C D Le E F" 
  using assms sums__le1256 sums_sym by blast

(** If the sum of two segments is degenerate, then the segments are degenerate *)

lemma eq_sums__eq: 
  assumes "A B C D SumS E E"
  shows "A = B ∧ C = D" 
  by (metis assms cong_identity le_diff sums__cong1245 sums__le3456)

lemma sums_diff_1: 
  assumes "A ≠ B" and
    "A B C D SumS E F"
  shows "E ≠ F" 
  using assms(1) assms(2) eq_sums__eq by force

lemma sums_diff_2: 
  assumes "C ≠ D" and
    "A B C D SumS E F" 
  shows "E ≠ F" 
  using assms(1) assms(2) eq_sums__eq by blast

(** SumS preserves Le *)

lemma le2_sums2__le:
  assumes "A B Le A' B'" and
    "C D Le C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "E F Le E' F'"
proof -
  obtain P Q R where "Bet P Q R" and "Cong P Q A B" and 
    "Cong Q R C D" and "Cong P R E F" 
    using SumS_def assms(3) by blast
  obtain P' Q' R' where "Bet P' Q' R'" and "Cong P' Q' A' B'" and 
    "Cong Q' R' C' D'" and "Cong P' R' E' F'" 
    using SumS_def assms(4) by blast
  have "P Q Le P' Q'" 
    by (meson ‹Cong P Q A B› ‹Cong P' Q' A' B'› assms(1) cong_symmetry l5_6)
  moreover have "Q R Le Q' R'" 
    by (meson Cong_perm ‹Cong Q R C D› ‹Cong Q' R' C' D'› assms(2) l5_6)
  ultimately have "P R Le P' R'" 
    using ‹Bet P Q R› ‹Bet P' Q' R'› bet2_le2__le1346 by blast
  thus ?thesis 
    using ‹Cong P R E F› ‹Cong P' R' E' F'› l5_6 by blast
qed

(** If AB <= A'B', CD <= C'D' and AB + CD = A'B' + C'D', then AB = A'B' and CD = C'D' *)

lemma le2_sums2__cong12:
  assumes "A B Le A' B'" and
    "C D Le C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E F" 
  shows "Cong A B A' B'" 
proof -
  obtain E' F' where "A' B' C D SumS E' F'" 
    using ex_sums by blast
  hence "Cong E' F' E F" 
    by (meson assms(1) assms(2) assms(3) assms(4) le2_sums2__le le_anti_symmetry le_reflexivity)
  hence "A' B' C D SumS E F" 
    using ‹A' B' C D SumS E' F'› cong3_sums__sums cong_reflexivity by blast
  thus ?thesis
    using assms(3) sums2__cong12 by blast
qed

lemma le2_sums2__cong34:
  assumes "A B Le A' B'" and
    "C D Le C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E F" 
  shows "Cong C D C' D'" 
  by (meson assms(1) assms(2) assms(3) assms(4) cong3_sums__sums cong_reflexivity 
      le2_sums2__cong12 sums2__cong34)

(** If AB < A'B' and CD <= C'D', then AB + CD < A'B' + C'D' *)

lemma le_lt12_sums2__lt:
  assumes "A B Lt A' B'" and 
    "C D Le C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "E F Lt E' F'" 
proof -
  have "E F Le E' F'" 
    using Lt_def assms(1) assms(2) assms(3) assms(4) le2_sums2__le by blast
  moreover {
    assume "Cong E F E' F'" 
    hence "A' B' C' D' SumS E F" 
      by (meson assms(4) cong3_sums__sums cong_reflexivity not_cong_3412)
    hence "Cong A B A' B'" 
      using assms(1) assms(2) assms(3) le2_sums2__cong12 lt__le by blast
    hence False 
      using assms(1) cong__nlt lt__le by blast 
  }
  ultimately show ?thesis 
    using Lt_def by blast
qed

lemma le_lt34_sums2__lt:
  assumes "A B Le A' B'" and 
    "C D Lt C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "E F Lt E' F'" 
  using assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt sums_sym by blast

lemma lt2_sums2__lt:
  assumes "A B Lt A' B'" and
    "C D Lt C' D'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "E F Lt E' F'" 
  using assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt lt__le by blast

(** If CD >= C'D' and AB + CD <= A'B' + C'D', then AB <= A'B' *)

lemma le2_sums2__le12:
  assumes "C' D' Le C D" and
    "E F Le E' F'" and 
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "A B Le A' B'" 
  using assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt lt__nle nlt__le by blast

lemma le2_sums2__le34:
  assumes "A' B' Le A B" and
    "E F Le E' F'" and
    "A B C D SumS E F" and 
    "A' B' C' D' SumS E' F'" 
  shows "C D Le C' D'" 
  by (meson assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt lt__nle nlt__le sums_sym)

(** If CD > C'D' and AB + CD <= A'B' + C'D', then AB < A'B' *)

lemma le_lt34_sums2__lt12:
  assumes "C' D' Lt C D" and
    "E F Le E' F'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "A B Lt A' B'" 
  by (meson assms(1) assms(2) assms(3) assms(4) le3456_lt__lt le_lt34_sums2__lt nle__lt nlt)

lemma le_lt12_sums2__lt34:
  assumes "A' B' Lt A B" and
    "E F Le E' F'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "C D Lt C' D'" 
  using assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt lt__nle nlt__le by blast

(** If CD >= C'D' and AB + CD < A'B' + C'D', then AB < A'B' *)

lemma le_lt56_sums2__lt12:
  assumes "C' D' Le C D" and
    "E F Lt E' F'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "A B Lt A' B'" 
  by (meson assms(1) assms(2) assms(3) assms(4) le2_sums2__le le__nlt nle__lt)

lemma le_lt56_sums2__lt34:
  assumes "A' B' Le A B" and
    "E F Lt E' F'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "C D Lt C' D'" 
  using assms(1) assms(2) assms(3) assms(4) le2_sums2__le lt__nle nlt__le by blast

lemma lt2_sums2__lt12:
  assumes "C' D' Lt C D" and
    "E F Lt E' F'" and 
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "A B Lt A' B'" 
  using assms(1) assms(2) assms(3) assms(4) le_lt34_sums2__lt nle__lt not_and_lt by blast

lemma lt2_sums2__lt34: 
  assumes "A' B' Lt A B" and
    "E F Lt E' F'" and
    "A B C D SumS E F" and
    "A' B' C' D' SumS E' F'" 
  shows "C D Lt C' D'" 
  by (meson assms(1) assms(2) assms(3) assms(4) le_lt12_sums2__lt nlt__le not_and_lt)

lemma midpoint_dec:
  "I Midpoint A B ∨ ¬ I Midpoint A B"
  by simp

lemma is_midpoint_id:
  assumes "A Midpoint A B"
  shows "A = B"
  using Midpoint_def assms between_cong by blast

lemma is_midpoint_id_2:
  assumes "A Midpoint B A"
  shows "A = B"
  using Midpoint_def assms cong_diff_2 by blast

lemma l7_2:
  assumes "M Midpoint A B"
  shows "M Midpoint B A"
  using Bet_perm Cong_perm Midpoint_def assms by blast

lemma l7_3:
  assumes "M Midpoint A A"
  shows "M = A"
  using Midpoint_def assms bet_neq23__neq by blast

lemma l7_3_2:
  "A Midpoint A A"
  by (simp add: Midpoint_def between_trivial2 cong_reflexivity)

lemma symmetric_point_construction:
  "∃ P'. A Midpoint P P'"
  by (meson Midpoint_def cong__le cong__le3412 le_anti_symmetry segment_construction)

lemma symmetric_point_uniqueness:
  assumes "P Midpoint A P1" and
    "P Midpoint A P2"
  shows "P1 = P2"
  by (metis Midpoint_def assms(1) assms(2) between_cong_3 cong_diff_4 cong_inner_transitivity)

lemma l7_9:
  assumes "A Midpoint P X" and
    "A Midpoint Q X"
  shows "P = Q"
  using assms(1) assms(2) l7_2 symmetric_point_uniqueness by blast

lemma l7_9_bis:
  assumes "A Midpoint P X" and
    "A Midpoint X Q"
  shows "P = Q"
  using assms(1) assms(2) l7_2 symmetric_point_uniqueness by blast

lemma l7_13_R1:
  assumes "A ≠ P" and
    "A Midpoint P' P" and
    "A Midpoint Q' Q"
  shows "Cong P Q P' Q'"
proof -
  obtain X where "Bet P' P X" and "Cong P X Q A"
    using segment_construction by blast
  obtain X' where "Bet X P' X'" and "Cong P' X' Q A"
    using segment_construction by blast
  obtain Y where "Bet Q' Q Y" and "Cong Q Y P A"
    using segment_construction by blast
  obtain Y' where "Bet Y Q' Y'" and "Cong Q' Y' P A"
    using segment_construction by blast
  have "Bet Y A Q'"
    using Bet_cases Midpoint_def ‹Bet Q' Q Y› assms(3) between_exchange4 by blast
  have "Bet P' A X"
    using Midpoint_def ‹Bet P' P X› assms(2) between_exchange4 by blast
  have "Bet A P X" 
    using Midpoint_def ‹Bet P' P X› assms(2) between_exchange3 by blast
  have "Bet Y Q A" 
    using Midpoint_def ‹Bet Q' Q Y› assms(3) between_exchange3 between_symmetry by blast
  have "Bet A Q' Y'"
    using ‹Bet Y A Q'› ‹Bet Y Q' Y'› between_exchange3 by blast
  have "Bet X' P' A" 
    using ‹Bet P' A X› ‹Bet X P' X'› between_exchange3 between_symmetry by blast
  hence "Bet X A X'"
    using ‹Bet P' A X› ‹Bet X P' X'› between_symmetry outer_transitivity_between2 by blast
  have "Bet Y A Y'" 
    using ‹Bet Y A Q'› ‹Bet Y Q' Y'› between_exchange4 by blast
  have "Cong A X Y A"
    using ‹Bet A P X› ‹Bet Y Q A› ‹Cong P X Q A› ‹Cong Q Y P A› l2_11_b not_cong_4321 by blast
  have "Cong A Y' X' A"
  proof -
    have "Cong Q' Y' P' A"
      using Midpoint_def ‹Cong Q' Y' P A› assms(2) cong_4312 cong_transitivity by blast
    have "Cong A Q' X' P'"
      by (metis Cong_cases Midpoint_def ‹Cong P' X' Q A› assms(3) cong_transitivity)
    thus ?thesis 
      using ‹Bet A Q' Y'› ‹Bet X' P' A› ‹Cong Q' Y' P' A› l2_11_b by force
  qed
  have "Cong A Y A Y'"
  proof -
    have "Cong Q Y Q' Y'" 
      using ‹Cong Q Y P A› ‹Cong Q' Y' P A› cong_inner_transitivity cong_symmetry by blast
    thus ?thesis 
      by (meson Midpoint_def ‹Bet A Q' Y'› ‹Bet Q' Q Y› assms(3) between_exchange3 
          cong_left_commutativity cong_symmetry l2_11_b)
  qed
  have "Cong X A Y' A" 
    by (metis cong_inner_transitivity ‹Cong A X Y A› ‹Cong A Y A Y'› cong_4312)
  have "Cong A X' A Y" 
    using ‹Cong A Y A Y'› ‹Cong A Y' X' A› cong_4312 cong_transitivity by blast
  have "Cong A X A X'"
    using Cong_cases ‹Cong A X Y A› ‹Cong A X' A Y› cong_transitivity by blast
  have "X A X' Y' FSC Y' A Y X" 
  proof -
    have "Col X A X'"
      using Col_def ‹Bet X A X'› by blast
    have "Cong X X' Y' Y" 
      using Cong_cases ‹Bet X A X'› ‹Bet Y A Y'› ‹Cong A X Y A› ‹Cong A Y' X' A› l2_11_b by blast
    thus ?thesis 
      using Cong3_def FSC_def ‹Col X A X'› ‹Cong A X' A Y› ‹Cong X A Y' A› 
        cong_pseudo_reflexivity not_cong_4321 by blast
  qed
  hence "Y Q A X IFSC Y' Q' A X'" 
    by (metis Bet_cases Cong_cases IFSC_def Midpoint_def bet_neq23__neq 
        ‹Bet A P X› ‹Bet A Q' Y'› ‹Bet X A X'› ‹Bet Y Q A› ‹Cong A X A X'› ‹Cong A Y A Y'› 
        assms(1) assms(3) l4_16R1)
  hence "X P A Q IFSC X' P' A Q'" 
    by (metis Cong_cases IFSC_def Midpoint_def ‹Bet A P X› ‹Bet X' P' A› assms(2) 
        between_symmetry l4_2)
  thus ?thesis 
    using l4_2 by force
qed

lemma l7_13:
  assumes "A Midpoint P' P" and
    "A Midpoint Q' Q"
  shows "Cong P Q P' Q'"
proof (cases)
  assume "A = P"
  thus ?thesis
    using Midpoint_def assms(1) assms(2) cong_3421 is_midpoint_id_2 by blast
next
  show ?thesis
    by (metis l7_13_R1 assms(1) assms(2) cong_trivial_identity is_midpoint_id_2 not_cong_2143)
qed

lemma l7_15:
  assumes "A Midpoint P P'" and
    "A Midpoint Q Q'" and
    "A Midpoint R R'" and
    "Bet P Q R"
  shows "Bet P' Q' R'"
proof -
  have "P Q R Cong3 P' Q' R'"
    using Cong3_def assms(1) assms(2) assms(3) l7_13 l7_2 by blast
  thus ?thesis
    using assms(4) l4_6 by blast
qed

lemma l7_16:
  assumes "A Midpoint P P'" and
    "A Midpoint Q Q'" and
    "A Midpoint R R'" and
    "A Midpoint S S'" and
    "Cong P Q R S"
  shows "Cong P' Q' R' S'"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) cong_transitivity l7_13 not_cong_3412)

lemma symmetry_preserves_midpoint:
  assumes "Z Midpoint A D" and
    "Z Midpoint B E" and
    "Z Midpoint C F" and
    "B Midpoint A C"
  shows "E Midpoint D F"
  by (meson Midpoint_def assms(1) assms(2) assms(3) assms(4) l7_15 l7_16)

lemma Mid_cases:
  assumes "A Midpoint B C ∨ A Midpoint C B"
  shows "A Midpoint B C"
  using assms l7_2 by blast

lemma Mid_perm:
  assumes "A Midpoint B C"
  shows "A Midpoint B C ∧ A Midpoint C B"
  by (simp add: assms l7_2)

lemma l7_17:
  assumes "A Midpoint P P'" and
    "B Midpoint P P'"
  shows "A = B"
proof -
  have "Cong P B P' B" 
    using Cong_cases Midpoint_def assms(2) by blast
  obtain x where "A Midpoint B x" 
    using symmetric_point_construction by presburger
  hence "Cong P' B P x" 
    using assms(1) l7_13 l7_2 by blast
  hence "Cong P B P x" 
    using ‹Cong P B P' B› cong_transitivity by blast
  have "Cong P B P' x" 
    using ‹A Midpoint B x› assms(1) cong_4321 l7_13 by blast
  have "Cong P' B P' x" 
    using cong_inner_transitivity ‹Cong P B P' B› ‹Cong P B P' x› by blast
  have "Bet P B P'" 
    using Midpoint_def assms(2) by blast
  hence "B = x" 
    using ‹Cong P B P x› ‹Cong P' B P' x› l4_19 by auto
  thus ?thesis 
    using ‹A Midpoint B x› l7_3 by blast
qed

lemma l7_17_bis:
  assumes "A Midpoint P P'" and
    "B Midpoint P' P"
  shows "A = B"
  by (meson l7_17 l7_2 Tarski_neutral_dimensionless_axioms assms(1) assms(2))

lemma l7_20:
  assumes "Col A M B" and
    "Cong M A M B"
  shows "A = B ∨ M Midpoint A B"
  by (metis Bet_cases Col_def Midpoint_def assms(1) assms(2) between_cong 
      cong_left_commutativity not_cong_3412)

lemma l7_20_bis:
  assumes "A ≠ B" and
    "Col A M B" and
    "Cong M A M B"
  shows "M Midpoint A B"
  using assms(1) assms(2) assms(3) l7_20 by blast

lemma cong_col_mid:
  assumes "A ≠ C" and
    "Col A B C" and
    "Cong A B B C"
  shows "B Midpoint A C"
  using assms(1) assms(2) assms(3) cong_left_commutativity l7_20 by blast

lemma l7_21_R1:
  assumes "¬ Col A B C" and
    "B ≠ D" and
    "Cong A B C D" and
    "Cong B C D A" and
    "Col A P C" and
    "Col B P D"
  shows "P Midpoint A C"
proof -
  obtain X where "B D P Cong3 D B X"
    using Col_perm assms(6) cong_pseudo_reflexivity l4_14 by blast
  hence "Col D B X"
    using assms(6) l4_13 not_col_permutation_5 by blast
  have "B D P A FSC D B X C" 
    by (meson Col_cases Cong_cases FSC_def ‹B D P Cong3 D B X› assms(3) assms(4) assms(6))
  have "B D P C FSC D B X A" 
    using Col_cases Cong_perm FSC_def ‹B D P Cong3 D B X› assms(3) assms(4) assms(6) by blast
  hence "A P C Cong3 C X A" 
    using Cong3_def Cong_cases ‹B D P A FSC D B X C› assms(2) cong_pseudo_reflexivity l4_16 
    by blast
  hence "Col C X A" 
    using assms(5) l4_13 by blast
  hence "P = X" 
    using ‹Col D B X› assms(1) assms(2) assms(5) assms(6) l6_21 not_col_permutation_1 
      not_col_permutation_5 by blast
  thus ?thesis 
    by (metis Col_perm ‹B D P A FSC D B X C› ‹Col C X A› assms(1) assms(2) l4_16 l7_20_bis 
        not_col_distincts)
qed

lemma l7_21:
  assumes "¬ Col A B C" and
    "B ≠ D" and
    "Cong A B C D" and
    "Cong B C D A" and
    "Col A P C" and
    "Col B P D"
  shows "P Midpoint A C ∧ P Midpoint B D" 
  by (metis Cong_cases Midpoint_def assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
      cong_reverse_identity l7_21_R1 not_col_distincts)

lemma l7_22_aux_R1:
  assumes "Bet A1 C C" and
    "Bet B1 C B2" and
    "Cong C A1 C B1" and
    "Cong C C C B2" and
    "M1 Midpoint A1 B1" and
    "M2 Midpoint A2 B2"and
    "C A1 Le C C"
  shows "Bet M1 C M2"
  by (metis assms(3) assms(5) assms(7) cong_diff_3 l7_3 le_diff not_bet_distincts)

lemma l7_22_aux_R2:
  assumes "A2 ≠ C" and
    "Bet A1 C A2" and
    "Bet B1 C B2" and
    "Cong C A1 C B1" and
    "Cong C A2 C B2" and
    "M1 Midpoint A1 B1" and
    "M2 Midpoint A2 B2" and
    "C A1 Le C A2"
  shows "Bet M1 C M2"
proof -
  obtain X where "C Midpoint A2 X"
    using symmetric_point_construction by blast
  obtain X0 where "C Midpoint B2 X0"
    using symmetric_point_construction by blast
  obtain X1 where "C Midpoint M2 X1"
    using symmetric_point_construction by blast
  hence "X1 Midpoint X X0"
    using ‹C Midpoint A2 X› ‹C Midpoint B2 X0› assms(7) symmetry_preserves_midpoint by blast
  have "C A1 Le C X" 
    by (metis Midpoint_def cong_reflexivity l5_6 ‹C Midpoint A2 X› assms(8) le_right_comm)
  hence "Bet C A1 X"
    by (metis (full_types) Bet_cases Le_cases Midpoint_def ‹C Midpoint A2 X› assms(1,2)
        bet_le_eq l5_2) 
  have "Cong C X C X0" 
    by (meson l7_3_2 ‹C Midpoint A2 X› ‹C Midpoint B2 X0› assms(5) l7_16)
  hence "C B1 Le C X0"
    using ‹C A1 Le C X› assms(4) l5_6 by blast
  have "Bet C B1 X0" 
  proof cases
    assume "B1 = C"
    thus ?thesis 
      using between_trivial2 by auto
  next
    assume "B1 ≠ C"
    thus ?thesis
      by (metis (full_types) Bet_cases Le_cases Midpoint_def ‹C B1 Le C X0› ‹C Midpoint B2 X0› assms(3)
          bet_cong_eq bet_le_eq l5_2)
  qed
  hence "Bet X0 B1 C" 
    using Bet_cases by blast
  have "∃ Q. Bet X1 Q C ∧ Bet A1 Q B1" 
  proof -
    have "Bet X A1 C" 
      using Bet_cases ‹Bet C A1 X› by blast
    moreover have "Bet X X1 X0" 
      using Midpoint_def ‹X1 Midpoint X X0› by auto
    ultimately show ?thesis 
      using ‹Bet X0 B1 C› l3_17 by blast
  qed
  then obtain Q where "Bet X1 Q C" and "Bet A1 Q B1" 
    by blast
  have "X A1 C X1 IFSC X0 B1 C X1" 
    by (metis Bet_cases Cong_cases IFSC_def Midpoint_def ‹Bet C A1 X› ‹Bet X0 B1 C› 
        ‹Cong C X C X0› ‹X1 Midpoint X X0› assms(4) cong_reflexivity)
  hence "Cong A1 X1 B1 X1" 
    using l4_2 by auto
  have  "Cong Q A1 Q B1"
  proof cases
    assume "C = X1"
    thus ?thesis 
      using between_identity ‹Bet X1 Q C› assms(4) by blast
  next
    assume "¬ C = X1"
    moreover
    have "Col C X1 Q" 
      by (simp add: Col_def ‹Bet X1 Q C›)
    moreover
    have "Cong X1 A1 X1 B1" 
      using Cong_cases ‹Cong A1 X1 B1 X1› by auto
    ultimately show ?thesis 
      by (simp add: assms(4) l4_17)
  qed
  have "Q Midpoint A1 B1" 
    using Midpoint_def ‹Bet A1 Q B1› ‹Cong Q A1 Q B1› not_cong_2134 by blast
  thus ?thesis 
    by (metis Midpoint_def ‹Bet X1 Q C› ‹C Midpoint M2 X1› assms(6) between_inner_transitivity 
        between_symmetry l7_17)
qed

lemma l7_22_aux:
  assumes "Bet A1 C A2" and
    "Bet B1 C B2" and
    "Cong C A1 C B1" and
    "Cong C A2 C B2" and
    "M1 Midpoint A1 B1" and
    "M2 Midpoint A2 B2" and
    "C A1 Le C A2"
  shows "Bet M1 C M2" 
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) between_trivial 
      cong_diff_4 l7_22_aux_R2 l7_3)

lemma l7_22:
  assumes "Bet A1 C A2" and
    "Bet B1 C B2" and
    "Cong C A1 C B1" and
    "Cong C A2 C B2" and
    "M1 Midpoint A1 B1" and
    "M2 Midpoint A2 B2"
  shows "Bet M1 C M2"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) between_symmetry l7_22_aux 
      le_cases)

lemma bet_col1:
  assumes "Bet A B D" and
    "Bet A C D"
  shows "Col A B C"
  using Bet_perm Col_def assms(1) assms(2) l5_3 by blast

lemma l7_25_R1:
  assumes "Cong C A C B" and
    "Col A B C"
  shows "∃ X. X Midpoint A B"
  using assms(1) assms(2) l7_20 l7_3_2 not_col_permutation_5 by blast

lemma l7_25_R2:
  assumes "Cong C A C B" and
    "¬ Col A B C"
  shows "∃ X. X Midpoint A B"
proof -
  obtain P where "Bet C A P" and "A ≠ P"
    using point_construction_different by auto
  obtain Q where "Bet C B Q" and "Cong B Q A P"
    using segment_construction by blast
  obtain R where "Bet A R Q" and "Bet B R P" 
    by (meson ‹Bet C A P› ‹Bet C B Q› l3_17 not_bet_distincts)
  obtain X where "Bet A X B" and "Bet R X C" 
    using ‹Bet B R P› ‹Bet C A P› inner_pasch by blast
  have "Cong X A X B"
  proof -
    have "Cong R A R B ⟶ Cong X A X B"
    proof cases
      assume "R = C"
      thus ?thesis 
        using ‹Bet R X C› between_identity by blast
    next
      assume "¬ R = C"
      have "Col R C X" 
        using ‹Bet R X C› bet_col1 between_trivial by blast
      thus ?thesis 
        using ‹R ≠ C› assms(1) l4_17 by blast
    qed
    have "Cong R A R B"
    proof -
      have "C A P B OFSC C B Q A" 
        by (metis OFSC_def ‹Bet C A P› ‹Bet C B Q› ‹Cong B Q A P› assms(1) 
            cong_pseudo_reflexivity not_cong_3412)
      hence "Cong P B Q A" 
        using assms(2) col_trivial_3 five_segment_with_def by blast
      hence "Cong B P A Q" 
        using Cong_cases by blast
      then obtain R' where "Bet A R' Q" and "B R P Cong3 A R' Q" 
        using ‹Bet B R P› l4_5 by blast
      have "B R P A IFSC A R' Q B" 
        using Cong3_def IFSC_def ‹B R P Cong3 A R' Q› ‹Bet A R' Q› ‹Bet B R P› ‹Cong B Q A P› 
          cong_pseudo_reflexivity not_cong_4321 by blast
      hence "Cong R A R' B" 
        using l4_2 by auto
      have "B R P Q IFSC A R' Q P" 
        using Cong3_def IFSC_def ‹B R P Cong3 A R' Q› ‹Bet A R' Q› ‹Bet B R P› ‹Cong B Q A P› 
          cong_pseudo_reflexivity by blast
      hence "Cong R Q R' P" 
        using l4_2 by blast
      hence "A R Q Cong3 B R' P" 
        using Cong3_def Cong_cases ‹Cong B P A Q› ‹Cong R A R' B› by blast
      have "Col B R' P" 
        using ‹A R Q Cong3 B R' P› ‹Bet A R Q› bet_col l4_13 by blast
      have "R = R'"
      proof -
        have "B ≠ P" 
          using Col_def ‹Bet C A P› assms(2) by blast
        moreover
        have "B ≠ Q" 
          using ‹A ≠ P› ‹Cong B Q A P› cong_reverse_identity by force
        hence "¬ Col A Q B" 
          using ‹Bet C B Q› assms(2) bet_col col2__eq not_col_permutation_5 by blast
        moreover have "Col A Q R" 
          using Bet_cases Col_def ‹Bet A R Q› by auto
        moreover have "Col A Q R'" 
          using ‹Bet A R' Q› bet_col not_col_permutation_5 by blast
        moreover have "Col B P R" 
          using Bet_cases Col_def ‹Bet B R P› by auto
        moreover have "Col B P R'" 
          using ‹Col B R' P› not_col_permutation_5 by blast
        ultimately show ?thesis 
          using ‹B ≠ P› ‹¬ Col A Q B› l6_21 by blast
      qed
      thus ?thesis 
        using ‹Cong R A R' B› by auto
    qed
    thus ?thesis 
      by (simp add: ‹Cong R A R B ⟶ Cong X A X B›)
  qed
  thus ?thesis 
    using Col_def ‹Bet A X B› between_symmetry l7_25_R1 by blast
qed

lemma l7_25:
  assumes "Cong C A C B"
  shows "∃ X. X Midpoint A B"
  using assms l7_25_R1 l7_25_R2 by blast

lemma midpoint_distinct_1:
  assumes "A ≠ B" and
    "I Midpoint A B"
  shows "I ≠ A ∧ I ≠ B"
  using assms(1) assms(2) is_midpoint_id is_midpoint_id_2 by blast

lemma midpoint_distinct_2:
  assumes "I ≠ A" and
    "I Midpoint A B"
  shows "A ≠ B ∧ I ≠ B"
  using assms(1) assms(2) is_midpoint_id_2 l7_3 by blast

lemma midpoint_distinct_3:
  assumes "I ≠ B" and
    "I Midpoint A B"
  shows "A ≠ B ∧ I ≠ A"
  using assms(1) assms(2) is_midpoint_id l7_3 by blast

lemma midpoint_def:
  assumes "Bet A B C" and
    "Cong A B B C"
  shows "B Midpoint A C"
  using Midpoint_def assms(1) assms(2) by blast

lemma midpoint_bet:
  assumes "B Midpoint A C"
  shows "Bet A B C"
  using Midpoint_def assms by blast

lemma midpoint_col:
  assumes "M Midpoint A B"
  shows "Col M A B"
  using assms bet_col col_permutation_4 midpoint_bet by blast

lemma midpoint_cong:
  assumes "B Midpoint A C"
  shows "Cong A B B C"
  using Midpoint_def assms by blast

lemma midpoint_out:
  assumes "A ≠ C" and
    "B Midpoint A C"
  shows "A Out B C"
  using assms(1) assms(2) bet_out midpoint_bet midpoint_distinct_1 by blast

lemma midpoint_out_1:
  assumes "A ≠ C" and
    "B Midpoint A C"
  shows "C Out A B"
  by (metis midpoint_bet midpoint_distinct_1 assms(1) assms(2) bet_out_1 l6_6)

lemma midpoint_not_midpoint:
  assumes "A ≠ B" and
    "I Midpoint A B"
  shows "¬ B Midpoint A I"
  using assms(1) assms(2) between_equality_2 midpoint_bet midpoint_distinct_1 by blast

lemma swap_diff:
  assumes "A ≠ B"
  shows "B ≠ A"
  using assms by auto

lemma cong_cong_half_1:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "Cong A B A' B'"
  shows "Cong A M A' M'"
proof -
  obtain M'' where "Bet A' M'' B'" and "A M B Cong3 A' M'' B'"
    using assms(1) assms(3) l4_5 midpoint_bet by blast
  hence "M'' Midpoint A' B'"
    by (meson Cong3_def assms(1) cong_inner_transitivity midpoint_cong midpoint_def)
  hence "M' = M''"
    using assms(2) l7_17 by auto
  thus ?thesis 
    using Cong3_def ‹A M B Cong3 A' M'' B'› by blast
qed

lemma cong_cong_half_2:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "Cong A B A' B'"
  shows "Cong B M B' M'"
  using assms(1) assms(2) assms(3) cong_cong_half_1 l7_2 not_cong_2143 by blast

lemma cong_mid2__cong:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "Cong A M A' M'"
  shows "Cong A B A' B'"
  by (meson assms(1) assms(2) assms(3) cong_inner_transitivity l2_11_b midpoint_bet midpoint_cong)

lemma mid__lt:
  assumes "A ≠ B" and
    "M Midpoint A B"
  shows "A M Lt A B"
  using assms(1) assms(2) bet__lt1213 midpoint_bet midpoint_distinct_1 by blast

lemma le_mid2__le13:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "A M Le A' M'"
  shows "A B Le A' B'" 
  by (meson Midpoint_def l5_6 assms(1) assms(2) assms(3) bet2_le2__le1346)

lemma le_mid2__le12:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'"
    and "A B Le A' B'"
  shows "A M Le A' M'"
  by (meson assms(1) assms(2) assms(3) cong__le3412 cong_cong_half_1 le_anti_symmetry 
      le_mid2__le13 local.le_cases)

lemma lt_mid2__lt13:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "A M Lt A' M'"
  shows "A B Lt A' B'"
  by (meson le_mid2__le12 Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) 
      lt__nle nlt__le)

lemma lt_mid2__lt12:
  assumes "M Midpoint A B" and
    "M' Midpoint A' B'" and
    "A B Lt A' B'"
  shows "A M Lt A' M'"
  by (meson le_mid2__le13 Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) 
      le__nlt nle__lt)

lemma midpoint_preserves_out:
  assumes "A Out B C" and
    "M Midpoint A A'" and
    "M Midpoint B B'" and
    "M Midpoint C C'"
  shows "A' Out B' C'" 
  using Out_def assms(1) assms(2) assms(3) assms(4) l7_15 l7_9 by fastforce

lemma col_cong_bet:
  assumes "Col A B D" and
    "Cong A B C D" and
    "Bet A C B"
  shows "Bet C A D ∨ Bet C B D" 
proof -
  obtain D1 where "Bet B A D1" and "Cong A D1 B C" 
    using segment_construction by blast
  obtain D2 where "Bet A B D2" and "Cong B D2  A C" 
    using segment_construction by blast
  have "Cong A B C D1" 
    by (meson Bet_cases ‹Bet B A D1› ‹Cong A D1 B C› assms(3) between_exchange4 
        cong_pseudo_reflexivity l4_3_1 not_cong_2134)
  have "D = D1 ∨ C Midpoint D D1" 
  proof -
    have "Col D C D1" 
    proof cases
      assume "A = B"
      thus ?thesis 
        by (metis assms(2) col_trivial_1 cong_diff_3)
    next
      assume "A ≠ B"
      thus ?thesis 
        by (meson Col_def ‹Bet B A D1› assms(1) assms(3) col3 not_col_permutation_4)
    qed
    moreover have "Cong C D C D1" 
      using ‹Cong A B C D1› assms(2) cong_inner_transitivity by blast
    ultimately show ?thesis 
      using l7_20 by auto
  qed
  {
    assume "D = D1"
    hence "Bet C A D ∨ Bet C B D" 
      using ‹Bet B A D1› assms(3) between_exchange3 between_symmetry by blast
  }
  moreover
  {
    assume "C Midpoint D D1"
    have "Cong B A C D2" 
    proof -
      have "Bet B C A" 
        using Bet_cases assms(3) by blast
      moreover have "Bet C B D2" 
        using ‹Bet A B D2› assms(3) between_exchange3 by blast
      moreover have "Cong B C C B" 
        using cong_pseudo_reflexivity by blast
      have "Cong C A B D2" 
        using Cong_cases ‹Cong B D2 A C› by blast
      ultimately show ?thesis 
        using ‹Cong B C C B› l2_11_b by blast
    qed
    have "C Midpoint D2 D1" 
    proof cases
      assume "A = B"
      thus ?thesis 
        by (metis ‹C Midpoint D D1› ‹Cong B A C D2› assms(2) cong_diff_3)
    next
      assume "A ≠ B"
      show ?thesis 
      proof cases
        assume "B = C"
        thus ?thesis 
          using Midpoint_def ‹Bet A B D2› ‹Cong A D1 B C› ‹Cong B D2 A C› between_symmetry 
            cong_commutativity cong_identity by blast
      next
        assume "B ≠ C"
        have "Bet D1 C B" 
          using ‹Bet B A D1› assms(3) between_exchange4 between_symmetry by blast
        have "Bet C B D2" 
          using ‹Bet A B D2› assms(3) between_exchange3 by blast
        thus ?thesis 
          by (metis Midpoint_def cong_inner_transitivity ‹B ≠ C› ‹Bet D1 C B› 
              ‹Cong A B C D1› ‹Cong B A C D2› between_symmetry not_cong_2134 
              outer_transitivity_between2)
      qed
    qed
    have "Bet C A D ∨ Bet C B D" 
      using ‹Bet A B D2› ‹C Midpoint D2 D1› ‹D = D1 ∨ C Midpoint D D1› assms(3) 
        between_exchange3 calculation l7_9 by blast
  }
  ultimately show ?thesis 
    using ‹D = D1 ∨ C Midpoint D D1› by blast
qed

lemma col_cong2_bet1:
  assumes "Col A B D" and
    "Bet A C B" and
    "Cong A B C D" and
    "Cong A C B D"
  shows "Bet C B D"
  by (metis assms(1) assms(2) assms(3) assms(4) bet__le1213 bet_cong_eq between_symmetry 
      col_cong_bet cong__le cong_left_commutativity l5_12_b l5_6 outer_transitivity_between2)

lemma col_cong2_bet2:
  assumes "Col A B D" and
    "Bet A C B" and
    "Cong A B C D" and
    "Cong A D B C"
  shows "Bet C A D"
  by (metis assms(1) assms(2) assms(3) assms(4) bet_cong_eq col_cong_bet 
      cong_identity not_bet_distincts not_cong_3421 outer_transitivity_between2)

lemma col_cong2_bet3:
  assumes "Col A B D" and
    "Bet A B C" and
    "Cong A B C D" and
    "Cong A C B D"
  shows "Bet B C D"
  by (metis assms(1) assms(2) assms(3) assms(4) bet__le1213 bet__le2313 
      bet_col col_transitivity_2 cong_diff_3 cong_reflexivity l5_12_b l5_6 not_bet_distincts)

lemma col_cong2_bet4:
  assumes "Col A B C" and
    "Bet A B D" and
    "Cong A B C D" and
    "Cong A D B C"
  shows "Bet B D C"
  using assms(1) assms(2) assms(3) assms(4) col_cong2_bet3 cong_right_commutativity by blast

lemma col_bet2_cong1:
  assumes "Col A B D" and
    "Bet A C B" and
    "Cong A B C D" and
    "Bet C B D"
  shows "Cong A C D B"
  by (meson assms(2) assms(3) assms(4) between_symmetry cong_pseudo_reflexivity 
      cong_right_commutativity l4_3)

lemma col_bet2_cong2:
  assumes "Col A B D" and
    "Bet A C B" and
    "Cong A B C D" and
    "Bet C A D"
  shows "Cong D A B C"
  by (meson assms(2) assms(3) assms(4) between_symmetry cong_commutativity 
      cong_pseudo_reflexivity cong_symmetry l4_3)

lemma bet2_lt2__lt:
  assumes "Bet a Po b" and
    "Bet A PO B" and
    "Po a Lt PO A" and
    "Po b Lt PO B"
  shows "a b Lt A B"
  by (metis Lt_cases nle__lt assms(1) assms(2) assms(3) assms(4) bet2_le2__le1245 le__nlt lt__le)

lemma bet2_lt_le__lt:
  assumes "Bet a Po b" and
    "Bet A PO B" and
    "Cong Po a PO A" and
    "Po b Lt PO B"
  shows "a b Lt A B" 
proof -
  have "Po a Le PO A" 
    using assms(3) cong__le by blast
  thus ?thesis
    by (meson Le_cases nlt__le assms(1) assms(2) assms(4) bet2_le2__le2356 lt__nle)
qed

lemma per_dec:
  "Per A B C ∨ ¬ Per A B C"
  by simp

lemma l8_2:
  assumes "Per A B C"
  shows "Per C B A"
proof -
  obtain C' where "B Midpoint C C'" and "Cong A C A C'"
    using Per_def assms by blast
  obtain A' where "B Midpoint A A'"
    using symmetric_point_construction by blast
  hence "Cong C' A C A'" 
    using Mid_cases ‹B Midpoint C C'› l7_13 by blast
  thus ?thesis 
    using Per_def ‹B Midpoint A A'› ‹Cong A C A C'› cong_transitivity not_cong_2143 by blast
qed

lemma Per_cases:
  assumes "Per A B C ∨ Per C B A"
  shows "Per A B C"
  using assms l8_2 by blast

lemma Per_perm :
  assumes "Per A B C"
  shows "Per A B C ∧ Per C B A"
  by (simp add: assms l8_2)

lemma l8_3 :
  assumes "Per A B C" and
    "A ≠ B" and
    "Col B A A'"
  shows "Per A' B C" 
  by (metis Per_def cong_left_commutativity assms(1) assms(2) assms(3) l4_17 midpoint_cong)

lemma l8_4:
  assumes "Per A B C" and
    "B Midpoint C C'"
  shows "Per A B C'"
  by (metis l8_2 assms(1) assms(2) l8_3 midpoint_col midpoint_distinct_1)

lemma l8_5:
  shows "Per A B B"
  using Per_def cong_reflexivity l7_3_2 by blast

lemma l8_6:
  assumes "Per A B C" and
    "Per A' B C" and
    "Bet A C A'"
  shows "B = C"
  by (metis Per_def assms(1) assms(2) assms(3) l4_19 midpoint_distinct_3 
      symmetric_point_uniqueness)

lemma l8_7:
  assumes "Per A B C" and
    "Per A C B"
  shows "B = C"
proof -
  obtain C' where P1: "B Midpoint C C' ∧ Cong A C A C'"
    using Per_def assms(1) by blast
  obtain A' where P2: "C Midpoint A A'"
    using Per_def assms(2) l8_2 by blast
  have "Per C' C A"
    by (metis P1 l8_3 assms(2) bet_col l8_2 midpoint_bet midpoint_distinct_3)
  hence "Cong A C' A' C'"
    using Cong_perm P2 Per_def symmetric_point_uniqueness by blast
  hence "Cong A' C A' C'"
    using P1 P2 cong_inner_transitivity midpoint_cong not_cong_2134 by blast
  hence Q4: "Per A' B C"
    using P1 Per_def by blast
  have "Bet A' C A"
    using Mid_perm P2 midpoint_bet by blast
  thus ?thesis
    using Q4 assms(1) l8_6 by blast
qed

lemma l8_8:
  assumes "Per A B A"
  shows "A = B"
  using l8_6 Tarski_neutral_dimensionless_axioms assms between_trivial2 by fastforce

lemma per_distinct:
  assumes "Per A B C" and
    "A ≠ B"
  shows "A ≠ C"
  using assms(1) assms(2) l8_8 by blast

lemma per_distinct_1:
  assumes "Per A B C" and
    "B ≠ C"
  shows "A ≠ C"
  using assms(1) assms(2) l8_8 by blast

lemma l8_9:
  assumes "Per A B C" and
    "Col A B C"
  shows "A = B ∨ C = B"
  using Col_cases assms(1) assms(2) l8_3 l8_8 by blast

lemma l8_10:
  assumes "Per A B C" and
    "A B C Cong3 A' B' C'"
  shows "Per A' B' C'"
proof -
  obtain D where "B Midpoint C D" and "Cong A C A D"
    using Per_def assms(1) by blast
  obtain D' where "Bet C' B' D'" and "Cong B' D' B' C'"
    using segment_construction by blast
  hence "B' Midpoint C' D'"
    by (simp add: Midpoint_def cong_4312)
  have "Cong A' C' A' D'"
  proof cases
    assume "C = B"
    thus ?thesis 
      by (metis Cong3_def Cong_cases ‹Cong B' D' B' C'› assms(2) cong_reflexivity 
          cong_reverse_identity)
  next
    assume "¬ C = B"
    hence "C B D A OFSC C' B' D' A'"
      by (meson Cong3_def OFSC_def ‹B Midpoint C D› ‹B' Midpoint C' D'› assms(2) cong_commutativity
          cong_cong_half_2 cong_mid2__cong midpoint_bet) 
    thus ?thesis 
      by (meson Cong3_def ‹C ≠ B› ‹Cong A C A D› assms(2) cong_inner_transitivity 
          five_segment_with_def not_cong_2143)
  qed
  thus ?thesis 
    using Per_def ‹B' Midpoint C' D'› by blast
qed

lemma col_col_per_per:
  assumes "A ≠ X" and
    "C ≠ X" and
    "Col U A X" and
    "Col V C X" and
    "Per A X C"
  shows "Per U X V"
  by (meson l8_2 l8_3 Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) assms(4) 
      assms(5) not_col_permutation_3)

lemma perp_in_dec:
  "X PerpAt A B C D ∨ ¬ X PerpAt A B C D"
  by simp

lemma perp_distinct:
  assumes "A B Perp C D"
  shows "A ≠ B ∧ C ≠ D"
  using PerpAt_def Perp_def assms by auto

lemma l8_12:
  assumes "X PerpAt A B C D"
  shows "X PerpAt C D A B"
  using Per_perm PerpAt_def assms by auto

lemma per_col:
  assumes "B ≠ C" and
    "Per A B C" and
    "Col B C D"
  shows "Per A B D"
  by (metis l8_3 assms(1) assms(2) assms(3) l8_2)

lemma l8_13_2:
  assumes "A ≠ B" and
    "C ≠ D" and
    "Col X A B" and
    "Col X C D" and
    "∃ U. ∃ V. Col U A B ∧ Col V C D ∧ U ≠ X ∧ V ≠ X ∧ Per U X V"
  shows "X PerpAt A B C D"
proof -
  obtain U V where "Col U A B" and "Col V C D" and "U ≠ X" and "V ≠ X" and "Per U X V" 
    using assms(5) by blast
  {
    fix U0 V0
    assume "Col U0 A B" and "Col V0 C D"
    have "Col X U U0" 
      using ‹Col U A B› ‹Col U0 A B› assms(1) assms(3) col3 not_col_permutation_2 by blast
    hence "Per U0 X V" 
      using ‹Per U X V› ‹U ≠ X› l8_3 by blast
    hence "Per V X U0" 
      using l8_2 by blast
    hence "Per U0 X V0" 
      by (metis NCol_perm 
          ‹Col V C D› ‹Col V0 C D› ‹Per U0 X V› ‹V ≠ X› assms(2) assms(4) l6_16_1 per_col)
  }
  thus ?thesis 
    by (simp add: PerpAt_def assms(1) assms(2) assms(3) assms(4))
qed

lemma l8_14_1:
  "¬ A B Perp A B"
  by (metis PerpAt_def Perp_def col_trivial_1 col_trivial_3 l8_8)

lemma l8_14_2_1a:
  assumes "X PerpAt A B C D"
  shows "A B Perp C D"
  using Perp_def assms by blast

lemma perp_in_distinct:
  assumes "X PerpAt A B C D"
  shows "A ≠ B ∧ C ≠ D"
  using PerpAt_def assms by blast

lemma l8_14_2_1b:
  assumes "X PerpAt A B C D" and
    "Col Y A B" and
    "Col Y C D"
  shows "X = Y"
  by (metis PerpAt_def assms(1) assms(2) assms(3) l8_13_2 l8_14_1 l8_14_2_1a)

lemma l8_14_2_1b_bis:
  assumes "A B Perp C D" and
    "Col X A B" and
    "Col X C D"
  shows "X PerpAt A B C D"
  using Perp_def assms(1) assms(2) assms(3) l8_14_2_1b by blast

lemma l8_14_2_2:
  assumes "A B Perp C D" and
    "∀ Y. (Col Y A B ∧ Col Y C D) ⟶ X = Y"
  shows "X PerpAt A B C D"
  by (metis PerpAt_def Perp_def assms(1) assms(2))

lemma l8_14_3:
  assumes "X PerpAt A B C D" and
    "Y PerpAt A B C D"
  shows "X = Y"
  by (meson PerpAt_def assms(1) assms(2) l8_14_2_1b)

lemma l8_15_1:
  assumes "Col A B X" and
    "A B Perp C X"
  shows "X PerpAt A B C X"
  using NCol_perm assms(1) assms(2) col_trivial_3 l8_14_2_1b_bis by blast

lemma l8_15_2:
  assumes "Col A B X" and
    "X PerpAt A B C X"
  shows "A B Perp C X"
  using assms(2) l8_14_2_1a by blast

lemma perp_in_per:
  assumes "B PerpAt A B B C"
  shows "Per A B C"
  by (meson NCol_cases PerpAt_def assms col_trivial_3)

lemma perp_sym:
  assumes "A B Perp A B"
  shows "C D Perp C D"
  using assms l8_14_1 by auto

lemma perp_col0:
  assumes "A B Perp C D" and
    "X ≠ Y" and
    "Col A B X" and
    "Col A B Y"
  shows "C D Perp X Y"
proof -
  obtain X0 where "X0 PerpAt A B C D"
    using Perp_def assms(1) by blast
  hence " A ≠ B ∧ C ≠ D ∧ Col X0 A B ∧ Col X0 C D ∧
((Col U A B ∧ Col V C D) ⟶ Per U X0 V)" 
    using PerpAt_def by blast
  have "C ≠ D" 
    by (simp add: ‹A ≠ B ∧ C ≠ D ∧ Col X0 A B ∧ Col X0 C D ∧ 
    (Col U A B ∧ Col V C D ⟶ Per U X0 V)›)
  have "X ≠ Y"
    by (simp add: assms(2))
  have "Col X0 C D" 
    using ‹A ≠ B ∧ C ≠ D ∧ Col X0 A B ∧ Col X0 C D ∧ (Col U A B ∧ Col V C D ⟶ Per U X0 V)› 
    by blast
  have "Col X0 X Y" 
    by (meson ‹A ≠ B ∧ C ≠ D ∧ Col X0 A B ∧ Col X0 C D ∧ (Col U A B ∧ Col V C D ⟶ Per U X0 V)› 
        assms(3) assms(4) col3 not_col_permutation_2)
  have "X0 PerpAt C D X Y"
  proof -
    have "∀ U V. (Col U C D ∧ Col V X Y) ⟶ Per U X0 V" 
      by (metis Per_perm PerpAt_def col_trivial_2 ‹X0 PerpAt A B C D› assms(2) assms(3) 
          assms(4) l6_21 not_col_permutation_1)
    thus ?thesis 
      by (simp add: PerpAt_def ‹C ≠ D› ‹Col X0 C D› ‹Col X0 X Y› assms(2))
  qed
  thus ?thesis
    using Perp_def by auto
qed

lemma per_perp_in:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C"
  shows "B PerpAt A B B C"
  by (metis Col_def assms(1) assms(2) assms(3) between_trivial2 l8_13_2)

lemma per_perp:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C"
  shows "A B Perp B C"
  using Perp_def assms(1) assms(2) assms(3) per_perp_in by blast

lemma perp_left_comm:
  assumes "A B Perp C D"
  shows "B A Perp C D"
proof -
  obtain X where "X PerpAt A B C D"
    using Perp_def assms by blast
  hence "X PerpAt B A C D"
    using PerpAt_def col_permutation_5 by auto
  thus ?thesis
    using Perp_def by blast
qed

lemma perp_right_comm:
  assumes "A B Perp C D"
  shows "A B Perp D C"
  by (meson Perp_def assms l8_12 perp_left_comm)

lemma perp_comm:
  assumes "A B Perp C D"
  shows "B A Perp D C"
  by (simp add: assms perp_left_comm perp_right_comm)

lemma perp_in_sym:
  assumes  "X PerpAt A B C D"
  shows "X PerpAt C D A B"
  by (simp add: assms l8_12)

lemma perp_in_left_comm:
  assumes "X PerpAt A B C D"
  shows "X PerpAt B A C D"
  by (metis Col_cases PerpAt_def assms)

lemma perp_in_right_comm:
  assumes "X PerpAt A B C D"
  shows "X PerpAt A B D C"
  using assms perp_in_left_comm perp_in_sym by blast

lemma perp_in_comm:
  assumes "X PerpAt A B C D"
  shows "X PerpAt B A D C"
  by (simp add: assms perp_in_left_comm perp_in_right_comm)

lemma Perp_cases:
  assumes "A B Perp C D ∨ B A Perp C D ∨ A B Perp D C ∨ B A Perp D C ∨ C D Perp A B ∨ 
C D Perp B A ∨ D C Perp A B ∨ D C Perp B A"
  shows "A B Perp C D"
  by (meson Perp_def assms perp_in_sym perp_left_comm)

lemma Perp_perm :
  assumes "A B Perp C D"
  shows "A B Perp C D ∧ B A Perp C D ∧ A B Perp D C ∧ B A Perp D C ∧ C D Perp A B ∧ 
C D Perp B A ∧ D C Perp A B ∧ D C Perp B A"
  by (meson Perp_def assms perp_in_sym perp_left_comm)

lemma Perp_in_cases:
  assumes "X PerpAt A B C D ∨ X PerpAt B A C D ∨ X PerpAt A B D C ∨ X PerpAt B A D C ∨ 
X PerpAt C D A B ∨ X PerpAt C D B A ∨ X PerpAt D C A B ∨ X PerpAt D C B A"
  shows "X PerpAt A B C D"
  using assms perp_in_left_comm perp_in_sym by blast

lemma Perp_in_perm:
  assumes "X PerpAt A B C D"
  shows "X PerpAt A B C D ∧ X PerpAt B A C D ∧ X PerpAt A B D C ∧ X PerpAt B A D C ∧ 
X PerpAt C D A B ∧ X PerpAt C D B A ∧ X PerpAt D C A B ∧ X PerpAt D C B A"
  using Perp_in_cases assms by blast

lemma perp_in_col:
  assumes "X PerpAt A B C D"
  shows "Col A B X ∧ Col C D X"
  using PerpAt_def assms col_permutation_2 by presburger

lemma perp_perp_in:
  assumes "A B Perp C A"
  shows "A PerpAt A B C A"
  using assms l8_15_1 not_col_distincts by blast

lemma perp_per_1:
  assumes "A B Perp C A"
  shows "Per B A C"
  using Perp_in_cases assms perp_in_per perp_perp_in by blast

lemma perp_per_2:
  assumes "A B Perp A C"
  shows "Per B A C"
  by (simp add: Perp_perm assms perp_per_1)

lemma perp_col:
  assumes "A ≠ E" and
    "A B Perp C D" and
    "Col A B E"
  shows "A E Perp C D"
  using Perp_perm assms(1) assms(2) assms(3) col_trivial_3 perp_col0 by blast

lemma perp_col2:
  assumes "A B Perp X Y" and
    "C ≠ D" and
    "Col A B C" and
    "Col A B D"
  shows "C D Perp X Y"
  using Perp_perm assms(1) assms(2) assms(3) assms(4) perp_col0 by blast

lemma perp_col4:
  assumes "P ≠ Q" and
    "R ≠ S" and
    "Col A B P" and
    "Col A B Q" and
    "Col C D R" and
    "Col C D S" and
    "A B Perp C D"
  shows "P Q Perp R S"
  using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) perp_col0 by blast

lemma perp_not_eq_1:
  assumes "A B Perp C D"
  shows "A ≠ B"
  using assms perp_distinct by auto

lemma perp_not_eq_2:
  assumes "A B Perp C D"
  shows "C ≠ D"
  using assms perp_distinct by auto

lemma diff_per_diff:
  assumes "A ≠ B" and
    "Cong A P B R" and
    "Per B A P"
    and "Per A B R"
  shows "P ≠ R"
  using assms(1) assms(3) assms(4) l8_2 l8_7 by blast

lemma per_not_colp:
  assumes "A ≠ B" and
    "A ≠ P" and
    "B ≠ R" and
    "Per B A P"
    and "Per A B R"
  shows "¬ Col P A R"
  by (metis Per_cases col_permutation_4 assms(1) assms(2) assms(4) assms(5) l8_3 l8_7)

lemma per_not_col:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C"
  shows "¬ Col A B C"
  using assms(1) assms(2) assms(3) l8_9 by auto

lemma perp_not_col2:
  assumes "A B Perp C D"
  shows "¬ Col A B C ∨ ¬ Col A B D"
  using assms l8_14_1 perp_col2 perp_distinct by blast

lemma perp_not_col:
  assumes "A B Perp P A"
  shows "¬ Col A B P"
proof -
  have "A PerpAt A B P A"
    using assms perp_perp_in by auto
  hence "Per P A B"
    by (simp add: perp_in_per perp_in_sym)
  hence "¬ Col B A P"
    by (metis NCol_perm perp_not_eq_1 perp_not_eq_2 assms per_not_col)
  thus ?thesis
    using Col_perm by blast
qed

lemma perp_in_col_perp_in:
  assumes "C ≠ E" and
    "Col C D E" and
    "P PerpAt A B C D"
  shows "P PerpAt A B C E"
proof -
  have "C ≠ D"
    using assms(3) perp_in_distinct by blast
  have "Col P C D"
    using PerpAt_def assms(3) by blast
  hence "Col P C E" 
    using ‹C ≠ D› assms(2) col_trivial_2 colx by blast
  moreover
  {
    fix U V 
    assume "Col U A B" and "Col V C E" 
    hence "Per U P V"
      by (metis PerpAt_def assms(1) assms(2) assms(3) col_permutation_1 col_trivial_2 colx)
  }
  ultimately
  show ?thesis 
    using PerpAt_def assms(1) assms(3) by presburger
qed

lemma perp_col2_bis:
  assumes "A B Perp C D" and
    "Col C D P" and
    "Col C D Q" and
    "P ≠ Q"
  shows "A B Perp P Q"
  using Perp_cases assms(1) assms(2) assms(3) assms(4) perp_col0 by blast

lemma perp_in_perp_bis_R1:
  assumes "X ≠ A" and
    "X PerpAt A B C D"
  shows "X B Perp C D ∨ A X Perp C D"
  by (metis assms(2) l8_14_2_1a perp_col perp_in_col)

lemma perp_in_perp_bis:
  assumes "X PerpAt A B C D"
  shows "X B Perp C D ∨ A X Perp C D"
  by (metis assms l8_14_2_1a perp_in_perp_bis_R1)

lemma col_per_perp:
  assumes "A ≠ B" and
    "B ≠ C" and
    (*   "D ≠ B" and  *)
    "D ≠ C" and
    "Col B C D" and
    "Per A B C"
  shows "C D Perp A B"
  by (metis Perp_cases assms(1) assms(2) assms(3) assms(4) assms(5) col_trivial_2 
      per_perp perp_col2_bis)

lemma per_cong_mid_R1:
  assumes "B = H" and
    (*  "B ≠ C" and *)
    "Bet A B C" and
    "Cong A H C H" and
    "Per H B C"
  shows "B Midpoint A C"
  using assms(1) assms(2) assms(3) midpoint_def not_cong_1243 by blast

lemma per_cong_mid_R2:
  assumes (*"B ≠ H" and *)
    "B ≠ C" and
    "Bet A B C" and
    "Cong A H C H" and
    "Per H B C"
  shows "B Midpoint A C"
proof -
  have P1: "Per C B H"
    using Per_cases assms(4) by blast
  have P2: "Per H B A"
    using assms(1) assms(2) assms(4) bet_col col_permutation_1 per_col by blast
  hence P3: "Per A B H"
    using Per_cases by blast
  obtain C' where P4: "B Midpoint C C' ∧ Cong H C H C'"
    using Per_def assms(4) by blast
  obtain H' where P5: "B Midpoint H H' ∧ Cong C H C H'"
    using P1 Per_def by blast
  obtain A' where P6: "B Midpoint A A' ∧ Cong H A H A'"
    using P2 Per_def by blast
  obtain H'' where P7: "B Midpoint H H'' ∧ Cong A H A H'"
    using P3 P5 Per_def Tarski_neutral_dimensionless_axioms symmetric_point_uniqueness 
    by fastforce
  hence P8: "H' = H''"
    using P5 symmetric_point_uniqueness by blast
  have "H B H' A IFSC H B H' C"
  proof -
    have Q1: "Bet H B H'"
      by (simp add: P7 P8 midpoint_bet)
    have Q2: "Cong H H' H H'"
      by (simp add: cong_reflexivity)
    have Q3: "Cong B H' B H'"
      by (simp add: cong_reflexivity)
    have Q4: "Cong H A H C"
      using assms(3) not_cong_2143 by blast
    have "Cong H' A H' C"
      using P5 P7 assms(3) cong_commutativity cong_inner_transitivity by blast
    thus ?thesis
      by (simp add: IFSC_def Q1 Q2 Q3 Q4)
  qed
  thus ?thesis
    using assms(1) assms(2) bet_col bet_neq23__neq l4_2 l7_20_bis by auto
qed

lemma per_cong_mid:
  assumes "B ≠ C" and
    "Bet A B C" and
    "Cong A H C H" and
    "Per H B C"
  shows "B Midpoint A C"
  using assms(1) assms(2) assms(3) assms(4) per_cong_mid_R1 per_cong_mid_R2 by blast

lemma per_double_cong:
  assumes "Per A B C" and
    "B Midpoint C C'"
  shows "Cong A C A C'"
  using Mid_cases Per_def assms(1) assms(2) l7_9_bis by blast

lemma cong_perp_or_mid_R1:
  assumes "Col A B X" and
    "A ≠ B" and
    "M Midpoint A B" and
    "Cong A X B X"
  shows "X = M ∨ ¬ Col A B X ∧ M PerpAt X M A B"
  using assms(1) assms(2) assms(3) assms(4) col_permutation_5 cong_commutativity l7_17_bis 
    l7_2 l7_20 by blast

lemma cong_perp_or_mid_R2:
  assumes "¬ Col A B X" and
    "A ≠ B" and
    "M Midpoint A B" and
    "Cong A X B X"
  shows "X = M ∨ ¬ Col A B X ∧ M PerpAt X M A B"
proof -
  have P1: "Col M A B"
    by (simp add: assms(3) midpoint_col)
  have "Per X M A"
    using Per_def assms(3) assms(4) cong_commutativity by blast
  thus ?thesis
    by (metis P1 assms(1) assms(2) assms(3) midpoint_distinct_1 not_col_permutation_4 
        per_perp_in perp_in_col_perp_in perp_in_right_comm)
qed

lemma cong_perp_or_mid:
  assumes "A ≠ B" and
    "M Midpoint A B" and
    "Cong A X B X"
  shows "X = M ∨ ¬ Col A B X ∧ M PerpAt X M A B"
  using assms(1) assms(2) assms(3) cong_perp_or_mid_R1 cong_perp_or_mid_R2 by blast

lemma col_per2_cases:
  assumes "B ≠ C" and
    "B' ≠ C" and
    "C ≠ D" and
    "Col B C D" and
    "Per A B C" and
    "Per A B' C"
  shows  "B = B' ∨ ¬ Col B' C D"
  by (meson l8_7 Tarski_neutral_dimensionless_axioms assms(1) assms(2) assms(3) assms(4) 
      assms(5) assms(6) l6_16_1 per_col)

lemma l8_16_1:
  assumes "Col A B X" and
    "Col A B U" and
    "A B Perp C X"
  shows "¬ Col A B C ∧ Per C X U"
  by (metis assms(1) assms(2) assms(3) l8_5 perp_col0 perp_left_comm perp_not_col2 perp_per_2)

lemma l8_16_2:
  assumes "Col A B X" and
    "Col A B U" and 
    "U ≠ X" and
    "¬ Col A B C" and
    "Per C X U"
  shows "A B Perp C X"
proof -
  obtain X where "X PerpAt A B C X"
    by (metis NCol_perm assms(1) assms(2) assms(3) assms(4) assms(5) l8_13_2 l8_2 
        not_col_distincts)
  thus ?thesis 
    by (metis Perp_perm per_col assms(1) assms(2) assms(3) assms(4) assms(5) col3 col_per_perp
        not_col_distincts)
qed

lemma l8_18_uniqueness:
  assumes (*"¬ Col A B C" and *)
    "Col A B X" and
    "A B Perp C X" and
    "Col A B Y" and
    "A B Perp C Y"
  shows "X = Y"
  using assms(1) assms(2) assms(3) assms(4) l8_16_1 l8_7 by blast

lemma midpoint_distinct:
  assumes "¬ Col A B C" and
    "Col A B X" and
    "X Midpoint C C'"
  shows "C ≠ C'"
  using assms(1) assms(2) assms(3) l7_3 by auto

lemma l8_20_1_R1:
  assumes "A = B"
  shows "Per B A P"
  by (simp add: assms l8_2 l8_5)

lemma l8_20_1_R2:
  assumes "A ≠ B" and
    "Per A B C" and
    "P Midpoint C' D" and
    "A Midpoint C' C" and
    "B Midpoint D C"
  shows "Per B A P"
proof -
  obtain B' where P1: "A Midpoint B B'"
    using symmetric_point_construction by blast
  obtain D' where P2: "A Midpoint D D'"
    using symmetric_point_construction by blast
  obtain P' where P3: "A Midpoint P P'"
    using symmetric_point_construction by blast
  have P4: "Per B' B C"
    by (metis P1 Per_cases per_col assms(1) assms(2) midpoint_col not_col_permutation_4)
  have P5: "Per B B' C'"
  proof -
    have "Per B' B C"
      by (simp add: P4)
    have "B' B C Cong3 B B' C'"
      by (meson Cong3_def P1 assms(4) l7_13 l7_2)
    thus ?thesis
      using P4 l8_10 by blast
  qed
  have P6: "B' Midpoint D' C'"
    by (meson P1 P2 assms(4) assms(5) l7_15 l7_16 l7_2 midpoint_bet midpoint_cong midpoint_def)
  have P7: "P' Midpoint C D'"
    using P2 P3 assms(3) assms(4) symmetry_preserves_midpoint by blast
  have P8: "A Midpoint P P'"
    by (simp add: P3)
  obtain D'' where P9: "B Midpoint C D'' ∧ Cong B' C B' D"
    using P4 assms(5) l7_2 per_double_cong by blast
  have P10: "D'' = D"
    using P9 assms(5) l7_9_bis by blast
  obtain D'' where P11: "B' Midpoint C' D'' ∧ Cong B C' B D''"
    using P5 Per_def by blast
  have P12: "D' = D''"
    by (meson P11 P6 l7_9_bis Tarski_neutral_dimensionless_axioms)
  have P13: "P Midpoint C' D"
    using assms(3) by blast
  have P14: "Cong C D C' D'"
    using P2 assms(4) l7_13 l7_2 by blast
  have P15: "Cong C' D C D'"
    using P2 assms(4) cong_4321 l7_13 by blast
  have P16: "Cong P D P' D'"
    using P2 P8 cong_symmetry l7_13 by blast
  have P17: "Cong P D P' C"
    using P16 P7 cong_3421 cong_transitivity midpoint_cong by blast
  have P18: "C' P D B IFSC D' P' C B"
    by (metis Bet_cases IFSC_def P10 P11 P12 P13 P15 P17 P7 P9 cong_commutativity 
        cong_right_commutativity l7_13 l7_3_2 midpoint_bet)
  hence "Cong B P B P'"
    using l4_2 Tarski_neutral_dimensionless_axioms not_cong_2143 by fastforce
  thus ?thesis
    using P8 Per_def by blast
qed

lemma l8_20_1:
  assumes "Per A B C" and
    "P Midpoint C' D" and
    "A Midpoint C' C" and
    "B Midpoint D C"
  shows "Per B A P"
  using assms(1) assms(2) assms(3) assms(4) l8_20_1_R1 l8_20_1_R2 by fastforce

lemma l8_20_2:
  assumes "P Midpoint C' D" and
    "A Midpoint C' C" and
    "B Midpoint D C" and
    "B ≠ C"
  shows "A ≠ P"
  using assms(1) assms(2) assms(3) assms(4) l7_3 symmetric_point_uniqueness by blast

lemma perp_col1:
  assumes "C ≠ X" and
    "A B Perp C D" and
    "Col C D X"
  shows "A B Perp C X"
  using assms(1) assms(2) assms(3) col_trivial_3 perp_col2_bis by blast

lemma l8_18_existence:
  assumes "¬ Col A B C"
  shows "∃ X. Col A B X ∧ A B Perp C X"
proof -
  obtain Y where "Bet B A Y" and "Cong A Y A C"
    using segment_construction by blast
  then obtain P where "P Midpoint C Y"
    using Mid_cases l7_25 by blast
  hence "Per A P Y" 
    using Per_def ‹Cong A Y A C› l7_2 by blast
  obtain Z where "Bet A Y Z" and "Cong Y Z Y P" 
    using segment_construction by blast
  obtain Q where "Bet P Y Q" and "Cong Y Q Y A"
    using segment_construction by blast
  obtain Q' where "Bet Q Z Q'" and "Cong Z Q' Q Z"
    using segment_construction by blast
  hence "Z Midpoint Q Q'"
    using midpoint_def not_cong_3412 by blast
  obtain C' where "Bet Q' Y C'" and "Cong Y C' Y C"
    using segment_construction by blast
  obtain X where "X Midpoint C C'" 
    using ‹Cong Y C' Y C› l7_2 l7_25 by blast
  have "A Y Z Q OFSC Q Y P A" 
    by (simp add: OFSC_def ‹Bet A Y Z› ‹Bet P Y Q› ‹Cong Y Q Y A› ‹Cong Y Z Y P› 
        between_symmetry cong_4321 cong_pseudo_reflexivity)
  have "A ≠ Y" 
    using ‹Cong A Y A C› assms is_midpoint_id l7_20 not_col_distincts by blast
  hence "Cong Z Q P A" 
    using ‹A Y Z Q OFSC Q Y P A› five_segment_with_def by auto
  hence "A P Y Cong3 Q Z Y" 
    using Cong3_def Cong_cases ‹Cong Y Q Y A› ‹Cong Y Z Y P› by blast
  hence "Per Q Z Y" 
    using ‹Per A P Y› l8_10 by blast
  hence "Per Y Z Q" 
    using l8_2 by blast
  have "P ≠ Y" 
    by (metis Col_def ‹Bet B A Y› ‹P Midpoint C Y› assms between_symmetry midpoint_not_midpoint)
  obtain Q'' where "Z Midpoint Q Q''" and "Cong Y Q Y Q'" 
    using ‹Per Y Z Q› ‹Z Midpoint Q Q'› per_double_cong by force
  hence "Q' = Q''" 
    by (meson symmetric_point_uniqueness ‹Z Midpoint Q Q'›)
  have "Bet Q Y C" 
    by (metis midpoint_bet ‹Bet P Y Q› ‹P Midpoint C Y› ‹P ≠ Y› between_symmetry 
        outer_transitivity_between2)
  hence "Bet Z Y X"
    by (meson l7_22 ‹Bet Q' Y C'› ‹Cong Y C' Y C› ‹Cong Y Q Y Q'› ‹X Midpoint C C'› 
        ‹Z Midpoint Q Q'› cong_symmetry)
  have "Q ≠ Y" 
    using ‹A ≠ Y› ‹Cong Y Q Y A› cong_reverse_identity by blast
  have "Bet C P Y" 
    using Midpoint_def ‹P Midpoint C Y› by auto
  hence "Per Y X C"
    using Per_def ‹Cong Y C' Y C› ‹X Midpoint C C'› cong_inner_transitivity 
      cong_reflexivity by blast
  moreover
  have "Col P Y Q" 
    by (simp add: Col_def ‹Bet P Y Q›)
  have "Col P Y C" 
    by (simp add: Col_def ‹Bet C P Y›)
  have "Col P Q C" 
    using ‹Col P Y C› ‹Col P Y Q› ‹P ≠ Y› col_transitivity_1 by blast
  have "Col Y Q C" 
    using Bet_cases Col_def ‹Bet Q Y C› by auto
  have "Col A Y B" 
    by (simp add: Col_def ‹Bet B A Y›)
  moreover
  have "Col A Y Z" 
    using Col_def ‹Bet A Y Z› by blast
  have "Col A B Z" 
    using ‹A ≠ Y› ‹Col A Y B› ‹Col A Y Z› col_transitivity_1 by blast
  have "Col Y B Z" 
    using ‹A ≠ Y› ‹Col A Y B› ‹Col A Y Z› col_transitivity_2 by blast
  have "Col Q Y P" 
    using Col_cases ‹Col P Y Q› by blast
  have "Q ≠ C" 
    using ‹Bet Q Y C› ‹Q ≠ Y› between_identity by blast
  have "Col Y Q' C'" 
    using Col_cases Col_def ‹Bet Q' Y C'› by blast
  {
    assume "Q = Q'"
    hence "Col P B C" 
      by (metis cong_reverse_identity ‹Col A Y B› ‹Col P Y C› ‹Cong Z Q P A› ‹P ≠ Y› 
          ‹Q' = Q''› ‹Z Midpoint Q Q''› col_transitivity_1 midpoint_distinct_2)
    moreover have "¬ Col P B C" 
      by (metis ‹Q = Q'› ‹Bet Q Z Q'› ‹Cong Z Q P A› assms bet_neq12__neq cong_diff_3)
    ultimately have False 
      by blast
  }
  hence "C ≠ C'" 
    by (metis between_cong_3 ‹Bet Q Y C› ‹Bet Q' Y C'› ‹Cong Y Q Y Q'› ‹P Midpoint C Y› 
        ‹P ≠ Y› between_symmetry midpoint_distinct_3)
  have "Q Y C Z OFSC Q' Y C' Z" 
    by (simp add: OFSC_def ‹Bet Q Y C› ‹Bet Q' Y C'› ‹Cong Y C' Y C› ‹Cong Y Q Y Q'› 
        ‹Cong Z Q' Q Z› cong_3421 cong_reflexivity cong_symmetry)
  hence "Cong C Z C' Z" 
    using ‹Q ≠ Y› five_segment_with_def by force
  have "Col Z Y X" 
    using Col_def ‹Bet Z Y X› by blast
  have "Y ≠ Z" 
    using ‹Cong Y Z Y P› ‹P ≠ Y› cong_diff_4 by blast
  {
    assume "X = Y"
    hence "C' ≠ Y" 
      using ‹C ≠ C'› ‹Cong Y C' Y C› cong_reverse_identity by blast
    have "Col Y C' P" 
      by (metis Col_def Midpoint_def ‹Bet C P Y› ‹X = Y› ‹X Midpoint C C'› between_equality_2 
          col_transitivity_1 not_bet_distincts)
    hence "Col Y P Q'" 
      by (metis ‹C' ≠ Y› ‹Col Y Q' C'› col_trivial_3 colx not_col_permutation_5)
    hence "Col Y Q Q'" 
      by (meson ‹Col P Y Q› ‹P ≠ Y› colx not_col_distincts not_col_permutation_5)
    hence False 
      using l7_20 ‹Cong Y Q Y Q'› ‹Q = Q' ⟹ False› ‹Q' = Q''› ‹Y ≠ Z› 
        ‹Z Midpoint Q Q''› col_permutation_4 l7_17 by blast
  }
  hence "X ≠ Y" 
    by auto
  moreover have "Col A B X" 
    by (meson ‹Col A Y Z› ‹Col Y B Z› ‹Col Z Y X› ‹Y ≠ Z› col3 col_permutation_3 
        not_col_permutation_1)
  ultimately show ?thesis 
    by (metis Col_cases l8_2 assms l8_16_2)
qed

lemma l8_21_aux:
  assumes "¬ Col A B C"
  shows "∃ P. ∃ T. (A B Perp P A ∧ Col A B T ∧ Bet C T P)"
proof -
  obtain X where "Col A B X" and "A B Perp C X"
    using assms l8_18_existence by blast
  hence "X PerpAt A B C X"
    by (simp add: l8_15_1)
  have "Per A X C" 
    using PerpAt_def ‹X PerpAt A B C X› col_trivial_1 by presburger
  obtain C' where "X Midpoint C C'" and "Cong A C A C'" 
    using Per_def ‹Per A X C› by auto
  obtain C'' where "A Midpoint C C''"
    using symmetric_point_construction by blast
  obtain P where "P Midpoint C' C''" 
    by (metis Cong_cases ‹A Midpoint C C''› ‹Cong A C A C'› cong_inner_transitivity 
        l7_25 midpoint_cong)
  have "Per X A P" 
  proof -
    have "P Midpoint C'' C'" 
      using ‹P Midpoint C' C''› l7_2 by blast
    moreover have "A Midpoint C'' C" 
      using ‹A Midpoint C C''› l7_2 by blast
    moreover have "X Midpoint C' C" 
      by (simp add: ‹X Midpoint C C'› l7_2)
    ultimately show ?thesis 
      using ‹Per A X C› l8_20_1 by blast
  qed
  have "X ≠ C" 
    using ‹Col A B X› assms by blast
  hence "A ≠ P" 
    using ‹A Midpoint C C''› ‹P Midpoint C' C''› ‹X Midpoint C C'› l7_9 midpoint_distinct_2 
    by blast
  have "∃ T. Bet P T C ∧ Bet A T X"
  proof -
    have "Bet C'' A C" 
      using Mid_cases ‹A Midpoint C C''› midpoint_bet by blast
    moreover have "Bet C' X C" 
      using Bet_cases Midpoint_def ‹X Midpoint C C'› by auto
    moreover have "Bet C'' P C'" 
      using ‹P Midpoint C' C''› between_symmetry midpoint_bet by blast
    ultimately show ?thesis 
      using l3_17 by fastforce
  qed
  then obtain T where "Bet P T C" and "Bet A T X" 
    by blast
  show ?thesis
  proof cases
    assume "A = X"
    thus ?thesis 
      by (metis Bet_perm between_identity midpoint_col midpoint_not_midpoint perp_col1 
          ‹A B Perp C X› ‹A Midpoint C C''› ‹Bet A T X› ‹Bet P T C› ‹Col A B X› 
          ‹P Midpoint C' C''› ‹X Midpoint C C'› l8_20_2 perp_comm)
  next
    assume "A ≠ X"
    have "A B Perp P A" 
      by (metis col3 l8_2 per_not_col ‹A ≠ P› ‹A ≠ X› ‹Col A B X› ‹Per X A P› 
          assms l8_16_2 not_col_distincts)
    moreover have "Col A B T" 
      by (metis Col_def ‹A ≠ X› ‹Bet A T X› ‹Col A B X› col_transitivity_2)
    moreover have "Bet C T P" 
      using Bet_cases ‹Bet P T C› by blast
    ultimately show ?thesis 
      by blast
  qed
qed

lemma l8_21:
  assumes "A ≠ B"
  shows "∃ P T. A B Perp P A ∧ Col A B T ∧ Bet C T P"
  by (meson assms between_trivial2 l8_21_aux not_col_exists)

lemma per_cong:
  assumes "A ≠ B" and
    "A ≠ P" and
    "Per B A P" and
    "Per A B R" and
    "Cong A P B R" and
    "Col A B X" and
    "Bet P X R"
  shows "Cong A R P B"
proof -
  have "Per P A B"
    using Per_cases assms(3) by blast
  obtain Q where "R Midpoint B Q"
    using symmetric_point_construction by auto
  have "B ≠ R"
    using assms(2) assms(5) cong_identity by blast
  hence "Per A B Q" 
    using Col_def Midpoint_def ‹R Midpoint B Q› assms(4) per_col by blast
  have "Per P A X" 
    using ‹Per P A B› assms(1) assms(6) per_col by blast
  have "B ≠ Q" 
    using ‹B ≠ R› ‹R Midpoint B Q› l7_3 by blast
  have "Per R B X" 
    by (metis col_permutation_4 per_col assms(1) assms(4) assms(6) l8_2)
  have "X ≠ A" 
    using ‹B ≠ R› assms(1) assms(2) assms(3) assms(4) assms(7) bet_col per_not_colp by blast
  obtain P' where "A Midpoint P P'" 
    using Per_def assms(3) by blast
  obtain R' where "Bet P' X R'" and "Cong X R' X R"   
    using segment_construction by blast
  obtain M where "M Midpoint R R'"
    using ‹Cong X R' X R› l7_2 l7_25 by blast
  have "Per X M R" 
    by (metis Per_def ‹Cong X R' X R› ‹M Midpoint R R'› cong_symmetry)
  have "Cong X P X P'" 
    using Per_cases ‹A Midpoint P P'› ‹Per P A X› per_double_cong by blast
  have "X ≠ P'" 
    using ‹Cong X P X P'› ‹Per P A X› assms(2) cong_identity l8_8 by blast
  have "P ≠ P'" 
    using ‹A Midpoint P P'› assms(2) l7_3 by blast
  have "¬ Col X P P'" 
    using ‹A Midpoint P P'› ‹Cong X P X P'› ‹P ≠ P'› ‹X ≠ A› col_permutation_4 l7_17 l7_20 
    by blast
  have "Bet A X M" 
    by (meson ‹A Midpoint P P'› ‹Bet P' X R'› ‹Cong X P X P'› ‹Cong X R' X R› ‹M Midpoint R R'› 
        assms(7) cong_symmetry l7_22)
  have "X ≠ R" 
    using ‹B ≠ R› ‹Per R B X› l8_8 by blast
  have "X ≠ R'" 
    using ‹Cong X R' X R› ‹X ≠ R› cong_diff_3 by blast
  {
    assume "X = M"
    have "Col X P P'" 
    proof -
      have "Col X R P" 
        using Col_def assms(7) by blast
      moreover have "Col X R P'" 
        by (metis Col_def ‹Bet P' X R'› ‹M Midpoint R R'› ‹X = M› ‹X ≠ R'› 
            col_transitivity_1 midpoint_col)
      ultimately show ?thesis 
        using ‹X ≠ R› col_transitivity_1 by blast
    qed
    hence False 
      by (simp add: ‹¬ Col X P P'›)
  }
  have "M = B" 
  proof -
    have "¬ Col A X R" 
      by (metis ‹B ≠ R› ‹X ≠ A› assms(1) assms(4) assms(6) col_trivial_3 colx per_not_col)
    moreover have "Col A X M" 
      using Col_def ‹Bet A X M› by auto
    moreover have "A X Perp R M" 
      by (metis Col_cases Per_cases ‹Per X M R› ‹X = M ⟹ False› ‹X ≠ A› calculation(1) 
          calculation(2) col_per_perp perp_left_comm)
    moreover have "Col A X B" 
      using Col_cases assms(6) by blast
    moreover have "A X Perp R B" 
      by (metis Col_cases Per_cases ‹B ≠ R› ‹X ≠ A› assms(1) assms(4) assms(6) col_per_perp)
    ultimately show ?thesis 
      using l8_18_uniqueness by blast
  qed
  have "P X R P' OFSC P' X R' P" 
    using Cong_cases OFSC_def ‹Bet P' X R'› ‹Cong X P X P'› ‹Cong X R' X R› assms(7) 
      cong_pseudo_reflexivity by auto
  hence "Cong R P' R' P" 
    using ‹¬ Col X P P'› five_segment_with_def not_col_distincts by blast
  have "P' A P R IFSC R' B R P"
  proof -
    have "M = B"
      using ‹M = B› by auto
    then have "B Midpoint R R'"
      using ‹M Midpoint R R'› by blast
    then show ?thesis
      by (smt (z3) Bet_cases Cong_cases IFSC_def Midpoint_def ‹A Midpoint P P'› 
          ‹Cong R P' R' P› assms(5) cong_mid2__cong cong_pseudo_reflexivity)
  qed
  thus ?thesis
    using l4_2 not_cong_1243 by blast
qed

lemma perp_cong:
  assumes "A ≠ B" and
    "A ≠ P" and
    "A B Perp P A" and
    "A B Perp R B" and
    "Cong A P B R" and
    "Col A B X" and
    "Bet P X R"
  shows "Cong A R P B"
  using Perp_cases assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) per_cong 
    perp_per_1 by blast

lemma perp_exists:
  assumes "A ≠ B"
  shows "∃ X. PO X Perp A B"
proof cases
  assume "Col A B PO"
  then obtain C where "A ≠ C" and "B ≠ C" and "PO ≠ C" and "Col A B C"
    using diff_col_ex3 by blast
  then obtain P T where "PO C Perp P PO" and "Col PO C T" and "Bet PO T P" 
    using l8_21 by blast
  hence "PO P Perp A B" 
    by (metis Perp_perm col_transitivity_2 ‹Col A B C› ‹Col A B PO› assms 
        not_col_permutation_2 perp_col0)
  thus ?thesis
    by blast
next
  assume "¬ Col A B PO"
  thus ?thesis 
    using l8_18_existence assms col_trivial_2 col_trivial_3 l8_18_existence perp_col0 by blast
qed

lemma perp_vector:
  assumes "A ≠ B"
  shows "∃ X Y. A B Perp X Y"
  using assms l8_21 by blast

lemma midpoint_existence_aux:
  assumes "A ≠ B" and
    "A B Perp Q B" and
    "A B Perp P A" and
    "Col A B T" and
    "Bet Q T P" and
    "A P Le B Q"
  shows "∃ X. X Midpoint A B"
proof -
  obtain R where "Bet B R Q" and "Cong A P B R"
    using Le_def assms(6) by blast
  obtain X where "Bet T X B" and "Bet R X P" 
    by (meson ‹Bet B R Q› assms(5) between_symmetry inner_pasch)
  have "Col A B X" 
    by (metis Col_def ‹Bet T X B› assms(4) between_equality_2 between_trivial2 col2__eq)
  have "B ≠ R"
    using ‹Cong A P B R› assms(3) cong_identity perp_not_eq_2 by blast
  have "¬ Col A B Q" 
    using Col_cases Perp_cases assms(2) perp_not_col by blast
  have "¬ Col A B R" 
    using Col_def ‹B ≠ R› ‹Bet B R Q› ‹¬ Col A B Q› l6_16_1 by blast
  have "P ≠ R" 
    using ‹Bet R X P› ‹Col A B X› ‹¬ Col A B R› between_identity by blast
  have "∃ X. X Midpoint A B"
  proof cases
    assume "A = P"
    thus ?thesis
      using assms(3) col_trivial_3 perp_not_col2 by blast
  next
    assume "¬ A = P"
    have "A B Perp R B" 
      by (metis Col_def ‹B ≠ R› ‹Bet B R Q› assms(2) not_col_distincts perp_col2_bis)
    hence "Cong A R P B" 
      using ‹A ≠ P› ‹Bet R X P› ‹Col A B X› ‹Cong A P B R› assms(1) assms(3) 
        between_symmetry perp_cong by blast
    hence "X Midpoint A B ∧ X Midpoint P R" 
      by (meson ‹Bet R X P› ‹Col A B X› ‹Cong A P B R› ‹P ≠ R› assms(3) bet_col 
          between_symmetry cong_4312 l7_2 l7_21 not_col_permutation_2 perp_not_col)
    thus ?thesis
      by blast
  qed
  thus ?thesis by blast
qed

lemma midpoint_existence:
  "∃ X. X Midpoint A B"
proof cases
  assume "A = B"
  thus ?thesis
    using l7_3_2 by blast
next
  assume P1: "¬ A = B"
  obtain Q where P2: "A B Perp B Q"
    by (metis P1 l8_21 perp_comm)
  obtain P T where P3: "A B Perp P A ∧ Col A B T ∧ Bet Q T P"
    using P2 l8_21_aux not_col_distincts perp_not_col2 by blast
  have P4: "A P Le B Q ∨ B Q Le A P"
    by (simp add: local.le_cases)
  have P5: "A P Le B Q ⟶ (∃ X. X Midpoint A B)"
    by (meson P1 P2 P3 Perp_cases midpoint_existence_aux Tarski_neutral_dimensionless_axioms)
  have P6: "B Q Le A P ⟶ (∃ X. X Midpoint A B)"
  proof -
    {
      assume H1: "B Q Le A P"
      have Q6: "B ≠ A"
        using P1 by auto
      have Q2: "B A Perp P A"
        by (simp add: P3 perp_left_comm)
      have Q3: "B A Perp Q B"
        using P2 Perp_perm by blast
      have Q4: "Col B A T"
        using Col_perm P3 by blast
      have Q5: "Bet P T Q"
        using Bet_perm P3 by blast
      obtain X where "X Midpoint B A"
        using H1 Q2 Q3 Q4 Q5 Q6 midpoint_existence_aux by blast
      hence "∃ X. X Midpoint A B"
        using l7_2 by blast
    }
    thus ?thesis
      by simp
  qed
  thus ?thesis
    using P4 P5 by blast
qed

lemma MidR_uniq_aux:
  shows "∃!x. x Midpoint A B"
  using l7_17_bis midpoint_existence by blast

lemma SymR_uniq_aux:
  assumes "B Midpoint A x" and
    "B Midpoint A y"
  shows "x = y"
  using assms(1) assms(2) symmetric_point_uniqueness by auto

lemma perp_in_id:
  assumes "X PerpAt A B C A"
  shows "X = A"
  by (meson Col_cases assms col_trivial_3 l8_14_2_1b)

lemma l8_22:
  assumes "A ≠ B" and
    "A ≠ P" and
    "Per B A P" and
    "Per A B R" and
    "Cong A P B R" and
    "Col A B X" and
    "Bet P X R" and
    "Cong A R P B"
  shows "X Midpoint A B ∧ X Midpoint P R"
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) assms(8) 
      bet_col cong_commutativity cong_diff cong_right_commutativity l7_21 
      not_col_permutation_5 per_not_colp)

lemma l8_22_bis:
  assumes "A ≠ B" and
    "A ≠ P" and
    "A B Perp P A" and
    "A B Perp R B" and
    "Cong A P B R" and
    "Col A B X" and
    "Bet P X R"
  shows "Cong A R P B ∧ X Midpoint A B ∧ X Midpoint P R"
  by (metis l8_22 Perp_cases assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
      assms(7) perp_cong perp_per_2)

lemma perp_in_perp:
  assumes "X PerpAt A B C D"
  shows "A B Perp C D"
  using assms l8_14_2_1a by auto

lemma perp_proj:
  assumes "A B Perp C D" and
    "¬ Col A C D"
  shows "∃ X. Col A B X ∧ A X Perp C D"
  using assms(1) not_col_distincts by auto

lemma l8_24 :
  assumes "P A Perp A B" and
    "Q B Perp A B" and
    "Col A B T" and
    "Bet P T Q" and
    "Bet B R Q" and
    "Cong A P B R"
  shows "∃ X. X Midpoint A B ∧ X Midpoint P R"
proof -
  obtain X where P1: "Bet T X B ∧ Bet R X P"
    using assms(4) assms(5) inner_pasch by blast
  have P2: "Col A B X"
    by (metis Out_cases P1 assms(3) bet_out_1 col_out2_col not_col_distincts out_trivial)
  have P3: "A ≠ B"
    using assms(1) col_trivial_2 l8_16_1 by blast
  have P4: "A ≠ P"
    using assms(1) col_trivial_1 l8_16_1 by blast
  have "∃ X. X Midpoint A B ∧ X Midpoint P R"
  proof cases
    assume "Col A B P"
    thus ?thesis
      using Perp_perm assms(1) perp_not_col by blast
  next
    assume Q1: "¬ Col A B P"
    have Q2: "B ≠ R"
      using P4 assms(6) cong_diff by blast
    have Q3: "Q ≠ B"
      using Q2 assms(5) between_identity by blast
    have Q4: "¬ Col A B Q"
      by (metis assms(2) col_permutation_3 l8_14_1 perp_col1 perp_not_col)
    have Q5: "¬ Col A B R"
      by (meson Q2 Q4 assms(5) bet_col col_transitivity_1 not_col_permutation_2)
    have Q6: "P ≠ R"
      using P1 P2 Q5 between_identity by blast
    have "∃ X. X Midpoint A B ∧ X Midpoint P R"
    proof cases
      assume "A = P"
      thus ?thesis
        using P4 by blast
    next
      assume R0: "¬ A = P"
      have R1: "A B Perp R B"
        by (metis Perp_cases Q2 bet_col1 assms(2) assms(5) bet_col col_transitivity_1 perp_col1)
      have R2: "Cong A R P B"
        using P1 P2 P3 Perp_perm R0 R1 assms(1) assms(6) between_symmetry perp_cong by blast
      have R3: "¬ Col A P B"
        using Col_perm Q1 by blast
      have R4: "P ≠ R"
        by (simp add: Q6)
      have R5: "Cong A P B R"
        by (simp add: assms(6))
      have R6: "Cong P B R A"
        using R2 not_cong_4312 by blast
      have R7: "Col A X B"
        using Col_perm P2 by blast
      have R8: "Col P X R"
        by (simp add: P1 bet_col between_symmetry)
      thus ?thesis using l7_21
        using R3 R4 R5 R6 R7 by blast
    qed
    thus ?thesis by simp
  qed
  thus ?thesis
    by simp
qed

lemma col_per2__per:
  assumes "A ≠ B" and
    "Col A B C" and
    "Per A X P" and
    "Per B X P"
  shows "Per C X P"
  by (meson Per_def assms(1) assms(2) assms(3) assms(4) l4_17 per_double_cong)

lemma perp_in_per_1:
  assumes "X PerpAt A B C D"
  shows "Per A X C"
  using PerpAt_def assms col_trivial_1 by auto

lemma perp_in_per_2:
  assumes "X PerpAt A B C D"
  shows "Per A X D"
  using assms perp_in_per_1 perp_in_right_comm by blast

lemma perp_in_per_3:
  assumes "X PerpAt A B C D"
  shows "Per B X C"
  using assms perp_in_comm perp_in_per_2 by blast

lemma perp_in_per_4:
  assumes "X PerpAt A B C D"
  shows "Per B X D"
  using assms perp_in_per_3 perp_in_right_comm by blast

lemma coplanar_perm_1:
  assumes "Coplanar A B C D"
  shows "Coplanar A B D C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_2:
  assumes "Coplanar A B C D"
  shows "Coplanar A C B D"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_3:
  assumes "Coplanar A B C D"
  shows "Coplanar A C D B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_4:
  assumes "Coplanar A B C D"
  shows "Coplanar A D B C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_5:
  assumes "Coplanar A B C D"
  shows "Coplanar A D C B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_6:
  assumes "Coplanar A B C D"
  shows "Coplanar B A C D"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_7:
  assumes "Coplanar A B C D"
  shows "Coplanar B A D C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_8:
  assumes "Coplanar A B C D"
  shows "Coplanar B C A D"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_9:
  assumes "Coplanar A B C D"
  shows "Coplanar B C D A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_10:
  assumes "Coplanar A B C D"
  shows "Coplanar B D A C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_11:
  assumes "Coplanar A B C D"
  shows "Coplanar B D C A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_12:
  assumes "Coplanar A B C D"
  shows "Coplanar C A B D"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_13:
  assumes "Coplanar A B C D"
  shows "Coplanar C A D B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_14:
  assumes "Coplanar A B C D"
  shows "Coplanar C B A D"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_15:
  assumes "Coplanar A B C D"
  shows "Coplanar C B D A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_16:
  assumes "Coplanar A B C D"
  shows "Coplanar C D A B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_17:
  assumes "Coplanar A B C D"
  shows "Coplanar C D B A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_18:
  assumes "Coplanar A B C D"
  shows "Coplanar D A B C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_19:
  assumes "Coplanar A B C D"
  shows "Coplanar D A C B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_20:
  assumes "Coplanar A B C D"
  shows "Coplanar D B A C"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_21:
  assumes "Coplanar A B C D"
  shows "Coplanar D B C A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_22:
  assumes "Coplanar A B C D"
  shows "Coplanar D C A B"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma coplanar_perm_23:
  assumes "Coplanar A B C D"
  shows "Coplanar D C B A"
proof -
  obtain X where "(Col A B X ∧ Col C D X) ∨ (Col A C X ∧ Col B D X) ∨ (Col A D X ∧ Col B C X)"
    using Coplanar_def assms by blast
  thus ?thesis
    using Coplanar_def col_permutation_4 by blast
qed

lemma ncoplanar_perm_1:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar A B D C"
  using assms coplanar_perm_1 by blast

lemma ncoplanar_perm_2:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar A C B D"
  using assms coplanar_perm_2 by blast

lemma ncoplanar_perm_3:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar A C D B"
  using assms coplanar_perm_4 by blast

lemma ncoplanar_perm_4:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar A D B C"
  using assms coplanar_perm_3 by blast

lemma ncoplanar_perm_5:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar A D C B"
  using assms coplanar_perm_5 by blast

lemma ncoplanar_perm_6:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar B A C D"
  using assms coplanar_perm_6 by blast

lemma ncoplanar_perm_7:
  assumes "¬  Coplanar A B C D"
  shows "¬ Coplanar B A D C"
  using assms coplanar_perm_7 by blast

lemma ncoplanar_perm_8:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar B C A D"
  using assms coplanar_perm_12 by blast

lemma ncoplanar_perm_9:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar B C D A"
  using assms coplanar_perm_18 by blast

lemma ncoplanar_perm_10:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar B D A C"
  using assms coplanar_perm_13 by blast

lemma ncoplanar_perm_11:
  assumes "¬ Coplanar A B C D"
  shows "¬  Coplanar B D C A"
  using assms coplanar_perm_19 by blast

lemma ncoplanar_perm_12:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C A B D"
  using assms coplanar_perm_8 by blast

lemma ncoplanar_perm_13:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C A D B"
  using assms coplanar_perm_10 by blast

lemma ncoplanar_perm_14:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C B A D"
  using assms coplanar_perm_14 by blast

lemma ncoplanar_perm_15:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C B D A"
  using assms coplanar_perm_20 by blast

lemma ncoplanar_perm_16:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C D A B"
  using assms coplanar_perm_16 by blast

lemma ncoplanar_perm_17:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar C D B A"
  using assms coplanar_perm_22 by blast

lemma ncoplanar_perm_18:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar D A B C"
  using assms coplanar_perm_9 by blast

lemma ncoplanar_perm_19:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar D A C B"
  using assms coplanar_perm_11 by blast

lemma ncoplanar_perm_20:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar D B A C"
  using assms coplanar_perm_15 by blast

lemma ncoplanar_perm_21:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar D B C A"
  using assms coplanar_perm_21 by blast

lemma ncoplanar_perm_22:
  assumes "¬ Coplanar A B C D"
  shows "¬ Coplanar D C A B"
  using assms coplanar_perm_17 by blast

lemma ncoplanar_perm_23:
  assumes "¬  Coplanar A B C D"
  shows "¬ Coplanar D C B A"
  using assms coplanar_perm_23 by blast

lemma coplanar_trivial:
  shows "Coplanar A A B C"
  using Coplanar_def NCol_cases col_trivial_1 by blast

lemma col__coplanar:
  assumes "Col A B C"
  shows "Coplanar A B C D"
  using Coplanar_def assms not_col_distincts by blast

lemma ncop__ncol:
  assumes "¬ Coplanar A B C D"
  shows "¬ Col A B C"
  using assms col__coplanar by blast

lemma ncop__ncols:
  assumes "¬ Coplanar A B C D"
  shows "¬ Col A B C ∧ ¬ Col A B D ∧ ¬ Col A C D ∧ ¬ Col B C D"
  by (meson assms col__coplanar coplanar_perm_4 ncoplanar_perm_9)

lemma bet__coplanar:
  assumes "Bet A B C"
  shows "Coplanar A B C D"
  using assms bet_col ncop__ncol by blast

lemma out__coplanar:
  assumes "A Out B C"
  shows "Coplanar A B C D"
  using assms col__coplanar out_col by blast

lemma midpoint__coplanar:
  assumes "A Midpoint B C"
  shows "Coplanar A B C D"
  using assms midpoint_col ncop__ncol by blast

lemma perp__coplanar:
  assumes "A B Perp C D"
  shows "Coplanar A B C D"
proof -
  obtain P where "P PerpAt A B C D"
    using Perp_def assms by blast
  thus ?thesis
    using Coplanar_def perp_in_col by blast
qed

lemma ts__coplanar:
  assumes "A B TS C D"
  shows "Coplanar A B C D"
  by (metis Coplanar_def TS_def assms bet_col col_permutation_2 col_permutation_3)

lemma reflectl__coplanar:
  assumes "A B ReflectL C D"
  shows "Coplanar A B C D"
  by (metis ReflectL_def perp__coplanar assms col__coplanar col_trivial_1 ncoplanar_perm_17)

lemma reflect__coplanar:
  assumes "A B Reflect C D"
  shows "Coplanar A B C D"
  by (metis Reflect_def reflectl__coplanar assms col_trivial_2 ncop__ncols)

lemma inangle__coplanar:
  assumes "A InAngle B C D"
  shows "Coplanar A B C D"
proof -
  obtain X where "Bet B X D ∧ (X = C ∨ C Out X A)"
    using InAngle_def assms by auto
  thus ?thesis
    by (meson Col_cases Coplanar_def bet_col ncop__ncols out_col)
qed

lemma pars__coplanar:
  assumes "A B ParStrict C D"
  shows "Coplanar A B C D"
  using ParStrict_def assms by auto

lemma par__coplanar:
  assumes "A B Par C D"
  shows "Coplanar A B C D"
  using Par_def assms ncop__ncols pars__coplanar by blast

lemma plg__coplanar:
  assumes "Plg A B C D"
  shows "Coplanar A B C D"
proof -
  obtain M where "Bet A M C ∧ Bet B M D"
    by (meson Plg_def assms midpoint_bet)
  thus ?thesis
    by (metis InAngle_def bet_out_1 inangle__coplanar ncop__ncols not_col_distincts)
qed

lemma plgs__coplanar:
  assumes "ParallelogramStrict A B C D"
  shows "Coplanar A B C D"
  using ParallelogramStrict_def assms par__coplanar by blast

lemma plgf__coplanar:
  assumes "ParallelogramFlat A B C D"
  shows "Coplanar A B C D"
  using ParallelogramFlat_def assms col__coplanar by auto

lemma parallelogram__coplanar:
  assumes "Parallelogram A B C D"
  shows "Coplanar A B C D"
  using Parallelogram_def assms plgf__coplanar plgs__coplanar by auto

lemma rhombus__coplanar:
  assumes "Rhombus A B C D"
  shows "Coplanar A B C D"
  using Rhombus_def assms plg__coplanar by blast

lemma rectangle__coplanar:
  assumes "Rectangle A B C D"
  shows "Coplanar A B C D"
  using Rectangle_def assms plg__coplanar by blast

lemma square__coplanar:
  assumes "Square A B C D"
  shows "Coplanar A B C D"
  using Square_def assms rectangle__coplanar by blast

lemma lambert__coplanar:
  assumes "Lambert A B C D"
  shows "Coplanar A B C D"
  using Lambert_def assms by presburger

lemma ts_distincts:
  assumes "A B TS P Q"
  shows "A ≠ B ∧ A ≠ P ∧ A ≠ Q ∧ B ≠ P ∧ B ≠ Q ∧ P ≠ Q"
  using TS_def assms bet_neq12__neq not_col_distincts by blast

lemma l9_2:
  assumes "A B TS P Q"
  shows "A B TS Q P"
  using TS_def assms between_symmetry by blast

lemma invert_two_sides:
  assumes "A B TS P Q"
  shows "B A TS P Q"
  using TS_def assms not_col_permutation_5 by blast

lemma l9_3:
  assumes "P Q TS A C" and
    "Col M P Q" and
    "M Midpoint A C" and
    "Col R P Q" and
    "R Out A B"
  shows "P Q TS B C"
proof -
  have "¬ Col A P Q"
    using TS_def assms(1) by blast
  hence "P ≠ Q"
    using not_col_distincts by auto
  obtain T where "Col T P Q" and "Bet A T C"
    using assms(2) assms(3) midpoint_bet by blast
  have "A ≠ C"
    using assms(1) ts_distincts by blast
  have "T = M" 
  proof -
    have "Bet A M C" 
      using assms(3) midpoint_bet by blast
    hence "Col A M C" 
      using Col_def by force
    moreover have "Col A T C" 
      using ‹Bet A T C› bet_col by blast
    moreover have "Col R A B" 
      using assms(5) out_col by auto
    ultimately show ?thesis
      by (meson l6_21 ‹A ≠ C› ‹Col T P Q› ‹¬ Col A P Q› assms(2) col_permutation_3 
          col_permutation_5)
  qed
  have "P Q TS B C"
  proof cases
    assume "C = M"
    thus ?thesis 
      using ‹A ≠ C› assms(3) is_midpoint_id_2 by blast
  next
    assume "¬ C = M"
    have "¬ Col B P Q" 
      by (metis ‹¬ Col A P Q› assms(4) assms(5) col_permutation_2 colx out_col out_diff2)
    have "Bet R A B ∨ Bet R B A"
      using Out_def assms(5) by auto
    {
      assume "Bet R A B"
      obtain B' where "M Midpoint B B'"
        using symmetric_point_construction by blast
      obtain R' where "M Midpoint R R'"
        using symmetric_point_construction by blast
      have "Bet B' C R'" 
        using l7_15 ‹Bet R A B› ‹M Midpoint B B'› ‹M Midpoint R R'› assms(3) between_symmetry 
        by fastforce
      have "∃ X. Bet M X R' ∧ Bet C X B" 
      proof -
        have "Bet B M B'" 
          using Midpoint_def ‹M Midpoint B B'› by auto
        moreover have "Bet R' C B'" 
          using Bet_cases ‹Bet B' C R'› by auto
        ultimately show ?thesis 
          by (simp add: inner_pasch)
      qed
      then obtain X where "Bet M X R'" and "Bet C X B" 
        by blast
      have "Col X P Q"
      proof -
        have "Col P M R" 
          using ‹P ≠ Q› assms(2) assms(4) l6_16_1 not_col_permutation_2 by blast
        have "Col Q M R" 
          by (metis l6_16_1 ‹Col P M R› assms(2) assms(4) col_permutation_2)
        {
          assume "M = X"
          hence "Col X P Q"
            using assms(2) by blast
        }
        hence "M = X ⟶ Col X P Q" by simp
        {
          assume "M ≠ X"
          hence "M ≠ R'" 
            using ‹Bet M X R'› between_identity by blast
          hence "M ≠ R" 
            using ‹M Midpoint R R'› is_midpoint_id by blast
          hence "Col X P Q" 
            by (metis ‹Bet M X R'› ‹M Midpoint R R'› ‹M ≠ R'› assms(2) assms(4) 
                bet_col col_permutation_4 col_permutation_5 colx midpoint_col)
        }
        hence "M ≠ X ⟶ Col X P Q" by simp
        thus ?thesis 
          using assms(2) by blast
      qed
      have "Bet B X C" 
        using Bet_cases ‹Bet C X B› by blast
      hence "P Q TS B C" 
        using TS_def ‹Col X P Q› ‹¬ Col B P Q› assms(1) by blast
    }
    hence "Bet R A B ⟶ P Q TS B C" by simp
    {
      assume "Bet R B A"
      have "Bet C M A" 
        using Bet_cases ‹Bet A T C› ‹T = M› by blast
      then obtain X where "Bet B X C" and "Bet M X R" 
        using ‹Bet R B A› inner_pasch by blast
      have "Col X P Q"  
        by (metis Col_def ‹Bet M X R› assms(2) assms(4) between_equality_2 
            between_trivial2 col_transitivity_1)
      hence "P Q TS B C" 
        using TS_def ‹Bet B X C› ‹¬ Col B P Q› assms(1) by blast
    }
    hence "Bet R B A ⟶ P Q TS B C" by simp
    thus ?thesis 
      using ‹Bet R A B ⟹ P Q TS B C› ‹Bet R A B ∨ Bet R B A› by blast
  qed
  thus ?thesis by blast
qed

lemma mid_preserves_col:
  assumes "Col A B C" and
    "M Midpoint A A'" and
    "M Midpoint B B'" and
    "M Midpoint C C'"
  shows "Col A' B' C'"
  using Col_def assms(1) assms(2) assms(3) assms(4) l7_15 by auto

lemma per_mid_per:
  assumes (*"A ≠ B" and*)
    "Per X A B" and
    "M Midpoint A B" and
    "M Midpoint X Y"
  shows "Cong A X B Y ∧ Per Y B A"
  by (meson Cong3_def Mid_perm assms(1) assms(2) assms(3) l7_13 l8_10)

lemma sym_preserve_diff:
  assumes "A ≠ B" and
    "M Midpoint A A'" and
    "M Midpoint B B'"
  shows "A'≠ B'"
  using assms(1) assms(2) assms(3) l7_9 by blast

lemma l9_4_1_aux_R1:
  assumes "R = S" and
    "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "M Midpoint R S"
  shows "∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C')"
proof -
  have "M = R"
    using assms(1) assms(8) l7_3 by blast
  have "¬ Col A P Q"
    using TS_def assms(3) by auto
  hence "P ≠ Q"
    using not_col_distincts by blast
  obtain T where "Col T P Q" and "Bet A T C"
    using TS_def assms(3) by blast
  {
    assume "¬ M = T"
    hence "M PerpAt M T A M" 
      using perp_col2 assms(4) assms(5) not_col_permutation_3 perp_left_comm perp_perp_in
      by (metis ‹Col T P Q› ‹M = R›)
    hence "M T Perp C M"
      using ‹M ≠ T› assms(1) assms(4) assms(7) col_permutation_1 perp_col2 ‹Col T P Q› ‹M = R› 
      by blast
    hence "Per T M A"
      using ‹M PerpAt M T A M› perp_in_per_3 by blast
    have "Per T M C"
      by (simp add: ‹M T Perp C M› perp_per_1)
    have "M = T"
    proof -
      have "Per C M T"
        by (simp add: ‹Per T M C› l8_2)
      thus ?thesis 
        using l8_6 l8_2 ‹Bet A T C› ‹Per T M A› by blast
    qed
    hence "False"
      using ‹M ≠ T› by blast
  }
  hence "M = T" by blast
  have "∀ U C'. ((M Midpoint U C' ∧ M Out U A) ⟶ M Out C C')"
  proof -
    {
      fix U C'
      assume "M Midpoint U C'" and "M Out U A"
      have "C ≠ M"
        using assms(1) assms(7) perp_not_eq_2 ‹M = R› by blast
      have "C' ≠ M"
        using midpoint_not_midpoint out_diff1 ‹M Midpoint U C'› ‹M Out U A› by blast
      have "Bet U M C"
        using bet_out__bet l6_6 ‹Bet A T C› ‹M = T› ‹M Out U A› by blast
      hence "M Out C C'" 
        by (metis Out_def midpoint_bet ‹C ≠ M› ‹C' ≠ M› ‹M Midpoint U C'› ‹M Out U A› l5_2)
    }
    thus ?thesis by blast
  qed
  have "∀ U C'. ((M Midpoint U C' ∧ M Out C C') ⟶ M Out U A)"
  proof -
    {
      fix U C'
      assume "M Midpoint U C'" and "M Out C C'"
      have "C ≠ M"
        using assms(1) assms(7) perp_not_eq_2 ‹M = R› by blast
      have "C' ≠ M"
        using l6_3_1 ‹M Out C C'› by blast
      have "Bet U M C"
        using Out_def between_inner_transitivity midpoint_bet outer_transitivity_between 
        by (metis ‹M Midpoint U C'› ‹M Out C C'›)
      hence "M Out U A"
        using l6_2 midpoint_distinct_1 
        by (metis ‹Bet A T C› ‹C ≠ M› ‹C' ≠ M› ‹M = R› ‹M Midpoint U C'› 
            ‹M ≠ T ⟹ False› ‹¬ Col A P Q› assms(4))
    }
    thus ?thesis by blast
  qed
  thus ?thesis 
    using ‹M = R› ‹∀U C'. M Midpoint U C' ∧ M Out U A ⟶ M Out C C'› assms(1) by blast
qed

lemma l9_4_1_aux_R21:
  assumes "R ≠ S" and
    "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "M Midpoint R S"
  shows "∀ U C'. M Midpoint U C' ⟶  (R Out U A ⟷ S Out C C')"
proof -
  obtain D where "Bet R D A" and "Cong S C R D"
    using Le_def assms(2) by blast
  have "C ≠ S"
    using assms(7) perp_not_eq_2 by auto
  have "R ≠ D"
    using cong_identity ‹C ≠ S› ‹Cong S C R D› by blast
  have "R S Perp A R"
    using assms(1) assms(4) assms(5) assms(6) not_col_permutation_2 perp_col2 by blast
  have "∃ M. (M Midpoint S R ∧ M Midpoint C D)"
  proof -
    have "¬ Col A P Q"
      using TS_def assms(3) by blast
    have "P ≠ Q"
      using not_col_distincts assms(3) ts_distincts by blast
    obtain T where "Col T P Q" and "Bet A T C"
      using TS_def assms(3) by blast
    have "C S Perp S R"
      by (metis NCol_perm assms(1) assms(4) assms(6) assms(7) perp_col0)
    have "A R Perp S R"
      using Perp_perm ‹R S Perp A R› by blast
    have "Col S R T"
      using Col_cases assms(4) assms(6) col3 ‹Col T P Q› ‹P ≠ Q› by blast
    have "Bet C T A"
      using Bet_perm ‹Bet A T C› by blast
    thus ?thesis 
      using l8_24 ‹A R Perp S R› ‹Bet R D A› ‹C S Perp S R› ‹Col S R T› ‹Cong S C R D› by blast
  qed
  then obtain M' where "M' Midpoint S R" and "M' Midpoint C D" by blast
  have "M = M'" 
    using assms(8) l7_17_bis ‹M' Midpoint S R› by blast
  have "∀ U C'. (M Midpoint U C' ∧ R Out U A) ⟶ S Out C C'"
  proof -
    {
      fix U C'
      assume "M Midpoint U C'" and "R Out U A"
      have "C' ≠ S"
        using ‹M Midpoint U C'› ‹R Out U A› assms(8) l7_9 out_diff1 by blast
      have "Bet S C C' ∨ Bet S C' C"
      proof -
        have "Bet R U A ∨ Bet R A U"
          using Out_def ‹R Out U A› by auto
        {
          assume "Bet R U A"
          hence "Bet R U D ∨ Bet R D U"
            by (simp add: ‹Bet R D A› l5_3)
          hence "Bet S C C' ∨ Bet S C' C"
            using l7_15 l7_2 ‹M = M'› ‹M Midpoint U C'› ‹M' Midpoint C D› assms(8) by blast
        }
        hence "Bet R U A ⟶ Bet S C C' ∨ Bet S C' C" by simp
        have "Bet R A U ⟶ Bet S C C' ∨ Bet S C' C"
          using l7_15 l7_2 ‹Bet R D A› ‹M = M'› ‹M Midpoint U C'› ‹M' Midpoint C D› 
            assms(8) between_exchange4 by blast
        thus ?thesis 
          using ‹Bet R U A ⟹ Bet S C C' ∨ Bet S C' C› ‹Bet R U A ∨ Bet R A U› by blast
      qed
      hence "S Out C C'" 
        using Out_def ‹C ≠ S› ‹C' ≠ S› by auto
    }
    thus ?thesis
      by blast
  qed
  have "∀ U C'. (M Midpoint U C' ∧ S Out C C') ⟶ R Out U A"
  proof -
    {
      fix U C'
      assume "M Midpoint U C'" and "S Out C C'"
      hence "U ≠ R" 
        using l7_9_bis ‹M = M'› ‹M' Midpoint S R› out_distinct by blast
      have "A ≠ R"
        using assms(5) perp_distinct by auto
      have "Bet S C C' ∨ Bet S C' C"
        using Out_def ‹S Out C C'› by fastforce
      {
        assume "Bet S C C'"
        have "Bet R D U"
        proof -
          have "M Midpoint S R" 
            by (simp add: ‹M = M'› ‹M' Midpoint S R›)
          moreover have "M Midpoint C D" 
            by (simp add: ‹M = M'› ‹M' Midpoint C D›)
          moreover have "M Midpoint C' U" 
            by (simp add: ‹M Midpoint U C'› l7_2)
          ultimately show ?thesis 
            by (simp add: ‹Bet S C C'› l7_15)
        qed
        hence "Bet R U A ∨ Bet R A U" 
          using ‹Bet R D A› ‹R ≠ D› l5_1 by auto
      }
      hence "Bet S C C' ⟶ Bet R U A ∨ Bet R A U" by simp
      {
        assume "Bet S C' C"
        have "Bet R U A" 
          using l7_15 l7_2 between_exchange4 ‹Bet R D A› ‹M = M'› ‹M Midpoint U C'› 
          by (meson ‹Bet S C' C› ‹M' Midpoint C D› ‹M' Midpoint S R›)
      }
      hence "Bet S C' C ⟶ Bet R U A ∨ Bet R A U" by simp
      hence "Bet R U A ∨ Bet R A U" 
        using ‹Bet S C C' ⟹ Bet R U A ∨ Bet R A U› ‹Bet S C C' ∨ Bet S C' C› by blast
      hence "R Out U A" 
        by (simp add: Out_def ‹A ≠ R› ‹U ≠ R›)
    }
    thus ?thesis by blast
  qed
  thus ?thesis 
    using ‹∀U C'. M Midpoint U C' ∧ R Out U A ⟶ S Out C C'› by blast
qed

lemma l9_4_1_aux:
  assumes "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "M Midpoint R S"
  shows "∀ U C'. (M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C'))"
  using l9_4_1_aux_R1 l9_4_1_aux_R21 assms by fast


lemma per_col_eq:
  assumes "Per A B C" and
    "Col A B C" and
    "B ≠ C"
  shows "A = B"
  using assms(1) assms(2) assms(3) l8_9 by blast

lemma l9_4_1:
  assumes "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "M Midpoint R S"
  shows "∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C')"
proof -
  have "S C Le R A ∨ R A  Le S C"
    using le_cases by blast
  {
    assume "S C Le R A"
    {
      fix U C'
      assume "M Midpoint U C'"
      hence "(R Out U A ⟷ S Out C C')"
        using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l9_4_1_aux ‹S C Le R A› 
        by blast
    }
    hence "∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C')" by simp
  }
  hence "S C Le R A ⟶ (∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C'))" by simp
  moreover
  {
    assume " R A Le S C"
    {
      fix U C'
      assume "M Midpoint U C'"
      hence "(R Out A U ⟷ S Out C' C)"
        using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l7_2 l9_2 l9_4_1_aux 
        by (meson Out_cases le_cases)
      hence "(R Out U A ⟷ S Out C C')"
        using l6_6 by blast
    }
    hence "∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C')" by simp
  }
  hence "R A Le S C ⟶ (∀ U C'. M Midpoint U C' ⟶ (R Out U A ⟷ S Out C C'))" by simp
  thus ?thesis 
    using ‹S C Le R A ∨ R A Le S C› calculation by presburger
qed

lemma mid_two_sides:
  assumes "M Midpoint A B" and
    "¬ Col A B X" and
    "M Midpoint X Y"
  shows "A B TS X Y"
proof -
  have "¬ Col Y A B"
    by (meson Mid_cases mid_preserves_col assms(1) assms(2) assms(3) col_permutation_3)
  moreover have "Bet X M Y"
    using assms(3) midpoint_bet by blast
  ultimately show ?thesis 
    by (metis TS_def not_col_permutation_2 assms(1) assms(2) midpoint_col)
qed

lemma col_preserves_two_sides:
  assumes "C ≠ D" and
    "Col A B C" and
    "Col A B D" and
    "A B TS X Y"
  shows "C D TS X Y"
proof -
  have "¬ Col X A B"
    using TS_def assms(4) by blast
  hence "A ≠ B"
    using not_col_distincts by blast
  have "¬ Col X C D"
    using colx assms(1) assms(2) assms(3)
    by (meson ‹¬ Col X A B› not_col_permutation_2)
  have "¬ Col Y C D"
    by (metis Col_cases TS_def colx assms(1) assms(2) assms(3) assms(4))
  thus ?thesis
  proof -
    obtain PP where "¬ Col X A B" and "¬ Col Y A B" and "Col PP A B" and "Bet X PP Y" 
      using TS_def assms(4) by blast
    hence "Col PP C D" 
      using ‹A ≠ B› assms(2) assms(3) col3 col_permutation_1 by blast
    thus ?thesis 
      using TS_def ‹Bet X PP Y› ‹¬ Col X C D› ‹¬ Col Y C D› by blast
  qed
qed

lemma out_out_two_sides:
  assumes "A ≠ B" and
    "A B TS X Y" and
    "Col I A B" and
    "Col I X Y" and
    "I Out X U" and
    "I Out Y V"
  shows "A B TS U V"
proof -
  have "¬ Col X A B"
    using TS_def assms(2) by blast
  {
    assume "Col V A B"
    hence "Col Y A B" 
      by (metis out_distinct assms(3) assms(6) col_permutation_2 colx out_col)
    have False 
      using TS_def ‹Col Y A B› assms(2) by blast
  }
  moreover
  have "¬ Col U A B" 
    using assms(3) assms(5) col_permutation_2 colx out_col out_distinct by (meson ‹¬ Col X A B›)
  moreover
  obtain T where "Col T A B" and "Bet X T Y"
    using TS_def assms(2) by blast
  have "I = T"
  proof -
    have "Col X Y I" 
      using assms(4) Col_cases by blast
    moreover have "Col B A I"
      using assms(3) Col_cases by blast
    moreover have "Col B A T" 
      using Col_cases ‹Col T A B› by auto
    moreover have "¬ Col X A B ∧ ¬ Col X B A ∧ ¬ Col A X B ∧ ¬ Col A B X ∧ ¬ Col B X A ∧ ¬ Col B A X"
      using ‹¬ Col X A B› Col_cases by blast
    moreover have "A ≠ B ∧ A ≠ X ∧ A ≠ Y ∧ B ≠ X ∧ B ≠ Y ∧ X ≠ Y"
      using assms(2) ts_distincts by presburger
    moreover have "Col X Y T" 
      using ‹Bet X T Y› bet_col1 between_trivial by blast
    ultimately show ?thesis 
      using l6_21 by blast
  qed
  hence "Bet U T V"
    using assms(5) assms(6) bet_out_out_bet ‹Bet X T Y› by blast
  ultimately show ?thesis 
    using TS_def ‹Col T A B› by blast
qed

lemma l9_4_2_aux_R1:
  assumes "R = S " and
    "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "R Out U A" and
    "S Out V C"
  shows "P Q TS U V"
proof -
  have "¬ Col A P Q"
    using TS_def assms(3) by auto
  hence "P ≠ Q"
    using not_col_distincts by blast
  obtain T where "Col T P Q" and "Bet A T C"
    using TS_def assms(3) by blast
  have "R = T" 
    using assms(1) assms(5) assms(6) assms(7) col_permutation_1 l8_16_1 l8_6 
    by (meson ‹Bet A T C› ‹Col T P Q›)
  thus ?thesis 
    by (metis ‹Bet A T C› ‹Col T P Q› ‹P ≠ Q› assms(1) assms(3) assms(8) assms(9) 
        bet_col col_permutation_4 l6_6 out_out_two_sides)
qed

lemma l9_4_2_aux_R2:
  assumes "R ≠ S" and
    "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "R Out U A" and
    "S Out V C"
  shows "P Q TS U V"
proof -
  have "P ≠ Q"
    using assms(7) perp_distinct by auto
  have "R S TS A C"
    using assms(1) assms(3) assms(4) assms(6) col_permutation_1 col_preserves_two_sides by blast
  have "Col R S P"
    using assms(4) assms(6) col2__eq not_col_permutation_1 ‹P ≠ Q› by blast
  have "Col R S Q"
    using colx Tarski_neutral_dimensionless_axioms assms(4) assms(6) col_trivial_2 
    by (metis ‹Col R S P›)
  have "R S Perp A R"
    using NCol_perm assms(1) assms(4) assms(5) assms(6) perp_col2 by blast
  have "R S Perp C S"
    using assms(1) assms(4) assms(6) assms(7) col_permutation_1 perp_col2 by blast
  have "¬ Col A R S" 
    using TS_def ‹R S TS A C› by force
  obtain T where "Col T R S" and "Bet A T C" 
    using TS_def ‹R S TS A C› by blast
  obtain C' where "Bet R C' A" and "Cong S C R C'" 
    using Le_def assms(2) by blast
  have "∃ X. X Midpoint S R ∧ X Midpoint C C'"
  proof -
    have "C S Perp S R" 
      using Perp_perm ‹R S Perp C S› by blast
    moreover have "A R Perp S R" 
      using Perp_perm ‹R S Perp A R› by blast
    moreover have "Col S R T" 
      using Col_cases ‹Col T R S› by auto
    moreover have "Bet C T A" 
      using Bet_cases ‹Bet A T C› by blast
    ultimately show ?thesis 
      using l8_24 ‹Bet R C' A› ‹Cong S C R C'› by blast
  qed
  then obtain M where "M Midpoint S R" and "M Midpoint C C'" 
    by blast
  obtain U' where "M Midpoint U U'"
    using symmetric_point_construction by blast
  have "R ≠ U"
    using assms(8) out_diff1 by blast
  have "R S TS U U'" 
    by (metis Col_def Out_def invert_two_sides l6_16_1 mid_two_sides ‹M Midpoint S R› 
        ‹M Midpoint U U'› ‹¬ Col A R S› assms(8))
  have "R S TS V U"
  proof -
    have "Col M R S" 
      using Col_def Midpoint_def ‹M Midpoint S R› by force
    moreover have "M Midpoint U' U" 
      by (simp add: ‹M Midpoint U U'› l7_2)
    moreover have "S Out U' V" 
      by (meson l6_7 ‹M Midpoint S R› ‹M Midpoint U U'› assms(2) assms(3) assms(4) 
          assms(5) assms(6) assms(7) assms(8) assms(9) l6_6 l7_2 l9_4_1_aux)
    ultimately show ?thesis 
      using ‹R S TS U U'› col_trivial_3 l9_2 l9_3 by blast
  qed
  thus ?thesis 
    using ‹Col R S P› ‹Col R S Q› ‹P ≠ Q› col_preserves_two_sides l9_2 by presburger
qed

lemma l9_4_2_aux:
  assumes "S C Le R A" and
    "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "R Out U A" and
    "S Out V C"
  shows "P Q TS U V"
  using l9_4_2_aux_R1 l9_4_2_aux_R2 
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) assms(8))

lemma l9_4_2:
  assumes "P Q TS A C" and
    "Col R P Q" and
    "P Q Perp A R" and
    "Col S P Q" and
    "P Q Perp C S" and
    "R Out U A" and
    "S Out V C"
  shows "P Q TS U V"
proof -
  have "S C Le R A ∨ R A Le S C"
    by (simp add: local.le_cases)
  moreover have "S C Le R A ⟶ P Q TS U V"
    by (simp add: assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) l9_4_2_aux)
  moreover have "R A Le S C ⟶ P Q TS U V"
    by (simp add: assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) l9_2 l9_4_2_aux)
  ultimately show ?thesis
    by blast
qed

lemma l9_5:
  assumes "P Q TS A C" and
    "Col R P Q" and
    "R Out A B"
  shows "P Q TS B C"
proof -
  have "P ≠ Q"
    using assms(1) ts_distincts by blast
  obtain A' where "Col P Q A'" and "P Q Perp A A'"
    by (metis NCol_perm TS_def assms(1) l8_18_existence)
  obtain C' where "Col P Q C'" and "P Q Perp C C'"
    using Col_perm TS_def assms(1) l8_18_existence by blast
  obtain M where "M Midpoint A' C'"
    using midpoint_existence by blast
  obtain D where "M Midpoint A D"
    using symmetric_point_construction by auto
  have "∃ B0. Col P Q B0 ∧ P Q Perp B B0"
  proof -
    have "¬ Col P Q B"
      using colx perp_not_col2 Tarski_neutral_dimensionless_axioms assms(2) assms(3) 
        col_permutation_1 l6_3_1 out_col by (meson ‹Col P Q A'› ‹P Q Perp A A'›)
    thus ?thesis
      by (simp add: l8_18_existence)
  qed
  then obtain B' where "Col P Q B'" and "P Q Perp B B'" by blast
  have "P Q TS B C"
  proof -
    have "C' Out D C ⟷ A' Out A A"
      using Out_cases assms(1) l9_4_1 not_col_permutation_1 ‹Col P Q A'› ‹Col P Q C'› 
        ‹M Midpoint A D› ‹M Midpoint A' C'› ‹P Q Perp A A'› ‹P Q Perp C C'› by blast
    hence "C' Out D C"
      using perp_not_eq_2 Tarski_neutral_dimensionless_axioms out_trivial ‹P Q Perp A A'› by blast
    have "P Q TS A D"
      using assms(1) col_permutation_2 l9_4_2 
      by (meson ‹(C' Out D C) = (A' Out A A)› ‹C' Out D C› ‹Col P Q A'› ‹Col P Q C'› 
          ‹P Q Perp A A'› ‹P Q Perp C C'›)
    {
      assume "A' ≠ C'"
      hence "Col M P Q"
        using col_trivial_2 l6_21 midpoint_col not_col_permutation_1 
          ‹Col P Q A'› ‹Col P Q C'› ‹M Midpoint A' C'› by fast
      hence "P Q TS B D"
        using assms(2) assms(3) l9_3 ‹M Midpoint A D› ‹P Q TS A D› by blast
    }
    hence "A' ≠ C' ⟶ P Q TS B D" by simp
    hence "P Q TS B D"
      using assms(2) assms(3) l9_3 midpoint_distinct_2 not_col_permutation_1 
      by (metis ‹Col P Q A'› ‹M Midpoint A D› ‹M Midpoint A' C'› ‹P Q TS A D›)
    moreover have "Col B' P Q" 
      using ‹Col P Q B'› not_col_permutation_1 by blast
    moreover have "Col C' P Q" 
      using ‹Col P Q C'› col_permutation_2 by blast
    moreover have "P Q Perp D C'"
      using Col_perm l6_3_1 out_col perp_col1 perp_right_comm 
      by (metis ‹C' Out D C› ‹P Q Perp C C'›)
    moreover have "B' Out B B" 
      using ‹P Q Perp B B'› out_trivial perp_not_eq_2 by auto
    moreover have "C' Out C D" 
      using Out_cases ‹C' Out D C› by auto
    ultimately show ?thesis 
      using l9_4_2 ‹P Q Perp B B'› by blast
  qed
  thus ?thesis using l8_18_existence by blast
qed

lemma outer_pasch_R1:
  assumes "Col P Q C" and
    "Bet A C P" and
    "Bet B Q C"
  shows "∃ X. Bet A X B ∧ Bet P Q X"
proof cases
  assume "Bet P Q C"
  thus ?thesis 
    using Bet_cases assms(2) between_exchange4 between_trivial2 by blast
next
  assume "¬ Bet P Q C"
  thus ?thesis 
    by (metis Bet_cases assms(1) assms(3) between_exchange3 between_trivial 
        outer_transitivity_between2 third_point)
qed

lemma outer_pasch_R2:
  assumes "¬ Col P Q C" and
    "Bet A C P" and
    "Bet B Q C"
  shows "∃ X. Bet A X B ∧ Bet P Q X"
proof cases
  assume "B = Q"
  thus ?thesis
    using between_trivial by blast
next
  assume "B ≠ Q"
  have "A ≠ P"
    using assms(1) assms(2) between_identity col_trivial_3 by blast
  have "P ≠ Q"
    using assms(1) col_trivial_1 by blast
  have "P ≠ B"
    using assms(1) assms(3) bet_col by blast
  have "P Q TS C B"
  proof -
    have "¬ Col C P Q"
      using Col_cases assms(1) by blast
    moreover have "¬ Col B P Q"
      using Col_cases colx Tarski_neutral_dimensionless_axioms assms(1) assms(3) bet_col 
        col_trivial_2 ‹B ≠ Q› by fast
    moreover have "∃ T. Col T P Q ∧ Bet C T B"
      using Col_cases assms(3) between_symmetry col_trivial_2 by blast
    ultimately show ?thesis 
      using TS_def by blast
  qed
  have "P Q TS A B"
    using assms(1) assms(2) bet_out_1 l9_5 not_col_distincts ‹P Q TS C B› by metis
  obtain X where "Col X P Q" and "Bet A X B" 
    using TS_def ‹P Q TS A B› by blast
  have "Bet P Q X"
  proof -
    obtain T where "Bet X T P" and "Bet C T B"
      using assms(2) between_symmetry inner_pasch by (meson ‹Bet A X B›)
    have "B ≠ C"
      using assms(3) bet_neq12__neq ‹B ≠ Q› by auto
    have "T = Q"
    proof -
      have "Col Q C B"
        using NCol_cases assms(3) Col_def by blast
      have "Col T C B" 
        using ‹Bet C T B› bet_col col_permutation_4 by presburger
      have "¬ Col X P B" 
        by (metis Bet_cases TS_def ‹Bet C T B› ‹Bet X T P› ‹Col X P Q› ‹P Q TS C B› 
            assms(3) bet_col1 between_equality_2 between_trivial2 col_transitivity_2)
      thus ?thesis
        by (metis Col_def ‹B ≠ C› ‹Bet C T B› ‹Bet X T P› ‹Col Q C B› ‹Col X P Q› 
            between_symmetry l6_21)
    qed
    thus ?thesis 
      using ‹Bet X T P› between_symmetry by blast
  qed
  thus ?thesis 
    using ‹Bet A X B› by blast
qed

(** GeoCoq: Ch09_planve.v **)
(** This lemma used to be an axiom in previous versions of Tarski's axiom system.
It is a been shown to a theorem by Gupta in his Phd 1965. *)
(** This corresponds to l9_6 in Tarski's book. *)
lemma outer_pasch:
  assumes "Bet A C P" and
    "Bet B Q C"
  shows "∃ X. Bet A X B ∧ Bet P Q X"
  using assms(1) assms(2) outer_pasch_R1 outer_pasch_R2 by blast

lemma os_distincts:
  assumes "A B OS X Y"
  shows "A ≠ B ∧ A ≠ X ∧ A ≠ Y ∧ B ≠ X ∧ B ≠ Y"
  using OS_def assms ts_distincts by blast

lemma invert_one_side:
  assumes "A B OS P Q"
  shows "B A OS P Q"
proof -
  obtain T where "A B TS P T ∧ A B TS Q T"
    using OS_def assms by blast
  hence "B A TS P T ∧ B A TS Q T"
    using invert_two_sides by blast
  thus ?thesis
    using OS_def by blast
qed

lemma l9_8_1:
  assumes "P Q TS A C" and
    "P Q TS B C"
  shows "P Q OS A B"
proof -
  have "∃ R::'p. (P Q TS A R ∧ P Q TS B R)"
    using assms(1) assms(2) by blast
  thus ?thesis
    using OS_def by blast
qed

lemma not_two_sides_id:
  shows "¬ P Q TS A A"
  using ts_distincts by blast

lemma l9_8_2:
  assumes "P Q TS A C" and
    "P Q OS A B"
  shows "P Q TS B C"
proof -
  obtain D where P1: "P Q TS A D ∧ P Q TS B D"
    using assms(2) OS_def by blast
  hence "P ≠ Q"
    using ts_distincts by blast
  obtain T where P2: "Col T P Q ∧ Bet A T C"
    using TS_def assms(1) by blast
  obtain X where P3: "Col X P Q ∧ Bet A X D"
    using TS_def P1 by blast
  obtain Y where P4: "Col Y P Q ∧ Bet B Y D"
    using TS_def P1 by blast
  then obtain M where P5: "Bet Y M A ∧ Bet X M B" using P3 inner_pasch by blast
  have P6: "A ≠ D"
    using P1 ts_distincts by blast
  have P7: "B ≠ D"
    using P1 not_two_sides_id by blast
  {
    assume Q0: "Col A B D"
    have "P Q TS B C"
    proof cases
      assume Q1: "M = Y"
      have "X = Y"
      proof -
        have S1: "¬ Col P Q A"
          using TS_def assms(1) not_col_permutation_1 by blast
        have S3: "Col P Q X"
          using Col_perm P3 by blast
        have S4: "Col P Q Y"
          using Col_perm P4 by blast
        have S5: "Col A D X"
          by (simp add: P3 bet_col col_permutation_5)
        have "Col A D Y"
          by (metis Col_def P5 Q1 S5 Q0 between_equality between_trivial l6_16_1)
        thus ?thesis using S1 S3 S4 S5 P6 l6_21
          by blast
      qed
      hence "X Out A B"
        by (metis P1 P3 P4 TS_def l6_2)
      thus ?thesis using assms(1) P3 l9_5 by blast
    next
      assume Z1: "¬ M = Y"
      have "X = Y"
      proof -
        have S1: "¬ Col P Q A"
          using TS_def assms(1) not_col_permutation_1 by blast
        have S3: "Col P Q X"
          using Col_perm P3 by blast
        have S4: "Col P Q Y"
          using Col_perm P4 by blast
        have S5: "Col A D X"
          by (simp add: P3 bet_col col_permutation_5)
        have "Col A D Y"
          by (metis Col_def P4 Q0 P7 l6_16_1)
        thus ?thesis using S1 S3 S4 S5 P6 l6_21
          by blast
      qed
      hence Z3: "M ≠ X" using Z1 by blast
      have Z4: "P Q TS M C"
        by (meson Out_cases P4 P5 l9_5 Tarski_neutral_dimensionless_axioms Z1 assms(1) bet_out)
      have "X Out M B"
        using P5 Z3 bet_out by auto
      thus ?thesis using Z4 P3 l9_5 by blast
    qed
  }
  hence Z99: "Col A B D ⟶ P Q TS B C" by blast
  {
    assume Q0: "¬ Col A B D"
    have Q1: "P Q TS M C"
    proof -
      have S3: "Y Out A M"
      proof -
        have T1: "A ≠ Y"
          using Col_def P4 Q0 col_permutation_4 by blast
        have T2: "M ≠ Y"
        proof -
          {
            assume T3: "M = Y"
            have "Col B D X"
            proof -
              have U1: "B ≠ M"
                using P1 P4 T3 TS_def by blast
              have U2: "Col B M D"
                by (simp add: P4 T3 bet_col)
              have "Col B M X"
                by (simp add: P5 bet_col between_symmetry)
              thus ?thesis using U1 U2
                using col_transitivity_1 by blast
            qed
            have "False"
              by (metis NCol_cases P1 P3 TS_def ‹Col B D X› Q0 bet_col col_trivial_2 l6_21)
          }
          thus ?thesis by blast
        qed
        have "Bet Y A M ∨ Bet Y M A" using P5 by blast
        thus ?thesis using T1 T2
          by (simp add: Out_def)
      qed
      hence "X Out M B"
        by (metis P1 P3 P4 P5 TS_def bet_out l9_5)
      thus ?thesis using assms(1) S3 l9_5 P3 P4 by blast
    qed
    have "X Out M B"
      by (metis P3 P5 Q1 TS_def bet_out)
    hence "P Q TS B C" using Q1 P3 l9_5 by blast
  }
  hence "¬ Col A B D ⟶ P Q TS B C" by blast
  thus ?thesis using Z99 by blast
qed

lemma l9_9:
  assumes "P Q TS A B"
  shows "¬ P Q OS A B"
  using assms l9_8_2 not_two_sides_id by blast

lemma l9_9_bis:
  assumes "P Q OS A B"
  shows "¬ P Q TS A B"
  using assms l9_9 by blast

lemma one_side_chara:
  assumes "P Q OS A B"
  shows "∀ X. Col X P Q ⟶ ¬ Bet A X B"
proof -
  have "¬ Col A P Q ∧ ¬ Col B P Q"
    using OS_def TS_def assms by auto
  thus ?thesis
    using l9_9_bis TS_def assms by blast
qed

lemma l9_10:
  assumes "¬ Col A P Q"
  shows "∃ C. P Q TS A C"
  by (meson Col_perm assms mid_two_sides midpoint_existence symmetric_point_construction)

lemma one_side_reflexivity:
  assumes "¬ Col A P Q"
  shows "P Q OS A A"
  using assms l9_10 l9_8_1 by blast

lemma one_side_symmetry:
  assumes "P Q OS A B"
  shows "P Q OS B A"
  by (meson OS_def Tarski_neutral_dimensionless_axioms assms invert_two_sides)

lemma one_side_transitivity:
  assumes "P Q OS A B" and
    "P Q OS B C"
  shows "P Q OS A C"
  by (meson OS_def l9_8_2 Tarski_neutral_dimensionless_axioms assms(1) assms(2))

lemma l9_17:
  assumes "P Q OS A C" and
    "Bet A B C"
  shows "P Q OS A B"
proof cases
  assume "A = C"
  thus ?thesis
    using assms(1) assms(2) between_identity by blast
next
  assume P1: "¬ A = C"
  obtain D where P2: "P Q TS A D ∧ P Q TS C D"
    using OS_def assms(1) by blast
  hence P3: "P ≠ Q"
    using ts_distincts by blast
  obtain X where P4: "Col X P Q ∧ Bet A X D"
    using P2 TS_def by blast
  obtain Y where P5: "Col Y P Q ∧ Bet C Y D"
    using P2 TS_def by blast
  obtain T where P6: "Bet B T D ∧ Bet X T Y"
    using P4 P5 assms(2) l3_17 by blast
  have P7: "P Q TS A D"
    by (simp add: P2)
  have "P Q TS B D"
  proof -
    have Q1: "¬ Col B P Q"
      using assms(1) assms(2) one_side_chara by blast
    have Q2: "¬ Col D P Q"
      using P2 TS_def by blast
    obtain T0 where "Col T0 P Q ∧ Bet B T0 D"
    proof -
      assume a1: "⋀T0. Col T0 P Q ∧ Bet B T0 D ⟹ thesis"
      obtain pp :: 'p where
        f2: "Bet B pp D ∧ Bet X pp Y"
        using ‹⋀thesis. (⋀T. Bet B T D ∧ Bet X T Y ⟹ thesis) ⟹ thesis› by blast
      have "Col P Q Y"
        using Col_def P5 by blast
      hence "Y = X ∨ Col P Q pp"
        using f2 Col_def P4 colx by blast
      thus ?thesis
        using f2 a1 by (metis BetSEq BetS_def Col_def P4)
    qed
    thus ?thesis 
      using Q1 Q2 TS_def by blast
  qed
  thus ?thesis using P7
    using OS_def by blast
qed

lemma l9_18_R1:
  assumes "Col X Y P" and
    "Col A B P"
    and "X Y TS A B"
  shows "Bet A P B ∧ ¬ Col X Y A ∧ ¬ Col X Y B"
  by (meson TS_def assms(1) assms(2) assms(3) col_permutation_5 l9_5 not_col_permutation_1 
      not_out_bet not_two_sides_id)

lemma l9_18_R2:
  assumes "Col X Y P" and
    "Col A B P" and
    "Bet A P B" and
    "¬ Col X Y A" and
    "¬ Col X Y B"
  shows "X Y TS A B"
  using Col_perm TS_def assms(1) assms(3) assms(4) assms(5) by blast

lemma l9_18:
  assumes "Col X Y P" and
    "Col A B P"
  shows "X Y TS A B ⟷ (Bet A P B ∧ ¬ Col X Y A ∧ ¬ Col X Y B)"
  using l9_18_R1 l9_18_R2 assms(1) assms(2) by blast

lemma l9_19_R1:
  assumes "Col X Y P" and
    "Col A B P" and
    "X Y OS A B"
  shows "P Out A B ∧ ¬ Col X Y A"
  by (meson OS_def TS_def assms(1) assms(2) assms(3) col_permutation_5 not_col_permutation_1 
      not_out_bet one_side_chara)

lemma l9_19_R2:
  assumes "Col X Y P" and
    (*    "Col A B P" and *)
    "P Out A B" and
    "¬ Col X Y A"
  shows "X Y OS A B"
proof -
  obtain D where "X Y TS A D"
    using Col_perm assms(3) l9_10 by blast
  thus ?thesis
    using OS_def assms(1) assms(2) l9_5 not_col_permutation_1 by blast
qed

lemma l9_19:
  assumes "Col X Y P" and
    "Col A B P"
  shows "X Y OS A B ⟷ (P Out A B ∧ ¬ Col X Y A)"
  using l9_19_R1 l9_19_R2 assms(1) assms(2) by blast

lemma one_side_not_col123:
  assumes "A B OS X Y"
  shows "¬ Col A B X"
  using assms col_trivial_3 l9_19 by blast

lemma one_side_not_col124:
  assumes "A B OS X Y"
  shows "¬ Col A B Y"
  using assms one_side_not_col123 one_side_symmetry by blast

lemma col_two_sides:
  assumes "Col A B C" and
    "A ≠ C" and
    "A B TS P Q"
  shows "A C TS P Q"
  using assms(1) assms(2) assms(3) col_preserves_two_sides col_trivial_3 by blast

lemma col_one_side:
  assumes "Col A B C" and
    "A ≠ C" and
    "A B OS P Q"
  shows "A C OS P Q"
proof -
  obtain T where "A B TS P T ∧ A B TS Q T" using assms(1) assms(2) assms(3) OS_def by blast
  thus ?thesis
    using col_two_sides OS_def assms(1) assms(2) by blast
qed

lemma out_out_one_side:
  assumes "A B OS X Y" and
    "A Out Y Z"
  shows "A B OS X Z"
  by (meson Col_cases OS_def Tarski_neutral_dimensionless_axioms assms(1) assms(2) 
      col_trivial_3 l9_5)

lemma out_one_side:
  assumes "¬ Col A B X ∨ ¬ Col A B Y" and
    "A Out X Y"
  shows "A B OS X Y"
  using assms(1) assms(2) l6_6 not_col_permutation_2 one_side_reflexivity one_side_symmetry 
    out_out_one_side by blast

lemma bet__ts:
  assumes "A ≠ Y" and
    "¬ Col A B X" and
    "Bet X A Y"
  shows "A B TS X Y"
proof -
  have "¬ Col Y A B"
    using NCol_cases assms(1) assms(2) assms(3) bet_col col2__eq by blast
  thus ?thesis
    by (meson TS_def assms(2) assms(3) col_permutation_3 col_permutation_5 col_trivial_3)
qed

lemma bet_ts__ts:
  assumes "A B TS X Y" and
    "Bet X Y Z"
  shows "A B TS X Z"
proof -
  have "¬ Col Z A B"
    using assms(1) assms(2) bet_col between_equality_2 col_permutation_1 l9_18 by blast
  thus ?thesis
    using TS_def assms(1) assms(2) between_exchange4 by blast
qed

lemma bet_ts__os:
  assumes "A B TS X Y" and
    "Bet X Y Z"
  shows "A B OS Y Z"
  using OS_def assms(1) assms(2) bet_ts__ts l9_2 by blast

lemma l9_31 :
  assumes "A X OS Y Z" and
    "A Z OS Y X"
  shows "A Y TS X Z"
proof -
  have "A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z"
    using assms(1) assms(2) col_permutation_1 one_side_not_col123 one_side_not_col124 
      os_distincts by blast
  obtain Z' where "Bet Z A Z'" and "Cong A Z' Z A" 
    using segment_construction by blast
  have "Z' ≠ A" 
    by (metis ‹Cong A Z' Z A› assms(1) cong_diff_3 os_distincts)
  have "A X TS Y Z'" 
    by (metis l9_8_2 one_side_symmetry ‹Bet Z A Z'› ‹Z' ≠ A› assms(1) bet__ts 
        one_side_not_col124)
  have "¬ Col Y A X" 
    using ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› by auto
  obtain T where "Col A T X" and "Bet Y T Z'" 
    by (meson TS_def col_permutation_4 ‹A X TS Y Z'›)
  hence "T ≠ A"
  proof -
    have "¬ A Out Z Y" 
      using Col_cases ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› out_col by blast
    have "A ≠ Z'" 
      using ‹Z' ≠ A› by auto
    thus ?thesis 
      by (metis ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› ‹Bet Y T Z'› 
          ‹Bet Z A Z'› bet_col l6_21 not_col_distincts)
  qed
  have "Y A OS Z' T" 
    by (metis NCol_cases Out_def col3 col_trivial_3 out_one_side ‹A X TS Y Z'› ‹Bet Y T Z'› 
        ‹Col A T X› ‹T ≠ A› ‹¬ Col Y A X› ts_distincts)
  have "A Y TS Z' Z" 
    by (metis Bet_cases Col_cases ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› 
        ‹Bet Z A Z'› ‹Y A OS Z' T› bet__ts one_side_not_col123)
  {
    assume "Bet T A X"
    have "Z' Z OS Y T" 
      using BetSEq BetS_def TS_def l6_6 bet_col bet_out_1 col_trivial_3 
        colx not_col_permutation_3 not_col_permutation_4 out_one_side 
        ‹A Y TS Z' Z› ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› 
        ‹Bet Y T Z'› ‹Bet Z A Z'› ‹Col A T X› by metis
    hence "Z' Out T Y" 
      by (metis ‹Bet Y T Z'› bet_out_1 os_distincts)
    hence "A Z OS Y T" 
      using ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› ‹Bet Z A Z'› 
        bet_col invert_one_side l6_6 l9_19_R2 not_col_permutation_3 by blast
    have "A Z TS X T"
    proof -
      have "¬ Col X A Z" 
        using Col_cases ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› by blast
      have "¬ Col T A Z" 
        using ‹A Z OS Y T› col_permutation_1 one_side_not_col124 by blast
      have "∃ T0. Col T0 A Z ∧ Bet X T0 T"
      proof -
        have "Col A A Z" 
          by (simp add: col_trivial_1)
        moreover have "Bet X A T" 
          using Bet_cases ‹Bet T A X› by blast
        ultimately show ?thesis 
          by auto
      qed
      thus ?thesis 
        using TS_def ‹¬ Col T A Z› ‹¬ Col X A Z› by presburger
    qed
    have "A Y TS X Z" 
      by (meson l9_8_2 ‹A Z OS Y T› ‹A Z TS X T› assms(2) l9_9 one_side_symmetry)
  }
  moreover
  {
    assume "Bet A X T"
    hence "A Y OS Z' X" 
      using Bet_cases between_equality invert_one_side not_col_permutation_4 
        not_out_bet out_out_one_side 
      by (meson OS_def ‹A Y TS Z' Z› ‹Col A T X› ‹Y A OS Z' T› calculation)
    have "A Y TS X Z" 
      using ‹A Y OS Z' X› ‹A Y TS Z' Z› l9_8_2 by blast
  }
  moreover
  {
    assume "Bet X T A"
    hence "A Y OS T X" 
      using ‹A ≠ X ∧ A ≠ Z ∧ ¬ Col Y A X ∧ ¬ Col Z A X ∧ ¬ Col Y A Z› ‹T ≠ A› 
        bet_out_1 not_col_permutation_4 out_one_side by presburger
    hence "A Y TS X Z" 
      using ‹A Y TS Z' Z› ‹Y A OS Z' T› invert_two_sides l9_8_2 by blast
  }
  ultimately show ?thesis 
    using Bet_cases ‹Col A T X› third_point by blast
qed

lemma col123__nos:
  assumes "Col P Q A"
  shows "¬ P Q OS A B"
  using assms one_side_not_col123 by blast

lemma col124__nos:
  assumes "Col P Q B"
  shows "¬ P Q OS A B"
  using assms one_side_not_col124 by blast

lemma col2_os__os:
  assumes "C ≠ D" and
    "Col A B C" and
    "Col A B D" and
    "A B OS X Y"
  shows "C D OS X Y"
  by (metis assms(1) assms(2) assms(3) assms(4) col3 col_one_side col_trivial_3 
      invert_one_side os_distincts)

lemma os_out_os:
  assumes "Col A B P" and
    "A B OS C D" and
    "P Out C C'"
  shows "A B OS C' D"
  using OS_def assms(1) assms(2) assms(3) l9_5 not_col_permutation_1 by blast

lemma ts_ts_os:
  assumes "A B TS C D" and
    "C D TS A B"
  shows "A C OS B D"
proof -
  obtain T1 where P1: "Col T1 A B ∧ Bet C T1 D"
    using TS_def assms(1) by blast
  obtain T where P2: "Col T C D ∧ Bet A T B"
    using TS_def assms(2) by blast
  have P3: "T1 = T"
  proof -
    have "A ≠ B"
      using assms(2) ts_distincts by blast
    thus ?thesis
    proof -
      have "Col T1 D C"
        using Col_def P1 by blast
      hence f1: "∀p. (C = T1 ∨ Col C p T1) ∨ ¬ Col C T1 p"
        by (metis assms(1) col_transitivity_1 l6_16_1 ts_distincts)
      have f2: "¬ Col C A B"
        using TS_def assms(1) by presburger
      have f3: "(Bet B T1 A ∨ Bet T1 A B) ∨ Bet A B T1"
        using Col_def P1 by blast
      {
        assume "T1 ≠ B"
        hence "C ≠ T1 ∧ ¬ Col C T1 B ∨ (∃p. ¬ Col p T1 B ∧ Col p T1 T) ∨ T ≠ A ∧ T ≠ B"
          using f3 f2 by (metis (no_types) Col_def col_transitivity_1 l6_16_1)
        hence "T ≠ A ∧ T ≠ B ∨ C ≠ T1 ∧ ¬ Col C T1 T ∨ T1 = T"
          using f3 by (meson Col_def l6_16_1)
      }
      moreover
      {
        assume "T ≠ A ∧ T ≠ B"
        hence "C ≠ T1 ∧ ¬ Col C T1 T ∨ T1 = T"
          using f2 by (metis (no_types) Col_def P1 P2 ‹A ≠ B› col_transitivity_1 l6_16_1)
      }
      ultimately have "C ≠ T1 ∧ ¬ Col C T1 T ∨ T1 = T"
        using f2 f1 assms(1) ts_distincts by blast
      thus ?thesis
        by (metis (no_types) Col_def P1 P2 assms(1) l6_16_1 ts_distincts)
    qed
  qed
  have P4: "A C OS T B"
    by (metis Col_cases P2 TS_def assms(1) assms(2) bet_out out_one_side)
  hence "C A OS T D"
    by (metis Col_cases P1 TS_def P3 assms(2) bet_out os_distincts out_one_side)
  thus ?thesis
    by (meson P4 invert_one_side one_side_symmetry Tarski_neutral_dimensionless_axioms 
        one_side_transitivity)
qed

lemma col_one_side_out:
  assumes "Col A X Y" and
    "A B OS X Y"
  shows "A Out X Y"
  by (meson assms(1) assms(2) l6_4_2 not_col_distincts not_col_permutation_4 one_side_chara)

lemma col_two_sides_bet:
  assumes "Col A X Y" and
    "A B TS X Y"
  shows "Bet X A Y"
  using Col_cases assms(1) assms(2) l9_8_1 l9_9 or_bet_out out_out_one_side by blast

lemma os_ts1324__os:
  assumes "A X OS Y Z" and
    "A Y TS X Z"
  shows "A Z OS X Y"
proof -
  obtain P where P1: "Col P A Y ∧ Bet X P Z"
    using TS_def assms(2) by blast
  have P2: "A Z OS X P"
    by (metis Col_cases P1 TS_def assms(1) assms(2) bet_col bet_out_1 col124__nos 
        col_trivial_2 l6_6 l9_19)
  have "A Z OS P Y"
  proof -
    have "¬ Col A Z P ∨ ¬ Col A Z Y"
      using P2 col124__nos by blast
    moreover have "A Out P Y"
    proof -
      have "X A OS P Z"
        by (metis Col_cases P1 P2 assms(1) bet_out col123__nos out_one_side)
      hence "A X OS P Y"
        by (meson invert_one_side one_side_symmetry Tarski_neutral_dimensionless_axioms 
            assms(1) one_side_transitivity)
      thus ?thesis
        using P1 col_one_side_out not_col_permutation_4 by blast
    qed
    ultimately show ?thesis
      by (simp add: out_one_side)
  qed
  thus ?thesis
    using P2 one_side_transitivity by blast
qed

lemma ts2__ex_bet2:
  assumes "A C TS B D" and
    "B D TS A C"
  shows "∃ X. Bet A X C ∧ Bet B X D"
  by (metis TS_def assms(1) assms(2) bet_col col_permutation_5 l9_18_R1 not_col_permutation_2)

lemma out_one_side_1:
  assumes "¬ Col A B C" and
    "Col A B X" and
    "X Out C D"
  shows "A B OS C D"
  using assms(1) assms(2) assms(3) not_col_permutation_2 one_side_reflexivity 
    one_side_symmetry os_out_os by blast

lemma out_two_sides_two_sides:
  assumes (*"A ≠ PX" and *)
    "Col A B PX" and
    "PX Out X P" and
    "A B TS P Y"
  shows "A B TS X Y"
  using assms(1) assms(2) assms(3) l6_6 l9_5 not_col_permutation_1 by blast

lemma l8_21_bis:
  assumes "X ≠ Y" and
    "¬ Col C A B"
  shows "∃ P. Cong A P X Y ∧ A B Perp P A ∧ A B TS C P"
proof -
  have "A ≠ B"
    using assms(2) not_col_distincts by blast
  hence "∃ P T. A B Perp P A ∧ Col A B T ∧ Bet C T P"
    using l8_21 by auto
  then obtain P T where "A B Perp P A" and "Col A B T" and "Bet C T P" by blast
  have "A B TS C P"
  proof -
    have "¬ Col P A B"
      using col_permutation_1 perp_not_col ‹A B Perp P A› by blast
    thus ?thesis 
      using Col_cases TS_def ‹Bet C T P› ‹Col A B T› assms(2) by blast
  qed
  have "P ≠ A" 
    using ‹A B Perp P A› perp_distinct by auto
  obtain P' where "(Bet A P P' ∨ Bet A P' P)" and "Cong A P' X Y"
    using segment_construction_2 ‹P ≠ A› by blast
  have "A B Perp P' A" 
    by (metis Bet_cases Col_def cong_identity perp_col1 ‹A B Perp P A› 
        ‹Bet A P P' ∨ Bet A P' P› ‹Cong A P' X Y› assms(1) cong_symmetry perp_comm)
  have "¬ Col P' A B" 
    using ‹A B Perp P' A› not_col_permutation_2 perp_not_col by blast
  hence "A B OS P P'" 
    using Out_def ‹A B Perp P A› ‹A B Perp P' A› ‹Bet A P P' ∨ Bet A P' P› 
      out_one_side perp_not_col perp_not_eq_2 by presburger
  hence "A B TS C P'" 
    using ‹A B TS C P› l9_2 l9_8_2 by blast
  thus ?thesis 
    using ‹A B Perp P' A› ‹Cong A P' X Y› by blast
qed

lemma ts__ncol:
  assumes "A B TS X Y"
  shows  "¬ Col A X Y ∨ ¬ Col B X Y"
  by (metis TS_def assms col_permutation_1 col_transitivity_2 ts_distincts)

lemma one_or_two_sides_aux:
  assumes "¬ Col C A B" and
    "¬ Col D A B" and
    "Col A C X"
    and "Col B D X"
  shows "A B TS C D ∨ A B OS C D"
proof -
  have P1: "A ≠ X"
    using assms(2) assms(4) col_permutation_2 by blast
  have P2: "B ≠ X"
    using assms(1) assms(3) col_permutation_4 by blast
  have P3: "¬ Col X A B"
    using P1 assms(1) assms(3) col_permutation_5 col_transitivity_1 not_col_permutation_4 
    by blast
  {
    assume Q0: "Bet A C X ∧ Bet B D X"
    hence Q1: "A B OS C X"
      using assms(1) bet_out not_col_distincts not_col_permutation_1 out_one_side by blast
    hence "A B OS X D"
      by (metis Q0 assms(2) assms(4) bet_out_1 col_permutation_2 col_permutation_3 
          invert_one_side l6_4_2 not_bet_and_out not_col_distincts out_one_side)
    hence "A B OS C D"
      using Q1 one_side_transitivity by blast
  }
  hence P4: "Bet A C X ∧ Bet B D X ⟶ A B OS C D" by blast
  {
    assume "Bet A C X ∧ Bet D X B"
    hence "A B OS C D" 
      by (metis P2 assms(1) bet_out bet_out_1 not_col_distincts one_side_reflexivity 
          one_side_symmetry os_out_os)
  }
  hence P5: "Bet A C X ∧ Bet D X B ⟶ A B OS C D " by blast
  {
    assume Q0: "Bet A C X ∧ Bet X B D"
    have Q1: "A B TS X D"
      using P3 Q0 TS_def assms(2) col_trivial_3 by blast
    have "A B OS X C"
      using Q0 assms(1) bet_out not_col_distincts one_side_reflexivity one_side_symmetry 
        out_out_one_side by blast
    hence "A B TS C D"
      using Q1 l9_8_2 by blast
  }
  hence P6: "Bet A C X ∧ Bet X B D ⟶ A B TS C D" by blast
  {
    assume Q1: "Bet C X A ∧ Bet B D X"
    hence Q2: "A B OS C X"
      using P1 assms(1) assms(3) between_equality_2 l6_4_2 not_col_permutation_1 
        not_col_permutation_4 out_one_side by blast
    have "A B OS X D"
      using Q1 assms(2) bet_out not_col_distincts one_side_reflexivity os_out_os by blast
    hence "A B OS C D" using Q2
      using one_side_transitivity by blast
  }
  hence P7: "Bet C X A ∧ Bet B D X ⟶ A B OS C D" by blast
  {
    assume "Bet C X A ∧ Bet D X B"
    hence "A B OS C D" 
      by (metis Out_def P1 P2 assms(1) bet_out between_symmetry col2__eq invert_one_side 
          l9_19_R2 not_col_distincts out_out_one_side)
  }
  hence P8: "Bet C X A ∧ Bet D X B ⟶ A B OS C D" by blast
  {
    assume Q1: "Bet C X A ∧ Bet X B D"
    have Q2: "A B TS X D"
      by (metis P3 Q1 assms(2) bet__ts invert_two_sides not_col_distincts not_col_permutation_3)
    have Q3: "A B OS X C"
      using P1 Q1 assms(1) bet_out_1 not_col_permutation_1 out_one_side by auto
    hence "A B TS C D"
      using Q2 l9_8_2 by blast
  }
  hence P9: "Bet C X A ∧ Bet X B D ⟶ A B TS C D" by blast
  {
    assume Q0: "Bet X A C ∧ Bet B D X"
    have Q1: "A B TS X C"
      by (metis P3 Q0 assms(1) bet__ts col_permutation_2 not_col_distincts)
    have "A B OS X D"
      by (metis NCol_cases Q0 out_one_side assms(2) assms(4) bet_out_1 invert_one_side 
          l6_4_1 not_col_distincts not_out_bet)
    hence "A B TS C D"
      using Q1 l9_2 l9_8_2 by blast
  }
  hence P10: "Bet X A C ∧ Bet B D X ⟶ A B TS C D" by blast
  {
    assume Q0: "Bet X A C ∧ Bet D X B"
    have Q1: "A B TS X C"
      by (metis NCol_cases P3 Q0 assms(1) bet__ts not_col_distincts)
    have "A B OS X D"
      by (metis P2 P3 Q0 bet_out_1 col_permutation_3 invert_one_side out_one_side)
    hence "A B TS C D"
      using Q1 l9_2 l9_8_2 by blast
  }
  hence P11: "Bet X A C ∧ Bet D X B ⟶ A B TS C D"
    by blast
  {
    assume Q0: "Bet X A C ∧ Bet X B D"
    hence Q1: "A B TS C X"
      by (simp add: P1 Q0 assms(1) bet__ts between_symmetry not_col_permutation_1)
    have "A B TS D X"
      by (simp add: P2 Q0 assms(2) bet__ts between_symmetry invert_two_sides 
          not_col_permutation_3)
    hence "A B OS C D"
      using Q1 l9_8_1 by blast
  }
  hence P12: "Bet X A C ∧ Bet X B D ⟶ A B OS C D" by blast
  thus ?thesis using P4 P5 P6 P7 P8 P9 P10 P11
    using Col_def assms(3) assms(4) by auto
qed

lemma cop__one_or_two_sides:
  assumes "Coplanar A B C D" and
    "¬ Col C A B" and
    "¬ Col D A B"
  shows "A B TS C D ∨ A B OS C D"
proof -
  obtain X where P1: "Col A B X ∧ Col C D X ∨ Col A C X ∧ Col B D X ∨ Col A D X ∧ Col B C X"
    using Coplanar_def assms(1) by auto
  have P2: "Col A B X ∧ Col C D X ⟶ A B TS C D ∨ A B OS C D"
    by (metis TS_def l9_19_R2 assms(2) assms(3) not_col_permutation_3 not_col_permutation_5 
        not_out_bet)
  have P3: "Col A C X ∧ Col B D X ⟶  A B TS C D ∨ A B OS C D"
    using assms(2) assms(3) one_or_two_sides_aux by blast
  have "Col A D X ∧ Col B C X ⟶  A B TS C D ∨ A B OS C D"
    using assms(2) assms(3) l9_2 one_or_two_sides_aux one_side_symmetry by blast
  thus ?thesis
    using P1 P2 P3 by blast
qed

lemma os__coplanar:
  assumes "A B OS C D"
  shows "Coplanar A B C D"
proof -
  have P1: "¬ Col A B C"
    using assms one_side_not_col123 by blast
  obtain C' where P2: "Bet C B C' ∧ Cong B C' B C"
    using segment_construction by presburger
  have P3: "A B TS D C'"
    by (metis Cong_perm OS_def P2 TS_def assms bet__ts bet_cong_eq invert_one_side l9_10 
        l9_8_2 one_side_not_col123 ts_distincts)
  obtain T where P4: "Col T A B ∧ Bet D T C'"
    using P3 TS_def by blast
  have P5: "C' ≠ T"
    using P3 P4 TS_def by blast
  have P6: "Col T B C ⟶ Coplanar A B C D"
    by (metis Col_def Coplanar_def P2 P4 P5 col_trivial_2 l6_16_1)
  {
    assume Q0: "¬ Col T B C"
    {
      assume R0: "Bet T B A"
      have S1: "B C TS T A"
        by (metis P1 Q0 R0 bet__ts col_permutation_2 not_col_distincts)
      have "C' Out T D"
        using P4 P5 bet_out_1 by auto
      hence "B C OS T D"
        using P2 Q0 bet_col invert_one_side not_col_permutation_3 out_one_side_1 by blast
      hence R1: "B C TS D A"
        using S1 l9_8_2 by blast
      hence "Coplanar A B C D"
        using ncoplanar_perm_9 ts__coplanar by blast
    }
    hence Q1: "Bet T B A ⟶ Coplanar A B C D" by blast
    {
      assume R0: "¬ Bet T B A"
      {
        have R2: "B C OS D T"
        proof -
          have S1: "¬ Col B C D"
            by (metis Col_perm P2 P3 P4 Q0 bet_col colx ts_distincts)
          have S2: "Col B C C'"
            by (simp add: P2 bet_col col_permutation_4)
          have S3: "C' Out D T"
            using P4 P5 bet_out_1 l6_6 by auto
          thus ?thesis
            using S1 S2 out_one_side_1 by blast
        qed
        have R3: "B C OS T A"
          using P4 Q0 R0 col_permutation_2 col_permutation_5 not_bet_out out_one_side by blast
      }
      hence R1: "B C OS D A"
        by (metis P2 P4 Q0 bet_col bet_out_1 col_permutation_2 col_permutation_5 os_out_os)
      hence "Coplanar A B C D"
        by (simp add: R1 assms coplanar_perm_19 invert_one_side l9_31 one_side_symmetry 
            ts__coplanar)
    }
    hence "¬ Bet T B A ⟶ Coplanar A B C D" by blast
    hence "Coplanar A B C D" using Q1 by blast
  }
  hence "¬ Col T B C ⟶ Coplanar A B C D" by blast
  thus ?thesis using P6 by blast
qed

lemma coplanar_trans_1:
  assumes "¬ Col P Q R" and
    "Coplanar P Q R A" and
    "Coplanar P Q R B"
  shows "Coplanar Q R A B"
proof -
  have P1: "Col Q R A ⟶ Coplanar Q R A B"
    by (simp add: col__coplanar)
  {
    assume T1: "¬ Col Q R A"
    {
      assume T2: "¬ Col Q R B"
      {
        have "Col Q A B ⟶ Coplanar Q R A B"
          using ncop__ncols by blast
        {
          assume S1: "¬ Col Q A B"
          have U1: "Q R TS P A ∨ Q R OS P A"
            by (simp add: T1 assms(1) assms(2) cop__one_or_two_sides coplanar_perm_8 
                not_col_permutation_2)
          have U2: "Q R TS P B ∨ Q R OS P B"
            using T2 assms(1) assms(3) col_permutation_1 cop__one_or_two_sides 
              coplanar_perm_8 by blast
          have W1: "Q R TS P A ∧ Q R OS P A ⟶ Q R TS A B ∨ Q R OS A B"
            using l9_9 by blast
          have W2: "Q R TS P A ∧ Q R OS P B ⟶ Q R TS A B ∨ Q R OS A B"
            using l9_2 l9_8_2 by blast
          have W3: "Q R TS P B ∧ Q R OS P A ⟶ Q R TS A B ∨ Q R OS A B"
            using l9_8_2 by blast
          have "Q R TS P B ∧ Q R OS P B ⟶ Q R TS A B ∨ Q R OS A B"
            using l9_9 by blast
          hence S2: "Q R TS A B ∨ Q R OS A B" using U1 U2 W1 W2 W3
            using OS_def l9_2 one_side_transitivity by blast
          have "Coplanar Q R A B"
            using S2 os__coplanar ts__coplanar by blast
        }
        hence "¬ Col Q A B ⟶ Coplanar Q R A B" by blast
      }
      hence "Coplanar Q R A B"
        using ncop__ncols by blast
    }
    hence "¬ Col Q R B ⟶ Coplanar Q R A B"
      by blast
  }
  hence "¬ Col Q R A ⟶ Coplanar Q R A B"
    using ncop__ncols by blast
  thus ?thesis using P1 by blast
qed

lemma col_cop__cop:
  assumes "Coplanar A B C D" and
    "C ≠ D" and
    "Col C D E"
  shows "Coplanar A B C E"
proof -
  have "Col D A C ⟶ Coplanar A B C E"
    by (meson assms(2) assms(3) col_permutation_1 l6_16_1 ncop__ncols)
  moreover
  {
    assume "¬ Col D A C"
    hence "Coplanar A C B E"
      by (meson assms(1) assms(3) col__coplanar coplanar_trans_1 ncoplanar_perm_11 
          ncoplanar_perm_13)
    hence "Coplanar A B C E"
      using ncoplanar_perm_2 by blast
  }
  ultimately show ?thesis
    by blast
qed

lemma bet_cop__cop:
  assumes "Coplanar A B C E" and
    "Bet C D E"
  shows "Coplanar A B C D"
  by (metis NCol_perm col_cop__cop assms(1) assms(2) bet_col bet_neq12__neq)

lemma col2_cop__cop:
  assumes "Coplanar A B C D" and
    "C ≠ D" and
    "Col C D E" and
    "Col C D F"
  shows "Coplanar A B E F"
proof cases
  assume "C = E"
  thus ?thesis
    using assms(1) assms(2) assms(4) col_cop__cop by blast
next
  assume "C ≠ E"
  thus ?thesis
    by (metis assms(1) assms(2) assms(3) assms(4) col_cop__cop col_transitivity_1 
        ncoplanar_perm_1 not_col_permutation_4)
qed

lemma col_cop2__cop:
  assumes "U ≠ V" and
    "Coplanar A B C U" and
    "Coplanar A B C V" and
    "Col U V P"
  shows "Coplanar A B C P"
proof cases
  assume "Col A B C"
  thus ?thesis
    using ncop__ncol by blast
next
  assume "¬ Col A B C"
  {
    fix A0 B0 C0
    assume "¬ Col A0 B0 C0" and "¬ Col U A0 B0" and "Coplanar A0 B0 C0 U" and 
      "Coplanar A0 B0 C0 V" and "¬ Col A0 B0 C0"
    have "Coplanar U A0 B0 P" 
      by (meson col_trivial_3 ‹Coplanar A0 B0 C0 U› ‹Coplanar A0 B0 C0 V› ‹¬ Col A0 B0 C0› 
          assms(1) assms(4) col2_cop__cop coplanar_trans_1 ncoplanar_perm_8 
          not_col_permutation_1)
    hence "Coplanar A0 B0 C0 P" 
      using ‹Coplanar A0 B0 C0 U›  ‹¬ Col U A0 B0› coplanar_perm_18 coplanar_trans_1 by blast
  }
  moreover
  {
    assume "Col U A B" and "Col U A C"
    hence "Coplanar A B C P" 
      by (metis ‹¬ Col A B C› assms(1) assms(3) assms(4) col_cop__cop 
          col_transitivity_2 coplanar_perm_14)
  }
  moreover
  {
    assume "Col U A B" and "¬ Col U A C"
    hence "Coplanar A B C P" 
      using calculation(1) ‹¬ Col A B C› assms(2) assms(3) coplanar_perm_2 
        not_col_permutation_5 by blast
  }
  moreover
  {
    assume "¬ Col U A B" and "Col U A C"
    hence "Coplanar A B C P" 
      using ‹¬ Col A B C› assms(2) assms(3) calculation(1) by blast
  }
  moreover
  {
    assume "¬ Col U A B" and "¬ Col U A C"
    hence "Coplanar A B C P" 
      using ‹¬ Col A B C› assms(2) assms(3) calculation(1) by blast
  }
  ultimately show ?thesis 
    by blast
qed

lemma bet_cop2__cop:
  assumes "Coplanar A B C U" and
    "Coplanar A B C W" and
    "Bet U V W"
  shows "Coplanar A B C V"
proof -
  have "Col U V W"
    using assms(3) bet_col by blast
  hence "Col U W V"
    by (meson not_col_permutation_5)
  thus ?thesis
    using assms(1) assms(2) assms(3) bet_neq23__neq col_cop2__cop by blast
qed

lemma coplanar_pseudo_trans_lem1:
  assumes "¬ Col P Q R" and
    "Coplanar P Q R A" and
    "Coplanar P Q R B" and
    "Coplanar P Q R C"
  shows "Coplanar A B C R" 
proof cases
  assume "Col R Q A"
  have "Coplanar B C R Q" 
    using assms(1) assms(3) assms(4) coplanar_perm_17 coplanar_trans_1 by blast
  thus ?thesis
    using ‹Col R Q A› assms(1) col_cop__cop coplanar_perm_2 coplanar_perm_20 
      not_col_distincts by blast
next
  assume "¬ Col R Q A"
  thus ?thesis
    by (meson assms(1) assms(2) assms(3) assms(4) coplanar_trans_1 ncoplanar_perm_18 
        not_col_permutation_4)
qed

lemma coplanar_pseudo_trans:
  assumes "¬ Col P Q R" and
    "Coplanar P Q R A" and
    "Coplanar P Q R B" and
    "Coplanar P Q R C" and
    "Coplanar P Q R D"
  shows "Coplanar A B C D"
proof cases
  assume "Col P Q D"
  moreover have "P ≠ Q"
    using assms(1) col_trivial_1 by blast
  moreover have "Coplanar A B C Q" 
    using coplanar_pseudo_trans_lem1 
    by (meson assms(1) assms(2) assms(3) assms(4) col_permutation_5 coplanar_perm_2)
  moreover have "Coplanar A B C P" 
  proof -
    have "¬ Col Q R P"
      using Col_cases assms(1) by blast
    moreover have "Coplanar Q R P A"
      using assms(2) ncoplanar_perm_12 by blast
    moreover have "Coplanar Q R P B"
      using assms(3) ncoplanar_perm_12 by blast
    moreover have "Coplanar Q R P C"
      using assms(4) ncoplanar_perm_12 by blast
    ultimately show ?thesis
      using coplanar_pseudo_trans_lem1 by blast
  qed
  ultimately show ?thesis
    using coplanar_pseudo_trans_lem1 col_cop2__cop by blast
next
  assume "¬ Col P Q D"
  moreover have "Coplanar P Q D A"
    using NCol_cases assms(1) assms(2) assms(5) coplanar_trans_1 ncoplanar_perm_8 by blast
  moreover have "Coplanar P Q D B"
    using assms(1) assms(3) assms(5) col_permutation_1 coplanar_perm_12 
      coplanar_trans_1 by blast
  moreover have "Coplanar P Q D C"
    by (meson assms(1) assms(4) assms(5) coplanar_perm_7 coplanar_trans_1 
        ncoplanar_perm_14 not_col_permutation_3)
  ultimately show ?thesis 
    using coplanar_pseudo_trans_lem1 by blast
qed

lemma l9_30:
  assumes "¬ Coplanar A B C P" and
    "¬ Col D E F" and
    "Coplanar D E F P" and
    "Coplanar A B C X" and
    "Coplanar A B C Y" and
    "Coplanar A B C Z" and
    "Coplanar D E F X" and
    "Coplanar D E F Y" and
    "Coplanar D E F Z"
  shows "Col X Y Z"
proof -
  {
    assume P1: "¬ Col X Y Z"
    have P2: "¬ Col A B C"
      using assms(1) col__coplanar by blast
    have "Coplanar A B C P"
    proof -
      have Q2: "Coplanar X Y Z A" 
        by (meson P2 col_trivial_3 assms(4) assms(5) assms(6) coplanar_pseudo_trans ncop__ncols)
      have Q3: "Coplanar X Y Z B"
        using P2 assms(4) assms(5) assms(6) col_trivial_3 coplanar_pseudo_trans 
          ncop__ncols by blast
      have Q4: "Coplanar X Y Z C"
        using P2 assms(4) assms(5) assms(6) col_trivial_2 coplanar_pseudo_trans 
          ncop__ncols by blast
      have "Coplanar X Y Z P"
        using assms(2) assms(3) assms(7) assms(8) assms(9) coplanar_pseudo_trans by blast
      thus ?thesis using P1 Q2 Q3 Q4
        using assms(2) assms(3) assms(7) assms(8) assms(9) coplanar_pseudo_trans by blast
    qed
    hence "False" using assms(1) by blast
  }
  thus ?thesis by blast
qed

lemma cop_per2__col:
  assumes "Coplanar A X Y Z" and
    "A ≠ Z" and
    "Per X Z A" and
    "Per Y Z A"
  shows "Col X Y Z"
proof cases
  assume "X = Y ∨ X = Z ∨ Y = Z"
  thus ?thesis
    using not_col_distincts by blast
next
  assume "¬ (X = Y ∨ X = Z ∨ Y = Z)"
  obtain B where "Cong X A X B" and "Z Midpoint A B" and "Cong Y A Y B"
    using Per_def assms(3) assms(4) per_double_cong by blast
  have "X ≠ Y" 
    using ‹¬ (X = Y ∨ X = Z ∨ Y = Z)› by blast
  have "X ≠ Z" 
    using ‹¬ (X = Y ∨ X = Z ∨ Y = Z)› by blast
  have "Y ≠ Z" 
    using ‹¬ (X = Y ∨ X = Z ∨ Y = Z)› by blast
  obtain I where "Col A X I ∧ Col Y Z I ∨ Col A Y I ∧ Col X Z I ∨ Col A Z I ∧ Col X Y I"
    using Coplanar_def assms(1) by auto
  moreover
  {
    assume "Col A X I" and "Col Y Z I"
    have "Col X Y Z" 
    proof (cases "X = I")
      assume "X = I"
      thus ?thesis
        using Col_cases ‹Col Y Z I› by blast
    next
      assume "X ≠ I"
      have "Col A X I ∧ Col Y Z I ⟹ Col X Y Z"
        by (metis (full_types) ‹¬ (X = Y ∨ X = Z ∨ Y = Z)› assms(2,3,4) col_per2__per l8_3 l8_8
            not_col_permutation_2 not_col_permutation_4) 
      moreover have "Col A Y I ∧ Col X Z I ⟹ Col X Y Z"
        by (simp add: ‹Col A X I› ‹Col Y Z I› calculation) 
      moreover have "Col A Z I ∧ Col X Y I ⟹ Col X Y Z"
        by (simp add: ‹Col A X I› ‹Col Y Z I› calculation(1))
      ultimately show "Col X Y Z"
        using ‹Col A X I› ‹Col Y Z I› by blast 
    qed
  }
  moreover have "Col A Y I ∧ Col X Z I ⟶ Col X Y Z"
  proof cases
    assume "X = I"
    thus ?thesis
      by (metis Col_cases ‹Cong X A X B› ‹Cong Y A Y B› ‹Z Midpoint A B› 
          l4_18 midpoint_distinct_3)
  next
    assume "X ≠ I"
    thus ?thesis 
      by (metis Col_cases midpoint_bet per_double_cong ‹Cong Y A Y B› ‹Z Midpoint A B› 
          assms(2) assms(3) between_equality between_trivial col_trivial_3 l4_18 l8_3)
  qed
  moreover 
  {
    assume "Col A Z I" and "Col X Y I"
    hence "Z = I ⟶ Col X Y Z" 
      by simp 
    moreover
    {
      assume "Z ≠ I" 
      have "Cong I A I B" 
        using l4_17 [where ?A = "X" and ?B ="Y"]
          ‹X ≠ Y› ‹Col X Y I› ‹Cong X A X B› ‹Cong Y A Y B› by auto
      have "(Col A I B ∧ Cong I A I B) ⟶ (A = B ∨ I Midpoint A B)" 
        using l7_20_bis by blast
      moreover have "A = B ⟶ Col X Y Z" 
        using ‹Z Midpoint A B› assms(2) l7_3 by auto
      moreover have "I Midpoint A B ⟶ ?thesis" 
        using ‹Z Midpoint A B› ‹Z ≠ I› l7_17 by blast
      ultimately have "Col X Y Z" 
        using Col_cases Per_def ‹Col A Z I› ‹Cong I A I B› ‹Z Midpoint A B› 
          assms(2) l8_9 by blast
    }
    ultimately have "Col X Y Z" 
      by blast
  }
  ultimately show ?thesis
    by blast
qed

lemma cop_perp2__col:
  assumes "Coplanar A B Y Z" and
    "X Y Perp A B" and
    "X Z Perp A B"
  shows "Col X Y Z"
proof cases
  assume P1: "Col A B X"
  {
    assume Q0: "X = A"
    hence Q1: "X ≠ B"
      using assms(3) perp_not_eq_2 by blast
    have Q2: "Coplanar B Y Z X"
      by (simp add: Q0 assms(1) coplanar_perm_9)
    have Q3: "Per Y X B"
      using Q0 assms(2) perp_per_2 by blast
    have "Per Z X B"
      using Q0 assms(3) perp_per_2 by blast
    hence "Col X Y Z"
      using Q1 Q2 Q3 cop_per2__col not_col_permutation_1 by blast
  }
  hence P2: "X = A ⟶ Col X Y Z" by blast
  {
    assume Q0: "X ≠ A"
    have Q1: "A X Perp X Y"
      by (metis P1 Perp_perm Q0 assms(2) perp_col1)
    have Q2: "A X Perp X Z"
      by (metis P1 Perp_perm Q0 assms(3) perp_col1)
    have Q3: "Coplanar A Y Z X" 
      by (metis P1 assms(1) assms(2) col_cop2__cop coplanar_perm_3 coplanar_trivial 
          perp_distinct)
    have Q4: "Per Y X A"
      using Perp_perm Q1 perp_per_2 by blast
    have "Per Z X A"
      using P1 Q0 assms(3) perp_col1 perp_per_1 by auto
    hence "Col X Y Z"
      using Q0 Q3 Q4 cop_per2__col not_col_permutation_1 by blast
  }
  hence "X ≠ A ⟶ Col X Y Z" by blast
  thus ?thesis
    using P2 by blast
next
  assume P1: "¬ Col A B X"
  obtain Y0 where P2: "Y0 PerpAt X Y A B"
    using Perp_def assms(2) by blast
  obtain Z0 where P3: "Z0 PerpAt X Z A B"
    using Perp_def assms(3) by auto
  have P4: "X Y0 Perp A B"
    by (metis P1 P2 assms(2) perp_col perp_in_col)
  have P5: "X Z0 Perp A B"
    by (metis P1 P3 assms(3) perp_col perp_in_col)
  have P6: "Y0 = Z0"
    by (meson P1 P2 P3 P4 P5 Perp_perm l8_18_uniqueness perp_in_col)
  have P7: "X ≠ Y0"
    using P4 perp_not_eq_1 by blast
  have P8: "Col X Y0 Y"
    using P2 col_permutation_5 perp_in_col by blast
  have "Col X Y0 Z"
    using P3 P6 col_permutation_5 perp_in_col by blast
  thus ?thesis
    using P7 P8 col_transitivity_1 by blast
qed

lemma two_sides_dec:
  shows "A B TS C D ∨ ¬ A B TS C D"
  by simp

lemma cop_nts__os:
  assumes "Coplanar A B C D" and
    "¬ Col C A B" and
    "¬ Col D A B" and
    "¬ A B TS C D"
  shows "A B OS C D"
  using assms(1) assms(2) assms(3) assms(4) cop__one_or_two_sides by blast

lemma cop_nos__ts:
  assumes "Coplanar A B C D" and
    "¬ Col C A B" and
    "¬ Col D A B" and
    "¬ A B OS C D"
  shows "A B TS C D"
  using assms(1) assms(2) assms(3) assms(4) cop_nts__os by blast

lemma one_side_dec:
  "A B OS C D ∨ ¬ A B OS C D"
  by simp

lemma cop_dec:
  "Coplanar A B C D ∨ ¬ Coplanar A B C D"
  by simp

lemma ex_diff_cop:
  "∃ E. Coplanar A B C E ∧ D ≠ E"
  by (metis col_trivial_2 diff_col_ex ncop__ncols)

lemma ex_ncol_cop:
  assumes "D ≠ E"
  shows "∃ F. Coplanar A B C F ∧ ¬ Col D E F"
proof cases
  assume "Col A B C"
  thus ?thesis
    using assms ncop__ncols not_col_exists by blast
next
  assume P1: "¬ Col A B C"
  thus ?thesis
  proof -
    have P2: "(Col D E A ∧ Col D E B) ⟶ (∃ F. Coplanar A B C F ∧ ¬ Col D E F)"
      by (meson P1 assms col3 col_trivial_2 ncop__ncols)
    have P3: "(¬Col D E A ∧ Col D E B) ⟶ (∃ F. Coplanar A B C F ∧ ¬ Col D E F)"
      using col_trivial_3 ncop__ncols by blast
    have P4: "(Col D E A ∧ ¬Col D E B) ⟶ (∃ F. Coplanar A B C F ∧ ¬ Col D E F)"
      using col_trivial_2 ncop__ncols by blast
    have "(¬Col D E A ∧ ¬Col D E B) ⟶ (∃ F. Coplanar A B C F ∧ ¬ Col D E F)"
      using col_trivial_3 ncop__ncols by blast
    thus ?thesis using P2 P3 P4 by blast
  qed
qed

lemma ex_ncol_cop2:
  "∃ E F. (Coplanar A B C E ∧ Coplanar A B C F ∧ ¬ Col D E F)"
proof -
  have "Coplanar A B C A" 
    by (simp add: coplanar_perm_3 coplanar_trivial)
  have "Coplanar A B C C" 
    using col_trivial_2 ncop__ncols by blast
  have "∃p. A ≠ p"
    by (meson col_trivial_3 diff_col_ex3)
  moreover
  { 
    assume "B ≠ A"
    hence "D = B ⟶ (∃p. ¬ Col D p A ∧ Coplanar A B C p)" 
      by (metis Col_cases ‹Coplanar A B C C› ncop__ncols not_col_exists)
    hence "D = B ⟶ (∃p pa. Coplanar A B C p ∧ Coplanar A B C pa ∧ ¬ Col D p pa)" 
      using ‹Coplanar A B C A› by blast
  }
  moreover
  { 
    assume "D ≠ B"
    moreover
    { 
      assume "∃p. D ≠ B ∧ ¬ Coplanar A B C p"
      hence "D ≠ B ∧ ¬ Col A B C"
        using ncop__ncols by blast
      hence "∃p. ¬ Col D p B ∧ Coplanar A B C p" 
        by (metis Col_cases ‹Coplanar A B C A› ‹Coplanar A B C C› col2__eq)
    }
    ultimately have ?thesis 
      by (meson col_trivial_3 ncop__ncols not_col_exists)
  }
  ultimately show ?thesis 
    using coplanar_trivial ex_ncol_cop by blast
qed

lemma col2_cop2__eq:
  assumes "¬ Coplanar A B C U" and
    "U ≠ V" and
    "Coplanar A B C P" and
    "Coplanar A B C Q" and
    "Col U V P" and
    "Col U V Q"
  shows "P = Q"
proof -
  have "Col U Q P"
    by (meson assms(2) assms(5) assms(6) col_transitivity_1)
  hence "Col P Q U"
    using not_col_permutation_3 by blast
  thus ?thesis
    using assms(1) assms(3) assms(4) col_cop2__cop by blast
qed

lemma cong3_cop2__col:
  assumes "Coplanar A B C P" and
    "Coplanar A B C Q" and
    "P ≠ Q" and
    "Cong A P A Q" and
    "Cong B P B Q" and
    "Cong C P C Q"
  shows "Col A B C"
proof cases
  assume "Col A B C"
  thus ?thesis by blast
next
  assume P1: "¬ Col A B C"
  obtain M where P2: "M Midpoint P Q"
    using assms(6) l7_25 by blast
  have P3: "Per A M P"
    using P2 Per_def assms(4) by blast
  have P4: "Per B M P"
    using P2 Per_def assms(5) by blast
  have P5: "Per C M P"
    using P2 Per_def assms(6) by blast
  have "False"
  proof cases
    assume Q1: "A = M"
    have Q2: "Coplanar P B C A"
      using assms(1) ncoplanar_perm_21 by blast
    have Q3: "P ≠ A"
      by (metis assms(3) assms(4) cong_diff_4)
    have Q4: "Per B A P"
      by (simp add: P4 Q1)
    have Q5: "Per C A P"
      by (simp add: P5 Q1)
    thus ?thesis using Q1 Q2 Q3 Q4 cop_per2__col
      using P1 not_col_permutation_1 by blast
  next
    assume Q0: "A ≠ M"
    have Q1: "Col A B M"
    proof -
      have R1: "Coplanar A B P Q"
        using P1 assms(1) assms(2) coplanar_trans_1 ncoplanar_perm_8 not_col_permutation_2 
        by blast
      hence R2: "Coplanar P A B M"
        using P2 bet_cop__cop coplanar_perm_14 midpoint_bet ncoplanar_perm_6 by blast
      have R3: "P ≠ M"
        using P2 assms(3) l7_3_2 l7_9_bis by blast
      have R4: "Per A M P"
        by (simp add: P3)
      have R5: "Per B M P"
        by (simp add: P4)
      thus ?thesis
        using R2 R3 R4 cop_per2__col by blast
    qed
    have "Col A C M"
    proof -
      have R1: "Coplanar P A C M"
        using P1 Q1 assms(1) col2_cop__cop coplanar_perm_22 ncoplanar_perm_3 
          not_col_distincts by blast
      have R2: "P ≠ M"
        using P2 assms(3) l7_3_2 symmetric_point_uniqueness by blast
      have R3: "Per A M P"
        by (simp add: P3)
      have "Per C M P"
        by (simp add: P5)
      thus ?thesis
        using R1 R2 R3 cop_per2__col by blast
    qed
    thus ?thesis
      using NCol_perm P1 Q0 Q1 col_trivial_3 colx by blast
  qed
  thus ?thesis by blast
qed

lemma l9_38:
  assumes "A B C TSP P Q"
  shows "A B C TSP Q P"
  using Bet_perm TSP_def assms by blast

lemma l9_39:
  assumes "A B C TSP P R" and
    "Coplanar A B C D" and
    "D Out P Q"
  shows "A B C TSP Q R"
proof -
  have P1: "¬ Col A B C"
    using TSP_def assms(1) ncop__ncol by blast
  have P2: "¬ Coplanar A B C Q"
    by (metis TSP_def assms(1) assms(2) assms(3) col_cop2__cop l6_6 out_col out_diff2)
  have P3: "¬ Coplanar A B C R"
    using TSP_def assms(1) by blast
  obtain T where P3A: "Coplanar A B C T ∧ Bet P T R"
    using TSP_def assms(1) by blast
  have W1: "D = T ⟶ A B C TSP Q R"
    using P2 P3 P3A TSP_def assms(3) bet_out__bet by blast
  {
    assume V1: "D ≠ T"
    have V1A: "¬ Col P D T" using P3A col_cop2__cop
      by (metis TSP_def V1 assms(1) assms(2) col2_cop2__eq col_trivial_2)
    have V1B: "D T TS P R"
      by (metis P3 P3A V1A bet__ts invert_two_sides not_col_permutation_3)
    have "D T OS P Q"
      using V1A assms(3) not_col_permutation_1 out_one_side by blast
    hence V2: "D T TS Q R"
      using V1B l9_8_2 by blast
    then obtain T' where V3: "Col T' D T ∧ Bet Q T' R"
      using TS_def by blast
    have V4: "Coplanar A B C T'"
      using Col_cases P3A V1 V3 assms(2) col_cop2__cop by blast
    hence "A B C TSP Q R"
      using P2 P3 TSP_def V3 by blast
  }
  hence "D ≠ T ⟶ A B C TSP Q R" by blast
  thus ?thesis using W1 by blast
qed

lemma l9_41_1:
  assumes "A B C TSP P R" and
    "A B C TSP Q R"
  shows "A B C OSP P Q"
  using OSP_def assms(1) assms(2) by blast

lemma l9_41_2:
  assumes "A B C TSP P R" and
    "A B C OSP P Q"
  shows "A B C TSP Q R"
proof -
  have P1: "¬ Coplanar A B C P"
    using TSP_def assms(1) by blast
  obtain S where P2: " A B C TSP P S ∧ A B C TSP Q S"
    using OSP_def assms(2) by blast
  obtain X where P3: "Coplanar A B C X ∧ Bet P X S"
    using P2 TSP_def by blast
  have P4: "¬ Coplanar A B C P ∧ ¬ Coplanar A B C S"
    using P2 TSP_def by blast
  obtain Y where P5: "Coplanar A B C Y ∧ Bet Q Y S"
    using P2 TSP_def by blast
  have P6: "¬ Coplanar A B C Q ∧ ¬ Coplanar A B C S"
    using P2 TSP_def by blast
  have P7: "X ≠ P ∧ S ≠ X ∧ Q ≠ Y ∧ S ≠ Y"
    using P3 P4 P5 P6 by blast
  {
    assume Q1: "Col P Q S"
    have Q2: "X = Y"
    proof -
      have R2: "Q ≠ S"
        using P5 P6 bet_neq12__neq by blast
      have R5: "Col Q S X" 
        by (metis Col_def P3 Q1 between_equality_2 l6_16_1 not_bet_distincts)
      have "Col Q S Y"
        by (simp add: P5 bet_col col_permutation_5)
      thus ?thesis
        using P2 P3 P5 R2 R5 TSP_def col2_cop2__eq by blast
    qed
    hence "X Out P Q"
      by (metis P3 P5 P7 l6_2)
    hence "A B C TSP Q R"
      using P3 assms(1) l9_39 by blast
  }
  hence P7: "Col P Q S ⟶ A B C TSP Q R" by blast
  {
    assume Q1: "¬ Col P Q S"
    obtain Z where Q2: "Bet X Z Q ∧ Bet Y Z P"
      using P3 P5 inner_pasch by blast
    {
      assume "X = Z"
      hence "False"
        by (metis P2 P3 P5 Q1 Q2 TSP_def bet_col col_cop2__cop l6_16_1 not_col_permutation_5)
    }
    hence Q3: "X ≠ Z" by blast
    have "Y ≠ Z"
    proof -
      have "X ≠ Z"
        by (meson ‹X = Z ⟹ False›)
      hence "Z ≠ Y"
        by (metis P2 P3 P5 Q2 TSP_def bet_col col_cop2__cop)
      thus ?thesis
        by meson
    qed
    hence "Y Out P Z"
      using Q2 bet_out l6_6 by auto
    hence Q4: "A B C TSP Z R"
      using assms(1) P5 l9_39 by blast
    have "X Out Z Q"
      using Q2 Q3 bet_out by auto
    hence "A B C TSP Q R"
      using Q4 P3 l9_39 by blast
  }
  hence "¬ Col P Q S ⟶ A B C TSP Q R" by blast
  thus ?thesis using P7 by blast
qed

lemma tsp_exists:
  assumes "¬ Coplanar A B C P"
  shows "∃ Q. A B C TSP P Q"
proof -
  obtain Q where "Bet P A Q" and "Cong A Q A P"
    using segment_construction by blast
  moreover have "Coplanar A B C A"
    using coplanar_trivial ncoplanar_perm_5 by blast
  moreover have "¬ Coplanar A B C Q" 
    by (metis assms bet_col bet_col1 between_cong between_symmetry calculation(1) 
        calculation(2) calculation(3) col2_cop2__eq)
  ultimately show ?thesis
    using TSP_def assms by blast
qed

lemma osp_reflexivity:
  assumes "¬ Coplanar A B C P"
  shows "A B C OSP P P"
  by (meson assms l9_41_1 tsp_exists)

lemma osp_symmetry:
  assumes "A B C OSP P Q"
  shows "A B C OSP Q P"
  using OSP_def assms by auto

lemma osp_transitivity:
  assumes "A B C OSP P Q" and
    "A B C OSP Q R"
  shows "A B C OSP P R"
  using OSP_def assms(1) assms(2) l9_41_2 by blast

lemma cop3_tsp__tsp:
  assumes "¬ Col D E F" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar A B C F" and
    "A B C TSP P Q"
  shows "D E F TSP P Q"
proof -
  obtain T where "Coplanar A B C T" and "Bet P T Q"
    using TSP_def assms(5) by blast
  have "¬ Col A B C"
    using TSP_def assms(5) ncop__ncols by blast
  have "Coplanar D E F A ∧ Coplanar D E F B ∧ Coplanar D E F C ∧ Coplanar D E F T"
  proof -
    have "Coplanar D E F A"
      using assms(2) assms(3) assms(4) col_trivial_3 coplanar_pseudo_trans ncop__ncols 
      by (meson ‹¬ Col A B C›)
    moreover have "Coplanar D E F B"
      using assms(2) assms(3) assms(4) col_trivial_2 coplanar_pseudo_trans ncop__ncols 
      by (meson ‹¬ Col A B C›)
    moreover have "Coplanar D E F C"
      by (meson  ‹¬ Col A B C› assms(2) assms(3) assms(4) coplanar_perm_16 coplanar_pseudo_trans 
          coplanar_trivial)
    moreover have "Coplanar D E F T"
      using ‹¬ Col A B C› assms(2) assms(3) assms(4) coplanar_pseudo_trans ‹Coplanar A B C T› 
      by blast
    ultimately show ?thesis 
      by simp
  qed
  hence "¬ Coplanar D E F P"
    using TSP_def assms(1) assms(5) coplanar_pseudo_trans by auto
  hence "¬ Coplanar D E F Q"
    using TSP_def assms(5) bet_col bet_col1 col2_cop2__eq ‹Bet P T Q› ‹Coplanar A B C T› 
      ‹Coplanar D E F A ∧ Coplanar D E F B ∧ Coplanar D E F C ∧ Coplanar D E F T› by metis
  thus ?thesis 
    using TSP_def ‹Bet P T Q› ‹¬ Coplanar D E F P›
      ‹Coplanar D E F A ∧ Coplanar D E F B ∧ Coplanar D E F C ∧ Coplanar D E F T› by blast
qed

lemma cop3_osp__osp:
  assumes "¬ Col D E F" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar A B C F" and
    "A B C OSP P Q"
  shows "D E F OSP P Q"
proof -
  obtain R where "A B C TSP P R" and "A B C TSP Q R"
    using OSP_def assms(5) by blast
  thus ?thesis
    using OSP_def assms(1) assms(2) assms(3) assms(4) cop3_tsp__tsp by blast
qed

lemma ncop_distincts:
  assumes "¬ Coplanar A B C D"
  shows "A ≠ B ∧ A ≠ C ∧ A ≠ D ∧ B ≠ C ∧ B ≠ D ∧ C ≠ D"
  using Coplanar_def assms col_trivial_1 col_trivial_2 by blast

lemma tsp_distincts:
  assumes "A B C TSP P Q"
  shows "A ≠ B ∧ A ≠ C ∧ B ≠ C ∧ A ≠ P ∧ B ≠ P ∧ C ≠ P ∧ A ≠ Q ∧ B ≠ Q ∧ C ≠ Q ∧ P ≠ Q"
proof -
  obtain X where "¬ Coplanar A B C P ∧ ¬ Coplanar A B C Q ∧ Coplanar A B C X ∧ Bet P X Q" 
    by (metis TSP_def assms)
  hence "Q ≠ X"
    by force
  thus ?thesis 
    using ‹¬ Coplanar A B C P ∧ ¬ Coplanar A B C Q ∧ Coplanar A B C X ∧ Bet P X Q› 
      bet_neq32__neq ncop_distincts by blast
qed

lemma osp_distincts:
  assumes "A B C OSP P Q"
  shows "A ≠ B ∧ A ≠ C ∧ B ≠ C ∧ A ≠ P ∧ B ≠ P ∧ C ≠ P ∧ A ≠ Q ∧ B ≠ Q ∧ C ≠ Q"
  using OSP_def assms tsp_distincts by blast

lemma tsp__ncop1:
  assumes "A B C TSP P Q"
  shows "¬ Coplanar A B C P"
  using TSP_def assms by blast

lemma tsp__ncop2:
  assumes "A B C TSP P Q"
  shows "¬ Coplanar A B C Q"
  using TSP_def assms by auto

lemma osp__ncop1:
  assumes "A B C OSP P Q"
  shows "¬ Coplanar A B C P"
  using OSP_def TSP_def assms by blast

lemma osp__ncop2:
  assumes "A B C OSP P Q"
  shows "¬ Coplanar A B C Q"
  using assms osp__ncop1 osp_symmetry by blast

lemma tsp__nosp:
  assumes "A B C TSP P Q"
  shows "¬ A B C OSP P Q"
  using assms l9_41_2 tsp_distincts by blast

lemma osp__ntsp:
  assumes "A B C OSP P Q"
  shows "¬ A B C TSP P Q"
  using assms tsp__nosp by blast

lemma osp_bet__osp:
  assumes "A B C OSP P R" and
    "Bet P Q R"
  shows "A B C OSP P Q"
proof -
  obtain S where "A B C TSP P S"
    using OSP_def assms(1) by blast
  then obtain Y where "Coplanar A B C Y" and "Bet R Y S"
    using TSP_def assms(1) l9_41_2 by blast
  obtain X where "Coplanar A B C X" and "Bet P X S" 
    by (metis TSP_def ‹A B C TSP P S›)
  have "P ≠ X ∧ S ≠ X ∧ R ≠ Y" 
    using TSP_def ‹A B C TSP P S› ‹Coplanar A B C X› ‹Coplanar A B C Y› assms(1) 
      osp__ncop2 by blast
  {
    assume "Col P R S"
    have "A B C TSP Q S"
    proof -
      have "X = Y"
      proof -
        have "¬ Coplanar A B C R"
          using assms(1) osp__ncop2 by blast
        moreover have "R ≠ S" 
          using ‹Bet R Y S› ‹P ≠ X ∧ S ≠ X ∧ R ≠ Y› between_identity by blast
        moreover have "Col R S X" 
          by (metis Bet_cases Col_cases Col_def ‹Bet P X S› ‹Col P R S› between_equality_2 
              col_transitivity_1 outer_transitivity_between point_construction_different)
        moreover have "Col R S Y" 
          using ‹Bet R Y S› bet_col1 between_trivial by blast
        ultimately show ?thesis 
          using  ‹Coplanar A B C X› ‹Coplanar A B C Y› col2_cop2__eq by blast
      qed
      have "X Out P R" 
        using ‹Bet P X S› ‹Bet R Y S› ‹P ≠ X ∧ S ≠ X ∧ R ≠ Y› ‹X = Y› l6_2 by blast
      hence "Y Out P Q" 
        using ‹X = Y› assms(2) out_bet_out_1 by blast 
      thus ?thesis 
        using ‹A B C TSP P S› ‹Coplanar A B C Y› l9_39 by blast
    qed
    hence "A B C OSP P Q" 
      using OSP_def ‹A B C TSP P S› by blast
  }
  moreover
  {
    assume "¬ Col P R S"
    have "X Y OS P R"
    proof -
      have "P ≠ X ∧ S ≠ X ∧ R ≠ Y ∧ S ≠ Y" 
        using ‹A B C TSP P S› ‹Coplanar A B C Y› ‹P ≠ X ∧ S ≠ X ∧ R ≠ Y› tsp__ncop2 by force
      have "¬ Col S X Y"
        using bet_out_1 col_out2_col col_permutation_5 not_col_permutation_4 
        by (metis ‹Bet P X S› ‹Bet R Y S› ‹P ≠ X ∧ S ≠ X ∧ R ≠ Y ∧ S ≠ Y› ‹¬ Col P R S›)
      have "X Y TS P S"
        using Col_perm bet__ts bet_col col_transitivity_2 
        by (metis ‹Bet P X S› ‹P ≠ X ∧ S ≠ X ∧ R ≠ Y› ‹¬ Col S X Y›)
      have "X Y TS R S"
        using assms(1) bet__ts col_cop2__cop invert_two_sides not_col_distincts osp__ncop2 
          ‹Bet R Y S› ‹Coplanar A B C X› ‹Coplanar A B C Y› ‹¬ Col S X Y› by metis
      thus ?thesis 
        using ‹X Y TS P S› l9_8_1 by auto
    qed
    hence "X Y OS P Q" 
      using assms(2) l9_17 by blast
    then obtain S' where "X Y TS P S'" and "X Y TS Q S'"
      using OS_def by blast
    have "¬ Col P X Y ∧ ¬ Col S' X Y ∧ (∃ T::'p. Col T X Y ∧ Bet P T S')" 
      using TS_def ‹X Y TS P S'› by blast
    have "¬ Col Q X Y ∧ ¬ Col S' X Y ∧ (∃ T::'p. Col T X Y ∧ Bet Q T S')" 
      using TS_def ‹X Y TS Q S'› by force
    obtain X' where "Col X' X Y" and "Bet P X' S'" and "X Y TS Q S'" 
      using ‹X Y TS Q S'› ‹¬ Col P X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet P T S')› by blast
    obtain Y' where "Col Y' X Y" and "Bet Q Y' S'" 
      using ‹¬ Col Q X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet Q T S')› by blast
    have "Coplanar A B C X'" 
      using ‹Coplanar A B C X› Col_cases col_cop2__cop ts_distincts 
      by (metis not_col_distincts ‹Col X' X Y› ‹Coplanar A B C Y› 
          ‹¬ Col P X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet P T S')›)
    have "Coplanar A B C Y'"
      using Col_cases col_cop2__cop ts_distincts 
      by (metis not_col_distincts ‹Col Y' X Y› ‹Coplanar A B C X› ‹Coplanar A B C Y› 
          ‹¬ Col P X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet P T S')›)
    have "¬ Coplanar A B C S'"
      using assms(1) bet_col bet_col1 col2_cop2__eq osp__ncop1 
      by (metis ‹Bet P X' S'› ‹Col X' X Y› ‹Coplanar A B C X'› 
          ‹¬ Col P X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet P T S')›)
    hence "A B C OSP P Q"
    proof -
      have "A B C TSP P S'"
        using TSP_def 
        by (meson osp__ncop1 ‹Bet P X' S'› ‹Coplanar A B C X'› ‹¬ Coplanar A B C S'› assms(1))
      moreover have "A B C TSP Q S'"
        using TSP_def bet_col col_cop2__cop 
        by (metis ‹Bet Q Y' S'› ‹Col Y' X Y› ‹Coplanar A B C Y'› 
            ‹¬ Col Q X Y ∧ ¬ Col S' X Y ∧ (∃T. Col T X Y ∧ Bet Q T S')› ‹¬ Coplanar A B C S'›)
      ultimately show ?thesis 
        using l9_41_1 by blast
    qed
  }
  ultimately show ?thesis 
    by blast
qed

lemma l9_18_3:
  assumes "Coplanar A B C P" and
    "Col X Y P"
  shows "A B C TSP X Y ⟷ (Bet X P Y ∧ ¬ Coplanar A B C X ∧ ¬ Coplanar A B C Y)"
  by (meson TSP_def assms(1) assms(2) l9_39 not_bet_out not_col_permutation_5 tsp_distincts)

lemma bet_cop__tsp:
  assumes "¬ Coplanar A B C X" and
    "P ≠ Y" and
    "Coplanar A B C P" and
    "Bet X P Y"
  shows "A B C TSP X Y"
  using TSP_def assms(1) assms(2) assms(3) assms(4) bet_col bet_col1 col2_cop2__eq by metis

lemma cop_out__osp:
  assumes "¬ Coplanar A B C X" and
    "Coplanar A B C P" and
    "P Out X Y"
  shows "A B C OSP X Y"
  by (meson OSP_def assms(1) assms(2) assms(3) l9_39 tsp_exists)

lemma l9_19_3:
  assumes "Coplanar A B C P" and
    "Col X Y P"
  shows "A B C OSP X Y ⟷ (P Out X Y ∧ ¬ Coplanar A B C X)"
  by (meson assms(1) assms(2) cop_out__osp l6_4_2 l9_18_3 not_col_permutation_5 osp__ncop1 
      osp__ncop2 tsp__nosp)

lemma cop2_ts__tsp:
  assumes "¬ Coplanar A B C X" and "Coplanar A B C D" and
    "Coplanar A B C E" and "D E TS X Y"
  shows "A B C TSP X Y"
proof -
  obtain T where "Col T D E" and "Bet X T Y"
    using TS_def assms(4) by blast
  moreover hence "Coplanar A B C T"
    using assms(2) assms(3) assms(4) col_cop2__cop not_col_permutation_2 ts_distincts by blast
  ultimately show ?thesis 
    by (metis TS_def assms(1) assms(4) bet_cop__tsp)
qed

lemma cop2_os__osp:
  assumes "¬ Coplanar A B C X" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "D E OS X Y"
  shows "A B C OSP X Y"
proof -
  obtain Z where "D E TS X Z" and "D E TS Y Z"
    using OS_def assms(4) by blast
  hence "A B C TSP X Z"
    using assms(1) assms(2) assms(3) cop2_ts__tsp by blast
  moreover hence "A B C TSP Y Z"
    using assms(2) assms(3) cop2_ts__tsp l9_2 tsp__ncop2 ‹D E TS Y Z› by meson
  ultimately show ?thesis
    using l9_41_1 by blast
qed

lemma cop3_tsp__ts:
  assumes "D ≠ E" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar D E X Y" and
    "A B C TSP X Y"
  shows "D E TS X Y"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) col_cop2__cop cop2_os__osp
      cop_nts__os not_col_permutation_2 tsp__ncop1 tsp__ncop2 tsp__nosp)

lemma cop3_osp__os:
  assumes "D ≠ E" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar D E X Y" and
    "A B C OSP X Y"
  shows "D E OS X Y"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) col_cop2__cop cop2_ts__tsp 
      cop_nts__os not_col_permutation_2 osp__ncop1 osp__ncop2 tsp__nosp)

lemma cop_tsp__ex_cop2:
  assumes (*"Coplanar A B C P" and*)
    "A B C TSP D E"
  shows "∃ Q. (Coplanar A B C Q ∧ Coplanar D E P Q ∧ P ≠ Q)"
proof cases
  assume "Col D E P"
  thus ?thesis
    by (meson ex_diff_cop ncop__ncols)
next
  assume "¬ Col D E P"
  then obtain Q where "Coplanar A B C Q ∧ Bet D Q E ∧ ¬ Col D E P"
    using TSP_def assms(1) by blast
  thus ?thesis
    using Col_perm bet_col ncop__ncols by blast
qed

lemma cop_osp__ex_cop2:
  assumes "Coplanar A B C P" and
    "A B C OSP D E"
  shows "∃ Q. Coplanar A B C Q ∧ Coplanar D E P Q ∧ P ≠ Q"
proof cases
  assume "Col D E P"
  thus ?thesis
    by (metis col_trivial_3 diff_col_ex ncop__ncols)
next
  assume P1: "¬ Col D E P"
  obtain E' where P2: "Bet E P E' ∧ Cong P E' P E"
    using segment_construction by blast
  have P3: "¬ Col D E' P"
    by (metis P1 P2 bet_col bet_cong_eq between_symmetry col_permutation_5 l5_2 l6_16_1)
  have P4: "A B C TSP D E'"
    by (metis P2 P3 assms(1) assms(2) bet_cop__tsp l9_41_2 not_col_distincts 
        osp__ncop2 osp_symmetry)
  hence "¬ Coplanar A B C D ∧ ¬ Coplanar A B C E' ∧ (∃ T. Coplanar A B C T ∧ Bet D T E')"
    by (simp add: TSP_def)
  then obtain Q where P7: "Coplanar A B C Q ∧ Bet D Q E'"
    by blast
  hence "Coplanar D E' P Q"
    using bet_col ncop__ncols ncoplanar_perm_5 by blast
  hence "Coplanar D E P Q"
    using Col_perm P2 P3 bet_col col_cop__cop ncoplanar_perm_5 not_col_distincts by blast
  thus ?thesis
    using P3 P7 bet_col col_permutation_5 by blast
qed

lemma sac__coplanar:
  assumes "Saccheri A B C D"
  shows "Coplanar A B C D"
  using Saccheri_def assms ncoplanar_perm_4 os__coplanar by blast

lemma ex_sym:
  "∃ Y. (A B Perp X Y ∨ X = Y) ∧ (∃ M. Col A B M ∧ M Midpoint X Y)"
proof cases
  assume "Col A B X"
  thus ?thesis
    using l7_3_2 by blast
next
  assume "¬ Col A B X"
  then obtain M0 where "Col A B M0" and "A B Perp X M0"
    using l8_18_existence by blast
  obtain Z where "M0 Midpoint X Z"
    using symmetric_point_construction by blast
  thus ?thesis 
    using Perp_cases bet_col midpoint_bet perp_col 
    by (metis ‹A B Perp X M0› ‹Col A B M0›)
qed

lemma is_image_is_image_spec:
  assumes "A ≠ B"
  shows "P' P Reflect A B ⟷ P' P ReflectL A B"
  by (simp add: Reflect_def assms)

lemma ex_sym1:
  assumes "A ≠ B"
  shows "∃ Y. (A B Perp X Y ∨ X = Y) ∧ (∃ M. Col A B M ∧ M Midpoint X Y ∧ X Y Reflect A B)"
proof cases
  assume "Col A B X"
  thus ?thesis
    by (meson ReflectL_def Reflect_def assms l7_3_2)
next
  assume P0: "¬ Col A B X"
  then obtain M0 where P1: "Col A B M0 ∧ A B Perp X M0"
    using l8_18_existence by blast
  obtain Z where P2: "M0 Midpoint X Z"
    using symmetric_point_construction by blast
  have P3: "A B Perp X Z"
  proof cases
    assume "X = Z"
    thus ?thesis
      using P1 P2 P0 midpoint_distinct by blast
  next
    assume "X ≠ Z"
    hence P2: "X Z Perp A B"
      using P1 P2 Perp_cases bet_col midpoint_bet perp_col by blast
    show ?thesis
      by (simp add: Perp_perm Tarski_neutral_dimensionless_axioms P2)
  qed
  have P10: "(A B Perp X Z ∨ X = Z)"
    by (simp add: P3)
  have "∃ M. Col A B M ∧ M Midpoint X Z ∧ X Z Reflect A B"
    using P1 P2 P3 ReflectL_def assms is_image_is_image_spec l7_2 perp_right_comm by blast
  thus ?thesis
    using P3 by blast
qed

lemma l10_2_uniqueness:
  assumes "P1 P Reflect A B" and
    "P2 P Reflect A B"
  shows "P1 = P2"
proof cases
  assume "A = B"
  thus ?thesis
    using Reflect_def assms(1) assms(2) symmetric_point_uniqueness by auto
next
  assume "A ≠ B"
  hence "P1 P ReflectL A B"
    using assms(1) is_image_is_image_spec by auto
  hence "A B Perp P P1 ∨ P = P1"
    using ReflectL_def by blast
  have "P2 P ReflectL A B"
    using assms(2) is_image_is_image_spec ‹A ≠ B› by blast
  hence "A B Perp P P2 ∨ P = P2"
    using ReflectL_def by blast
  obtain X where "X Midpoint P P1" and "Col A B X"
    by (metis ReflectL_def assms(1) col_trivial_1 is_image_is_image_spec midpoint_existence)
  obtain Y where "Y Midpoint P P2" and "Col A B Y"
    by (metis ReflectL_def assms(2) col_trivial_1 is_image_is_image_spec midpoint_existence)
  {
    assume "A B Perp P P1" and "A B Perp P P2"
    have "P ≠ X" 
      using ‹A B Perp P P1› ‹X Midpoint P P1› is_midpoint_id perp_not_eq_2 by blast
    have "P ≠ Y" 
      using ‹A B Perp P P2› ‹Y Midpoint P P2› is_midpoint_id perp_not_eq_2 by blast
    have "P X Perp A B" 
      using Perp_perm ‹A B Perp P P1› ‹P ≠ X› ‹X Midpoint P P1› bet_col midpoint_bet 
        not_col_permutation_5 perp_col1 by blast
    have "P Y Perp A B" 
      using Perp_perm ‹A B Perp P P2› ‹P ≠ Y› ‹Y Midpoint P P2› bet_col midpoint_bet 
        not_col_permutation_5 perp_col1 by blast
    hence "P1 = P2" 
      by (metis Perp_perm l7_2 l7_9_bis ‹Col A B Y› ‹P X Perp A B› ‹X Midpoint P P1› 
          ‹⋀thesis. (⋀X. ⟦X Midpoint P P1; Col A B X⟧ ⟹ thesis) ⟹ thesis› 
          ‹Y Midpoint P P2› l7_17 l8_18_uniqueness)
  }
  hence "(A B Perp P P1 ∧ A B Perp P P2) ⟶ P1 = P2" by blast
  moreover have "(P = P1 ∧ A B Perp P P2) ⟶ P1 = P2" 
    by (metis ‹Col A B X› ‹Col A B Y› ‹X Midpoint P P1› ‹Y Midpoint P P2› colx is_midpoint_id 
        l8_16_1 midpoint_col midpoint_distinct_2)
  moreover have "(P = P2 ∧ A B Perp P P1) ⟶ P1 = P2" 
    by (metis ‹Col A B X› ‹Col A B Y› ‹X Midpoint P P1› ‹Y Midpoint P P2› l8_16_1 
        l8_20_2 midpoint_col not_col_distincts perp_col2)
  ultimately show ?thesis 
    using ‹A B Perp P P1 ∨ P = P1› ‹A B Perp P P2 ∨ P = P2› by fastforce
qed

lemma l10_2_uniqueness_spec:
  assumes "P1 P ReflectL A B" and
    "P2 P ReflectL A B"
  shows "P1 = P2"
proof -
  have "A B Perp P P1 ∨ P = P1"
    using ReflectL_def assms(1) by blast
  moreover obtain X1 where "X1 Midpoint P P1" and "Col A B X1"
    using ReflectL_def assms(1) by blast
  moreover have "A B Perp P P2 ∨ P = P2"
    using ReflectL_def assms(2) by blast
  moreover obtain X2 where "X2 Midpoint P P2" and "Col A B X2"
    using ReflectL_def assms(2) by blast
  {
    assume "A B Perp P P1" and "A B Perp P P2"
    have "P1 P Reflect A B" 
      using Reflect_def ‹A B Perp P P1› assms(1) perp_distinct by auto
    moreover have "P2 P Reflect A B" 
      using ‹A B Perp P P2› assms(2) is_image_is_image_spec perp_distinct by auto
    ultimately have "P1 = P2" 
      using l10_2_uniqueness by auto
  }
  moreover
  {
    assume "A B Perp P P1 ∧ P = P2"
    hence "P1 = P2" 
      by (metis colx perp_not_col2 ‹Col A B X2› ‹X2 Midpoint P P2› calculation(2) 
          calculation(3) l8_20_2 midpoint_col)
  }
  moreover
  {
    assume "P = P1" and "A B Perp P P2"
    hence "P1 = P2" 
      by (metis ‹Col A B X2› ‹X2 Midpoint P P2› calculation(2) calculation(3) 
          colx l8_20_2 midpoint_col perp_not_col2)
  }
  ultimately show ?thesis 
    by blast
qed

lemma l10_2_existence_spec:
  "∃ P'. P' P ReflectL A B"
proof cases
  assume "Col A B P"
  thus ?thesis
    using ReflectL_def l7_3_2 by blast
next
  assume "¬ Col A B P"
  then obtain X where "Col A B X ∧ A B Perp P X"
    using l8_18_existence by blast
  moreover obtain P' where "X Midpoint P P'"
    using symmetric_point_construction by blast
  ultimately show ?thesis
    using ReflectL_def bet_col midpoint_bet perp_col1 by blast
qed

lemma l10_2_existence:
  "∃ P'. P' P Reflect A B"
  by (metis Reflect_def l10_2_existence_spec symmetric_point_construction)

lemma l10_4_spec:
  assumes "P P' ReflectL A B"
  shows "P' P ReflectL A B"
proof -
  obtain X where "X Midpoint P P' ∧ Col A B X"
    using ReflectL_def assms l7_2 by blast
  thus ?thesis
    using Perp_cases ReflectL_def assms by auto
qed

lemma l10_4:
  assumes "P P' Reflect A B"
  shows "P' P Reflect A B"
  using Reflect_def l7_2 Tarski_neutral_dimensionless_axioms assms l10_4_spec by fastforce

lemma l10_5:
  assumes "P' P Reflect A B" and
    "P'' P' Reflect A B"
  shows "P = P''"
  by (meson assms(1) assms(2) l10_2_uniqueness l10_4)

lemma l10_6_uniqueness:
  assumes "P P1 Reflect A B" and
    "P P2 Reflect A B"
  shows "P1 = P2"
  using assms(1) assms(2) l10_4 l10_5 by blast

lemma l10_6_uniqueness_spec:
  assumes "P P1 ReflectL A B" and
    "P P2 ReflectL A B"
  shows "P1 = P2"
  using assms(1) assms(2) l10_2_uniqueness_spec l10_4_spec by blast

lemma l10_6_existence_spec:
  assumes "A ≠ B"
  shows "∃ P. P' P ReflectL A B"
  using l10_2_existence_spec l10_4_spec by blast

lemma l10_6_existence:
  "∃ P. P' P Reflect A B"
  using l10_2_existence l10_4 by blast

lemma l10_7:
  assumes "P' P Reflect A B" and
    "Q' Q Reflect A B" and
    "P' = Q'"
  shows "P = Q"
  using assms(1) assms(2) assms(3) l10_6_uniqueness by blast

lemma l10_8:
  assumes "P P Reflect A B"
  shows "Col P A B"
  by (metis Col_perm assms col_trivial_2 ex_sym1 l10_6_uniqueness l7_3)

lemma col__refl:
  assumes "Col P A B"
  shows "P P ReflectL A B"
  using ReflectL_def assms col_permutation_1 l7_3_2 by blast

lemma is_image_col_cong:
  assumes "A ≠ B" and
    "P P' Reflect A B" and
    "Col A B X"
  shows "Cong P X P' X"
proof -
  have P1: "P P' ReflectL A B"
    using assms(1) assms(2) is_image_is_image_spec by blast
  obtain M0 where P2: "M0 Midpoint P' P ∧ Col A B M0"
    using P1 ReflectL_def by blast
  have "A B Perp P' P ∨ P' = P"
    using P1 ReflectL_def by auto
  moreover
  {
    assume S1: "A B Perp P' P"
    hence "A ≠ B ∧ P' ≠ P"
      using perp_distinct by blast
    have S2: "M0 = X ⟶ Cong P X P' X"
      using P2 cong_4312 midpoint_cong by blast
    {
      assume "M0 ≠ X"
      hence "M0 X Perp P' P"
        using P2 S1 assms(3) perp_col2 by blast
      hence "¬ Col A B P ∧ Per P M0 X"
        by (metis Col_perm P2 S1 colx l8_2 midpoint_col midpoint_distinct_1 
            per_col perp_col1 perp_not_col2 perp_per_1)
      hence "Cong P X P' X"
        using P2 cong_commutativity l7_2 l8_2 per_double_cong by blast
    }
    hence "Cong P X P' X"
      using S2 by blast
  }
  hence "A B Perp P' P ⟶ Cong P X P' X" by blast
  moreover
  {
    assume "P = P'"
    hence "Cong P X P' X"
      by (simp add: cong_reflexivity)
  }
  ultimately show ?thesis by blast
qed

lemma is_image_spec_col_cong:
  assumes "P P' ReflectL A B" and
    "Col A B X"
  shows "Cong P X P' X"
  by (metis Col_def Reflect_def assms(1) assms(2) between_trivial col__refl 
      cong_reflexivity is_image_col_cong l10_6_uniqueness_spec)

lemma image_id:
  assumes "A ≠ B" and
    "Col A B T" and
    "T T' Reflect A B"
  shows "T = T'"
  using assms(1) assms(2) assms(3) cong_diff_4 is_image_col_cong by blast

lemma osym_not_col:
  assumes "P P' Reflect A B" and
    "¬ Col A B P"
  shows "¬ Col A B P'"
  using assms(1) assms(2) l10_4 local.image_id not_col_distincts by blast

lemma midpoint_preserves_image:
  assumes "A ≠ B" and
    "Col A B M" and
    "P P' Reflect A B" and
    "M Midpoint P Q" and
    "M Midpoint P' Q'"
  shows "Q Q' Reflect A B"
proof -
  obtain X where "X Midpoint P' P" and "Col A B X"
    using ReflectL_def assms(1) assms(3) is_image_is_image_spec by blast
  {
    assume "A B Perp P' P"
    obtain Y where "M Midpoint X Y"
      using symmetric_point_construction by blast
    have "Y Midpoint Q Q'"
    proof -
      have "X Midpoint P P'" 
        using ‹X Midpoint P' P› l7_2 by blast
      thus ?thesis 
        using assms(4) assms(5) symmetry_preserves_midpoint ‹M Midpoint X Y› by blast
    qed
    have "P ≠ P'" 
      using ‹A B Perp P' P› perp_distinct by blast
    hence "Q ≠ Q'"
      using l7_9 Tarski_neutral_dimensionless_axioms assms(4) assms(5) by fastforce
    have "Y Midpoint Q' Q ∧ Col A B Y"
      using assms(2) colx l7_2 midpoint_col midpoint_distinct_1 
      by (metis ‹Col A B X› ‹M Midpoint X Y› ‹Y Midpoint Q Q'›)
    have "A B Perp Q' Q ∨ Q = Q'"
    proof -
      have "Per M Y Q"
      proof -
        have "Y Midpoint Q Q'" 
          using ‹Y Midpoint Q Q'› by auto
        have "Cong M Q M Q'"
          using assms(1) assms(2) assms(3) assms(4) assms(5) cong_commutativity 
            is_image_col_cong l7_16 l7_3_2 by blast
        thus ?thesis 
          using Per_def ‹Y Midpoint Q Q'› by blast
      qed
      {
        have "X = Y ⟶ (A B Perp Q' Q ∨ Q = Q')"
          using Perp_cases assms(5) l7_3 l7_9_bis 
          by (metis ‹A B Perp P' P› ‹M Midpoint X Y› ‹X Midpoint P' P› assms(4))
        {
          assume "X ≠ Y"
          hence "Y PerpAt M Y Y Q"
            using midpoint_distinct_1 per_perp_in 
            by (metis ‹M Midpoint X Y› ‹Per M Y Q› ‹Q ≠ Q'› ‹Y Midpoint Q' Q ∧ Col A B Y›)
          hence "Y Y Perp Y Q ∨ M Y Perp Y Q" 
            by (simp add: perp_in_perp_bis)
          {
            have "Y Y Perp Y Q ⟶ A B Perp Q' Q ∨ Q = Q'"
              using perp_not_eq_1 by blast
            {
              assume "M Y Perp Y Q"
              have "Y Q Perp A B"
              proof cases
                assume "A = M"
                thus ?thesis 
                  using Perp_cases ‹M Y Perp Y Q› ‹Y Midpoint Q' Q ∧ Col A B Y› 
                    assms(1) not_col_permutation_5 perp_col1 by blast
              next
                assume "A ≠ M"
                thus ?thesis 
                  by (metis ‹Y Midpoint Q' Q ∧ Col A B Y› ‹Y Y Perp Y Q ∨ M Y Perp Y Q› 
                      assms(1) assms(2) col3 not_col_distincts perp_col0)
              qed
              have "A B Perp Q' Q ∨ Q = Q'"
                using midpoint_col not_col_distincts perp_col0 
                by (metis ‹Y Midpoint Q Q'› ‹Y Q Perp A B›)
            }
            hence "M Y Perp Y Q ⟶ A B Perp Q' Q ∨ Q = Q'" by blast
          }
          hence "A B Perp Q' Q ∨ Q = Q'"
            using perp_distinct ‹Y Y Perp Y Q ∨ M Y Perp Y Q› by blast
        }
        hence "X ≠ Y ⟶ (A B Perp Q' Q ∨ Q = Q')" by blast
      }
      thus ?thesis
        using Perp_cases assms(5) l7_3 l7_9_bis
        by (metis ‹A B Perp P' P› ‹M Midpoint X Y› ‹Y Midpoint Q Q'› assms(4))
    qed
    hence "Q Q' ReflectL A B" 
      using ReflectL_def ‹Y Midpoint Q' Q ∧ Col A B Y› by blast
  }
  moreover
  {
    assume "P = P'"
    hence "Q Q' ReflectL A B"
      using assms(2) assms(4) assms(5) col__refl col_permutation_2 colx midpoint_col 
        midpoint_distinct_3 symmetric_point_uniqueness by (metis ‹Col A B X› ‹X Midpoint P' P›)
  }
  ultimately show ?thesis
    using ReflectL_def assms(1) assms(3) is_image_is_image_spec by auto
qed

lemma image_in_is_image_spec:
  assumes "M ReflectLAt P P' A B"
  shows "P P' ReflectL A B"
proof -
  have P1: "M Midpoint P' P"
    using ReflectLAt_def assms by blast
  have P2: "Col A B M"
    using ReflectLAt_def assms by blast
  have "A B Perp P' P ∨ P' = P"
    using ReflectLAt_def assms by blast
  thus ?thesis using P1 P2
    using ReflectL_def by blast
qed

lemma image_in_gen_is_image:
  assumes "M ReflectAt P P' A B"
  shows "P P' Reflect A B"
  using ReflectAt_def Reflect_def assms image_in_is_image_spec by auto

lemma image_image_in:
  assumes "P ≠ P'" and
    "P P' ReflectL A B" and
    "Col A B M" and
    "Col P M P'"
  shows "M ReflectLAt P P' A B"
proof -
  obtain M' where P1: "M' Midpoint P' P ∧ Col A B M'"
    using ReflectL_def assms(2) by blast
  have Q1: "P M' Perp A B"
    by (metis Col_cases P1 Perp_perm ReflectL_def assms(1) assms(2) bet_col cong_diff_3 
        midpoint_bet midpoint_cong not_cong_4321 perp_col1)
  {
    assume R1: "A B Perp P' P"
    have R3: "P ≠ M'"
      using Q1 perp_not_eq_1 by auto
    have R4: "A B Perp P' P"
      by (simp add: R1)
    have R5: "Col P P' M'"
      using P1 midpoint_col not_col_permutation_3 by blast
    have R6: "M' Midpoint P' P"
      by (simp add: P1)
    have R7: "¬ Col A B P"
      using assms(1) assms(2) col__refl col_permutation_2 l10_2_uniqueness_spec l10_4_spec 
      by blast
    have R8: "P ≠ P'"
      by (simp add: assms(1))
    have R9: "Col A B M'"
      by (simp add: P1)
    have R10: "Col A B M"
      by (simp add: assms(3))
    have R11: "Col P P' M'"
      by (simp add: R5)
    have R12: "Col P P' M"
      using Col_perm assms(4) by blast
    have "M = M'"
    proof cases
      assume S1: "A = M'"
      have "Per P M' A"
        by (simp add: S1 l8_5)
      thus ?thesis using l6_21 R8 R9 R10 R11 R12
        using R7 by blast
    next
      assume "A ≠ M'"
      thus ?thesis
        using R10 R12 R5 R7 R8 R9 l6_21 by blast
    qed
    hence "M Midpoint P' P"
      using R6 by blast
  }
  hence Q2: "A B Perp P' P ⟶ M Midpoint P' P" by blast
  have Q3: "P' = P ⟶ M Midpoint P' P"
    using assms(1) by auto
  have Q4: "A B Perp P' P ∨ P' = P"
    using ReflectL_def assms(2) by auto
  hence "M Midpoint P' P"
    using Q2 Q3 by blast
  thus ?thesis
    by (simp add: ReflectLAt_def Q4 assms(3))
qed

lemma image_in_col:
  assumes "Y ReflectLAt P P' A B"
  shows "Col P P' Y"
  using Col_perm ReflectLAt_def assms midpoint_col by blast

lemma is_image_spec_rev:
  assumes "P P' ReflectL A B"
  shows "P P' ReflectL B A"
proof -
  obtain M0 where P1: "M0 Midpoint P' P ∧ Col A B M0"
    using ReflectL_def assms by blast
  have P2: "Col B A M0"
    using Col_cases P1 by blast
  have "A B Perp P' P ∨ P' = P"
    using ReflectL_def assms by blast
  thus ?thesis
    using P1 P2 Perp_cases ReflectL_def by auto
qed

lemma is_image_rev:
  assumes "P P' Reflect A B"
  shows "P P' Reflect B A"
  using Reflect_def assms is_image_spec_rev by auto

lemma midpoint_preserves_per:
  assumes "Per A B C" and
    "M Midpoint A A1" and
    "M Midpoint B B1" and
    "M Midpoint C C1"
  shows "Per A1 B1 C1"
proof -
  obtain C' where P1: "B Midpoint C C' ∧ Cong A C A C'"
    using Per_def assms(1) by blast
  obtain C1' where P2: "M Midpoint C' C1'"
    using symmetric_point_construction by blast
  thus ?thesis
    by (meson P1 Per_def assms(2) assms(3) assms(4) l7_16 symmetry_preserves_midpoint)
qed

lemma col__image_spec:
  assumes "Col A B X"
  shows "X X ReflectL A B"
  by (simp add: assms col__refl col_permutation_2)

lemma image_triv:
  "A A Reflect A B"
  by (simp add: Reflect_def col__refl col_trivial_1 l7_3_2)

lemma cong_midpoint__image:
  assumes "Cong A X A Y" and
    "B Midpoint X Y"
  shows "Y X Reflect A B"
proof cases
  assume "A = B"
  thus ?thesis
    by (simp add: Reflect_def assms(2))
next
  assume S0: "A ≠ B"
  {
    assume S1: "X ≠ Y"
    hence "X Y Perp A B"
    proof -
      have T1: "B ≠ X"
        using S1 assms(2) midpoint_distinct_1 by blast
      have T2: "B ≠ Y"
        using S1 assms(2) midpoint_not_midpoint by blast
      have "Per A B X"
        using Per_def assms(1) assms(2) by auto
      thus ?thesis
        using S0 S1 T1 T2 assms(2) col_per_perp midpoint_col by auto
    qed
    hence "A B Perp X Y ∨ X = Y"
      using Perp_perm by blast
    hence "Y X Reflect A B"
      using ReflectL_def S0 assms(2) col_trivial_2 is_image_is_image_spec by blast
  }
  hence "X ≠ Y ⟶ Y X Reflect A B" by blast
  thus ?thesis
    using assms(2) image_triv is_image_rev l7_3 by blast
qed


lemma col_image_spec__eq:
  assumes "Col A B P" and
    "P P' ReflectL A B"
  shows "P = P'"
  using assms(1) assms(2) col__image_spec l10_2_uniqueness_spec l10_4_spec by blast

lemma image_spec_triv:
  "A A ReflectL B B"
  using col__image_spec not_col_distincts by blast

lemma image_spec__eq:
  assumes "P P' ReflectL A A"
  shows "P = P'"
  using assms col_image_spec__eq not_col_distincts by blast

lemma image__midpoint:
  assumes "P P' Reflect A A"
  shows "A Midpoint P' P"
  using Reflect_def assms by auto

lemma is_image_spec_dec:
  "A B ReflectL C D ∨ ¬ A B ReflectL C D"
  by simp

lemma l10_14:
  assumes "P ≠ P'" and
    "A ≠ B" and
    "P P' Reflect A B"
  shows "A B TS P P'"
proof -
  have P1: "P P' ReflectL A B"
    using assms(2) assms(3) is_image_is_image_spec by blast
  then obtain M0 where "M0 Midpoint P' P ∧ Col A B M0"
    using ReflectL_def by blast
  hence "A B Perp P' P ⟶ A B TS P P'"
    by (meson TS_def assms(1) assms(2) assms(3) between_symmetry col_permutation_2 
        image_id midpoint_bet osym_not_col)
  thus ?thesis
    using assms(1) P1 ReflectL_def by blast
qed

lemma l10_15:
  assumes "Col A B C" and
    "¬ Col A B P"
  shows "∃ Q. A B Perp Q C ∧ A B OS P Q"
proof -
  have P1: "A ≠ B"
    using assms(2) col_trivial_1 by auto
  obtain X where P2: "A B TS P X"
    using assms(2) col_permutation_1 l9_10 by blast
  {
    assume Q1: "A = C"
    obtain Q where Q2: "∃ T. A B Perp Q A ∧ Col A B T ∧ Bet X T Q"
      using P1 l8_21 by blast
    then obtain T where "A B Perp Q A ∧ Col A B T ∧ Bet X T Q" by blast
    hence "A B TS Q X"
      by (meson P2 TS_def between_symmetry col_permutation_2 perp_not_col)
    hence Q5: "A B OS P Q"
      using P2 l9_8_1 by blast
    hence "∃ Q. A B Perp Q C ∧ A B OS P Q"
      using Q1 Q2 by blast
  }
  hence P3: "A = C ⟶ (∃ Q. A B Perp Q C ∧ A B OS P Q)" by blast
  {
    assume Q1: "A ≠ C"
    then obtain Q where Q2: "∃ T. C A Perp Q C ∧ Col C A T ∧ Bet X T Q"
      using l8_21 by presburger
    then obtain T where Q3: "C A Perp Q C ∧ Col C A T ∧ Bet X T Q" by blast
    have Q4: "A B Perp Q C"
      using NCol_perm P1 Q2 assms(1) col_trivial_2 perp_col2 by blast
    have "A B TS Q X"
    proof -
      have R1: "¬ Col Q A B"
        using Col_perm P1 Q2 assms(1) col_trivial_2 colx perp_not_col by blast
      have R2: "¬ Col X A B"
        using P2 TS_def by auto
      have R3: "Col T A B"
        by (metis Q1 Q3 assms(1) col_trivial_2 colx not_col_permutation_1)
      have "Bet Q T X"
        using Bet_cases Q3 by blast
      hence "∃ T. Col T A B ∧ Bet Q T X"
        using R3 by blast
      thus ?thesis using R1 R2
        by (simp add: TS_def)
    qed
    hence "A B OS P Q"
      using P2 l9_8_1 by blast
    hence "∃ Q. A B Perp Q C ∧ A B OS P Q"
      using Q4 by blast
  }
  thus ?thesis using P3 by blast
qed

lemma ex_per_cong:
  assumes "A ≠ B" and
    "X ≠ Y" and
    "Col A B C" and
    "¬ Col A B D"
  shows "∃ P. Per P C A ∧ Cong P C X Y ∧ A B OS P D"
proof -
  obtain Q where P1: "A B Perp Q C ∧ A B OS D Q"
    using assms(3) assms(4) l10_15 by blast
  obtain P where P2: "C Out Q P ∧ Cong C P X Y"
    by (metis P1 assms(2) perp_not_eq_2 segment_construction_3)
  have P3: "Per P C A"
    using P1 P2 assms(3) col_trivial_3 l8_16_1 l8_3 out_col by blast
  have "A B OS P D"
    using P1 P2 assms(3) one_side_symmetry os_out_os by blast
  thus ?thesis
    using P2 P3 cong_left_commutativity by blast
qed

lemma exists_cong_per:
  "∃ C. Per A B C ∧ Cong B C X Y"
proof cases
  assume "A = B"
  thus ?thesis
    by (meson l8_5 Tarski_neutral_dimensionless_axioms l8_2 segment_construction)
next
  assume "A ≠ B"
  thus ?thesis
    by (metis Perp_perm bet_col between_trivial l8_16_1 l8_21 segment_construction)
qed

lemma upper_dim_implies_per2__col:
  assumes "upper_dim_axiom"
  shows "∀ A B C X. (Per A X C ∧ X ≠ C ∧ Per B X C) ⟶ Col A B X"
proof -
  {
    fix A B C X
    assume "Per A X C ∧ X ≠ C ∧ Per B X C"
    moreover then obtain C' where "X Midpoint C C'" and "Cong A C A C'"
      using Per_def by blast
    moreover obtain C'' where "X Midpoint C C''" and "Cong B C B C''" 
      using Per_def calculation(1) by blast
    moreover hence "C' = C''" 
      using ‹X Midpoint C C''› symmetric_point_uniqueness calculation(2) by auto
    have "C ≠ C'" 
      using calculation(1) calculation(2) l7_3 by blast
    moreover have "Cong B C B C'" 
      by (simp add: ‹C' = C''› calculation(5))
    moreover have "Cong X C X C'" 
      using calculation(2) cong_left_commutativity midpoint_cong by blast
    ultimately have "Col A B X" 
      using Col_def assms upper_dim_axiom_def by blast
  }
  thus ?thesis by blast
qed

lemma upper_dim_implies_col_perp2__col:
  assumes "upper_dim_axiom"
  shows "∀ A B X Y P. (Col A B P ∧ A B Perp X P ∧ P A Perp Y P) ⟶ Col Y X P"
proof -
  {
    fix A B X Y P
    assume H1: "Col A B P ∧ A B Perp X P ∧ P A Perp Y P"
    hence H2: "P ≠ A"
      using perp_not_eq_1 by blast
    have "Col Y X P"
    proof -
      have T1: "Per Y P A"
        using H1 l8_2 perp_per_1 by blast
      moreover have "Per X P A"
        using H1 col_trivial_3 l8_16_1 by blast
      thus ?thesis using T1 H2
        using assms upper_dim_implies_per2__col by blast
    qed
  }
  thus ?thesis by blast
qed

lemma upper_dim_implies_perp2__col:
  assumes "upper_dim_axiom"
  shows "∀ X Y Z A B. (X Y Perp A B ∧ X Z Perp A B) ⟶ Col X Y Z"
proof -
  {
    fix X Y Z A B
    assume H1: "X Y Perp A B ∧ X Z Perp A B"
    hence H1A: "X Y Perp A B" by blast
    have H1B: "X Z Perp A B" using H1 by blast
    obtain C where H2: "C PerpAt X Y A B"
      using H1 Perp_def by blast
    obtain C' where H3: "C' PerpAt X Z A B"
      using H1 Perp_def by blast
    have "Col X Y Z"
    proof cases
      assume H2: "Col A B X"
      {
        assume "X = A"
        hence "Col X Y Z" using upper_dim_implies_col_perp2__col
          by (metis H1 H2 Perp_cases assms col_permutation_1)
      }
      hence P1: "X = A ⟶ Col X Y Z" by blast
      {
        assume P2: "X ≠ A"
        hence P3: "A B Perp X Y" using perp_sym
          using H1 Perp_perm by blast
        have "Col A B X"
          by (simp add: H2)
        hence P4: "A X Perp X Y" using perp_col
          using P2 P3 by auto
        have P5: "A X Perp X Z"
          by (metis H1 H2 P2 Perp_perm col_trivial_3 perp_col0)
        have P6: "Col Y Z X"
        proof -
          have Q1: "upper_dim_axiom"
            by (simp add: assms)
          have Q2: "Per Y X A"
            using P4 Perp_cases perp_per_2 by blast
          have "Per Z X A"
            by (meson P5 Perp_cases Tarski_neutral_dimensionless_axioms perp_per_2)
          thus ?thesis using Q1 Q2 P2
            using upper_dim_implies_per2__col by blast
        qed
        hence "Col X Y Z"
          using Col_perm by blast
      }
      thus ?thesis
        using P1 by blast
    next
      assume T1: "¬ Col A B X"
      obtain Y0 where Q3: "Y0 PerpAt X Y A B"
        using H1 Perp_def by blast
      obtain Z0 where Q4: "Z0 PerpAt X Z A B"
        using Perp_def H1 by blast
      have Q5: "X Y0 Perp A B"
      proof -
        have R1: "X ≠ Y0"
          using Q3 T1 perp_in_col by blast
        have R2: "X Y Perp A B"
          by (simp add: H1A)
        thus ?thesis using R1
          using Q3 perp_col perp_in_col by blast
      qed
      have "X Z0 Perp A B"
        by (metis H1B Q4 T1 perp_col perp_in_col)
      hence Q7: "Y0 = Z0"
        by (meson Q3 Q4 Q5 T1 Perp_perm Tarski_neutral_dimensionless_axioms 
            l8_18_uniqueness perp_in_col)
      have "Col X Y Z"
      proof -
        have "X ≠ Y0"
          using Q5 perp_distinct by auto
        moreover have "Col X Y0 Y"
          using Q3 not_col_permutation_5 perp_in_col by blast
        moreover have "Col X Y0 Z"
          using Q4 Q7 col_permutation_5 perp_in_col by blast
        ultimately show ?thesis
          using col_transitivity_1 by blast
      qed
      thus ?thesis 
        using l8_18_uniqueness Perp_cases T1 col_trivial_3 perp_col1 perp_in_col perp_not_col 
        by blast
    qed
  }
  thus ?thesis by blast
qed

lemma upper_dim_implies_not_two_sides_one_side_aux:
  assumes "upper_dim_axiom"
  shows "∀ A B X Y PX. (A ≠ B ∧ PX ≠ A ∧ A B Perp X PX ∧ Col A B PX ∧ 
                        ¬ Col X A B ∧ ¬ Col Y A B ∧ ¬ A B TS X Y) ⟶ A B OS X Y"
proof -
  {
    fix A B X Y PX
    assume "A ≠ B" and "PX ≠ A" and "A B Perp X PX" and 
      "Col A B PX" and "¬ Col X A B" and 
      "¬ Col Y A B" and "¬ A B TS X Y"
    hence "∃ P T. PX A Perp P PX ∧ Col PX A T ∧ Bet Y T P"
      using l8_21 by blast
    then obtain P T where "PX A Perp P PX" and "Col PX A T" and "Bet Y T P"
      by blast
    have "Col P X PX" 
      using upper_dim_implies_col_perp2__col ‹A B Perp X PX› 
        ‹Col A B PX› ‹PX A Perp P PX› assms by blast
    have "¬ Col P A B"
      using col_trivial_2 colx not_col_permutation_3 perp_not_col 
        ‹A ≠ B› ‹Col A B PX› ‹PX A Perp P PX› by blast
    have "PX A TS P Y"
    proof -
      have "¬ Col P PX A" 
        using Col_cases ‹PX A Perp P PX› perp_not_col by blast
      moreover have "¬ Col Y PX A" 
        by (meson ‹Col A B PX› ‹PX ≠ A› ‹¬ Col Y A B› col_transitivity_2 
            not_col_permutation_1)
      moreover have "Col T PX A" 
        using Col_cases ‹Col PX A T› by blast
      moreover have "Bet P T Y" 
        using Bet_cases ‹Bet Y T P› by blast
      ultimately show ?thesis
        using TS_def by blast
    qed
    have "X ≠ PX" 
      using ‹A B Perp X PX› perp_not_eq_2 by auto
    have "P ≠ X" 
      using ‹A ≠ B› ‹Col A B PX› ‹PX A TS P Y› ‹¬ A B TS X Y› 
        col_permutation_2 col_preserves_two_sides not_col_distincts by blast
    have "Bet X PX P ∨ PX Out X P ∨ ¬ Col X PX P"
      using l6_4_2 by blast
    hence "PX A TS P X" 
      using Out_cases TS_def bet__ts between_symmetry 
        col_permutation_1 col_preserves_two_sides col_trivial_2 l9_5 
      by (metis ‹Col A B PX› ‹Col P X PX› ‹PX A TS P Y› ‹X ≠ PX› 
          ‹¬ A B TS X Y› ‹¬ Col P A B›)
    hence "A B OS X Y" 
      using col2_os__os col_trivial_2 l9_2 l9_8_1 not_col_permutation_1 
      by (meson ‹A ≠ B› ‹Col A B PX› ‹PX A TS P Y›)
  }
  thus ?thesis by blast
qed

lemma upper_dim_implies_not_two_sides_one_side:
  assumes "upper_dim_axiom"
  shows "∀ A B X Y. (¬ Col X A B ∧ ¬ Col Y A B ∧ ¬ A B TS X Y) ⟶ A B OS X Y"
proof -
  {
    fix A B X Y
    assume "¬ Col X A B" and "¬ Col Y A B" and "¬ A B TS X Y"
    have "A ≠ B"
      using ‹¬ Col Y A B› col_trivial_2 by blast
    obtain PX where "Col A B PX" and "A B Perp X PX"
      using Col_cases l8_18_existence ‹¬ Col X A B› by blast
    have "A B OS X Y"
    proof cases
      assume "PX = A"
      have "B A OS X Y"
      proof -
        have "B A Perp X A" 
          using ‹A B Perp X PX› ‹PX = A› perp_left_comm by blast
        moreover have "Col B A A" 
          by (simp add: col_trivial_2)
        moreover have "¬ Col X B A" 
          using Col_cases ‹¬ Col X A B› by blast
        moreover have "¬ Col Y B A"
          using Col_cases ‹¬ Col Y A B› by blast
        moreover have "¬ B A TS X Y" 
          using ‹¬ A B TS X Y› invert_two_sides by blast
        ultimately show ?thesis 
          by (metis ‹A ≠ B› assms upper_dim_implies_not_two_sides_one_side_aux)
      qed
      thus ?thesis
        by (simp add: invert_one_side)
    next
      assume "PX ≠ A"
      thus ?thesis 
        using ‹A B Perp X PX› ‹A ≠ B› ‹Col A B PX› ‹¬ A B TS X Y› 
          ‹¬ Col X A B› ‹¬ Col Y A B› assms 
          upper_dim_implies_not_two_sides_one_side_aux by blast
    qed
  }
  thus ?thesis by blast
qed

lemma upper_dim_implies_not_one_side_two_sides:
  assumes "upper_dim_axiom"
  shows "∀ A B X Y. (¬ Col X A B ∧ ¬ Col Y A B ∧ ¬ A B OS X Y) ⟶ A B TS X Y"
  using assms upper_dim_implies_not_two_sides_one_side by blast

lemma upper_dim_implies_one_or_two_sides:
  assumes "upper_dim_axiom"
  shows "∀ A B X Y. (¬ Col X A B ∧ ¬ Col Y A B) ⟶ (A B TS X Y ∨ A B OS X Y)"
  using assms upper_dim_implies_not_two_sides_one_side by blast

lemma upper_dim_implies_all_coplanar:
  assumes "upper_dim_axiom"
  shows "all_coplanar_axiom"
  using all_coplanar_axiom_def assms upper_dim_axiom_def by auto

lemma all_coplanar_implies_upper_dim:
  assumes "all_coplanar_axiom"
  shows "upper_dim_axiom"
  using all_coplanar_axiom_def assms upper_dim_axiom_def by auto

lemma all_coplanar_upper_dim:
  shows "all_coplanar_axiom ⟷ upper_dim_axiom"
  using all_coplanar_implies_upper_dim upper_dim_implies_all_coplanar by auto

lemma upper_dim_stab:
  shows "¬ ¬ upper_dim_axiom ⟶ upper_dim_axiom" 
  by blast

lemma cop__cong_on_bissect:
  assumes "Coplanar A B X P" and
    "M Midpoint A B" and
    "M PerpAt A B P M" and
    "Cong X A X B"
  shows "Col M P X"
proof -
  have "X = M ∨ ¬ Col A B X ∧ M PerpAt X M A B"
    using assms(2) assms(3) assms(4) cong_commutativity cong_perp_or_mid 
      perp_in_distinct by blast
  moreover
  {
    assume "¬ Col A B X" and "M PerpAt X M A B"
    hence "X M Perp A B"
      using perp_in_perp by blast
    have "A B Perp P M"
      using assms(3) perp_in_perp by blast
    have "Col M A B"
      by (simp add: assms(2) midpoint_col)
    hence "Col M P X" 
      using cop_perp2__col Perp_perm ‹A B Perp P M› ‹X M Perp A B› assms(1) 
        coplanar_perm_1 by blast
  }
  ultimately show ?thesis 
    using not_col_distincts by blast
qed

lemma cong_cop_mid_perp__col:
  assumes "Coplanar A B X P" and
    "Cong A X B X" and
    "M Midpoint A B" and
    "A B Perp P M"
  shows "Col M P X"
proof -
  have "M PerpAt A B P M"
    using Col_perm assms(3) assms(4) bet_col l8_15_1 midpoint_bet by blast
  thus ?thesis
    using assms(1) assms(2) assms(3) cop__cong_on_bissect not_cong_2143 by blast
qed

lemma cop_image_in2__col:
  assumes "Coplanar A B P Q" and
    "M ReflectLAt P P' A B" and
    "M ReflectLAt Q Q' A B"
  shows "Col M P Q"
proof -
  have P1: "P P' ReflectL A B"
    using assms(2) image_in_is_image_spec by auto
  hence P2: "A B Perp P' P ∨ P' = P"
    using ReflectL_def by auto
  have P3: "Q Q' ReflectL A B"
    using assms(3) image_in_is_image_spec by blast
  hence P4: "A B Perp Q' Q ∨ Q' = Q"
    using ReflectL_def by auto
  {
    assume S1: "A B Perp P' P ∧ A B Perp Q' Q"
    {
      assume T1: "A = M"
      have T2: "Per B A P"
        by (metis P1 Perp_perm S1 T1 assms(2) image_in_col is_image_is_image_spec l10_14 
            perp_col1 perp_distinct perp_per_1 ts_distincts)
      have T3: "Per B A Q"
        by (metis S1 T1 assms(3) image_in_col l8_5 perp_col1 perp_per_1 perp_right_comm)
      have T4: "Coplanar B P Q A"
        using assms(1) ncoplanar_perm_18 by blast
      have T5: "B ≠ A"
        using S1 perp_distinct by blast
      have T6: "Per P A B"
        by (simp add: T2 l8_2)
      have T7: "Per Q A B"
        using Per_cases T3 by blast
      hence "Col P Q A" using T4 T5 T6
        using cop_per2__col by blast
      hence "Col A P Q"
        using not_col_permutation_1 by blast
      hence "Col M P Q"
        using T1 by blast
    }
    hence S2: "A = M ⟶ Col M P Q" by blast
    {
      assume D0: "A ≠ M"
      have D1: "Per A M P"
      proof -
        have E1: "M Midpoint P P'"
          using ReflectLAt_def assms(2) l7_2 by blast
        have "Cong P A P' A"
          using P1 col_trivial_3 is_image_spec_col_cong by blast
        hence "Cong A P A P'"
          using Cong_perm by blast
        thus ?thesis
          using E1 Per_def by blast
      qed
      have D2: "Per A M Q"
      proof -
        have E2: "M Midpoint Q Q'"
          using ReflectLAt_def assms(3) l7_2 by blast
        have "Cong A Q A Q'"
          using P3 col_trivial_3 cong_commutativity is_image_spec_col_cong by blast
        thus ?thesis
          using E2 Per_def by blast
      qed
      have "Col P Q M"
      proof -
        have W1: "Coplanar P Q A B"
          using assms(1) ncoplanar_perm_16 by blast
        have W2: "A ≠ B"
          using S1 perp_distinct by blast
        have "Col A B M"
          using ReflectLAt_def assms(2) by blast
        hence "Coplanar P Q A M"
          using W1 W2 col2_cop__cop col_trivial_3 by blast
        hence V1: "Coplanar A P Q M"
          using ncoplanar_perm_8 by blast
        have V3: "Per P M A"
          by (simp add: D1 l8_2)
        have "Per Q M A"
          using D2 Per_perm by blast
        thus ?thesis
          using V1 D0 V3 cop_per2__col by blast
      qed
      hence "Col M P Q"
        using Col_perm by blast
    }
    hence "A ≠ M ⟶ Col M P Q" by blast
    hence "Col M P Q"
      using S2 by blast
  }
  hence P5: "(A B Perp P' P ∧ A B Perp Q' Q) ⟶ Col M P Q" by blast
  have P6: "(A B Perp P' P ∧ (Q' = Q)) ⟶ Col M P Q"
    using ReflectLAt_def assms(3) l7_3 not_col_distincts by blast
  have P7: "(P' = P ∧ A B Perp Q' Q) ⟶ Col M P Q"
    using ReflectLAt_def assms(2) l7_3 not_col_distincts by blast
  have "(P' = P ∧ Q' = Q) ⟶ Col M P Q"
    using ReflectLAt_def assms(3) col_trivial_3 l7_3 by blast
  thus ?thesis
    using P2 P4 P5 P6 P7 by blast
qed

lemma l10_10_spec:
  assumes "P' P ReflectL A B" and
    "Q' Q ReflectL A B"
  shows "Cong P Q P' Q'"
proof cases
  assume "A = B"
  thus ?thesis
    using assms(1) assms(2) cong_reflexivity image_spec__eq by blast
next
  assume H1: "A ≠ B"
  obtain X where P1: "X Midpoint P P' ∧ Col A B X"
    using ReflectL_def assms(1) by blast
  obtain Y where P2: "Y Midpoint Q Q' ∧ Col A B Y"
    using ReflectL_def assms(2) by blast
  obtain Z where P3: "Z Midpoint X Y"
    using midpoint_existence by blast
  have P4: "Col A B Z"
  proof cases
    assume "X = Y"
    thus ?thesis
      by (metis P2 P3 midpoint_distinct_3)
  next
    assume "X ≠ Y"
    thus ?thesis
      by (metis P1 P2 P3 l6_21 midpoint_col not_col_distincts)
  qed
  obtain R where P5: "Z Midpoint P R"
    using symmetric_point_construction by blast
  obtain R' where P6: "Z Midpoint P' R'"
    using symmetric_point_construction by blast
  have P7: "A B Perp P P' ∨ P = P'"
    using ReflectL_def assms(1) by auto
  have P8: "A B Perp Q Q' ∨ Q = Q'"
    using ReflectL_def assms(2) by blast
  {
    assume Q1: "A B Perp P P' ∧ A B Perp Q Q'"
    have Q2: "R R' ReflectL A B"
    proof -
      have "P P' Reflect A B"
        by (simp add: H1 assms(1) is_image_is_image_spec l10_4_spec)
      hence "R R' Reflect A B"
        using H1 P4 P5 P6 midpoint_preserves_image by blast
      thus ?thesis
        using H1 is_image_is_image_spec by blast
    qed
    have Q3: "R ≠ R'"
      using P5 P6 Q1 l7_9 perp_not_eq_2 by blast
    have Q4: "Y Midpoint R R'"
      using P1 P3 P5 P6 symmetry_preserves_midpoint by blast
    have Q5: "Cong Q' R' Q R"
      using P2 Q4 l7_13 by blast
    have Q6: "Cong P' Z P Z"
      using P4 assms(1) is_image_spec_col_cong by auto
    have Q7: "Cong Q' Z Q Z"
      using P4 assms(2) is_image_spec_col_cong by blast
    hence "Cong P Q P' Q'"
    proof -
      have S1: "Cong R Z R' Z"
        using P5 P6 Q6 cong_symmetry l7_16 l7_3_2 by blast
      have "R ≠ Z"
        using Q3 S1 cong_reverse_identity by blast
      thus ?thesis
        by (meson P5 P6 Q5 Q6 Q7 S1 between_symmetry five_segment midpoint_bet 
            not_cong_2143 not_cong_3412)
    qed
  }
  hence P9: "(A B Perp P P' ∧ A B Perp Q Q') ⟶ Cong P Q P' Q'" by blast
  have P10: "(A B Perp P P' ∧ Q = Q') ⟶ Cong P Q P' Q'"
    using P2 l7_3 Tarski_neutral_dimensionless_axioms assms(1) cong_symmetry 
      is_image_spec_col_cong by fastforce
  have P11: "(P = P' ∧ A B Perp Q Q') ⟶ Cong P Q P' Q'"
    using P1 l7_3 not_cong_4321 Tarski_neutral_dimensionless_axioms assms(2) 
      is_image_spec_col_cong by fastforce
  have "(P = P' ∧ Q = Q') ⟶ Cong P Q P' Q'"
    using cong_reflexivity by blast
  thus ?thesis
    using P10 P11 P7 P8 P9 by blast
qed

lemma l10_10:
  assumes "P' P Reflect A B" and
    "Q' Q Reflect A B"
  shows "Cong P Q P' Q'"
  using Reflect_def assms(1) assms(2) cong_4321 l10_10_spec l7_13 by auto

lemma image_preserves_bet:
  assumes "A A' ReflectL X Y" and
    "B B' ReflectL X Y" and
    "C C' ReflectL X Y" and
    "Bet A B C"
  shows "Bet A' B' C'"
proof -
  have "A B C Cong3 A' B' C'"
    using Cong3_def assms(1) assms(2) assms(3) l10_10_spec l10_4_spec by blast
  thus ?thesis
    using assms(4) l4_6 by blast
qed

lemma image_gen_preserves_bet:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y" and
    "C C' Reflect X Y" and
    "Bet A B C"
  shows "Bet A' B' C'"
proof cases
  assume "X = Y"
  thus ?thesis 
    by (metis (full_types) assms(1) assms(2) assms(3) assms(4) image__midpoint l7_15 l7_2)
next
  assume "X ≠ Y"
  hence "A A' ReflectL X Y"
    using assms(1) is_image_is_image_spec by blast
  moreover have "B B' ReflectL X Y"
    using assms(2) is_image_is_image_spec ‹X ≠ Y› by blast
  moreover have "C C' ReflectL X Y"
    using assms(3) is_image_is_image_spec ‹X ≠ Y› by blast
  ultimately show ?thesis using image_preserves_bet
    using assms(4) by blast
qed

lemma image_preserves_col:
  assumes "A A' ReflectL X Y" and
    "B B' ReflectL X Y" and
    "C C' ReflectL X Y" and
    "Col A B C"
  shows "Col A' B' C'" using image_preserves_bet
  using Col_def assms(1) assms(2) assms(3) assms(4) by auto

lemma image_gen_preserves_col:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y" and
    "C C' Reflect X Y" and
    "Col A B C"
  shows "Col A' B' C'"
  using Col_def assms(1) assms(2) assms(3) assms(4) image_gen_preserves_bet by auto

lemma image_gen_preserves_ncol:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y" and
    "C C' Reflect X Y" and
    "¬ Col A B C"
  shows "¬ Col A' B' C'"
  using assms(1) assms(2) assms(3) assms(4)image_gen_preserves_col l10_4 by blast

lemma image_gen_preserves_inter:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y" and
    "C C' Reflect X Y" and
    "D D' Reflect X Y" and
    "¬ Col A B C" and
    "C ≠ D" and
    "Col A B I" and
    "Col C D I" and
    "Col A' B' I'" and
    "Col C' D' I'"
  shows "I I' Reflect X Y"
proof -
  obtain I0 where "I I0 Reflect X Y"
    using l10_6_existence by blast
  have "I0 = I'" 
  proof -
    have "¬ Col A' B' C'" 
      by (meson assms(1) assms(2) assms(3) assms(5) image_gen_preserves_col l10_4)
    moreover have "C' ≠ D'" 
      using assms(3) assms(4) assms(6) l10_2_uniqueness by blast
    moreover have "Col A' B' I0" 
      using ‹I I0 Reflect X Y› assms(1) assms(2) assms(7) image_gen_preserves_col by auto
    moreover have "Col C' D' I0" 
      using ‹I I0 Reflect X Y› assms(3) assms(4) assms(8) image_gen_preserves_col by auto
    ultimately show ?thesis 
      using assms(10) assms(9) l6_21 by blast
  qed
  thus ?thesis 
    using ‹I I0 Reflect X Y› by blast
qed

lemma intersection_with_image_gen:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y" and
    "¬ Col A B A'" and
    "Col A B C" and
    "Col A' B' C"
  shows "Col C X Y"
proof -
  have "C C Reflect X Y" 
  proof -
    have "A' A Reflect X Y" 
      using assms(1) l10_4 by blast
    moreover have "B' B Reflect X Y" 
      by (simp add: assms(2) l10_4)
    moreover have "¬ Col A' B' A" 
      by (meson image_gen_preserves_col assms(1) assms(2) assms(3) l10_4)
    moreover have "A' ≠ B'" 
      using calculation(3) col_trivial_1 by blast
    ultimately show ?thesis
      using image_gen_preserves_inter assms(1) assms(2) assms(3) assms(4) assms(5) by blast
  qed
  thus ?thesis 
    using l10_8 by blast
qed

lemma image_preserves_midpoint :
  assumes "A A' ReflectL X Y" and
    "B B' ReflectL X Y" and
    "C C' ReflectL X Y" and
    "A Midpoint B C"
  shows "A' Midpoint B' C'"
proof -
  have "Bet B' A' C'" using image_preserves_bet
    using assms(1) assms(2) assms(3) assms(4) midpoint_bet by auto
  moreover
  have "Cong B' A' A' C'" 
  proof -
    let ?C = "B"
    let ?D = "A"
    have "Cong B' A' ?C ?D" 
      using assms(1) assms(2) l10_10_spec by auto
    moreover have "Cong ?C ?D A' C'" 
    proof -
      let ?C' = "A"
      let ?D' = "C"
      have "Cong B A ?C' ?D'" 
        using Midpoint_def assms(4) by auto
      moreover have "Cong ?C' ?D' A' C'" 
        using assms(1) assms(3) cong_4321 l10_10_spec by blast
      ultimately show ?thesis 
        using cong_transitivity by blast
    qed
    ultimately show ?thesis 
      using cong_transitivity by blast
  qed
  ultimately show ?thesis
    by (simp add: Midpoint_def)
qed

lemma image_spec_preserves_per:
  assumes "A A' ReflectL X Y" and
    "B B' ReflectL X Y" and
    "C C' ReflectL X Y" and
    "Per A B C"
  shows "Per A' B' C'"
proof cases
  assume "X = Y"
  thus ?thesis
    using assms(1) assms(2) assms(3) assms(4) image_spec__eq by blast
next
  assume P1: "X ≠ Y"
  obtain C1 where P2: "B Midpoint C C1"
    using symmetric_point_construction by blast
  obtain C1' where P3: "C1 C1' ReflectL X Y"
    by (meson P1 l10_6_existence_spec)
  hence P4: "B' Midpoint C' C1'"
    using P2 assms(2) assms(3) image_preserves_midpoint by blast
  have "Cong A' C' A' C1'"
  proof -
    have Q1: "Cong A' C' A C"
      using assms(1) assms(3) l10_10_spec by auto
    have "Cong A C A' C1'"
      by (metis P2 P3 l10_10_spec assms(1) assms(4) cong_inner_transitivity cong_symmetry 
          per_double_cong)
    thus ?thesis
      using Q1 cong_transitivity by blast
  qed
  thus ?thesis
    using P4 Per_def by blast
qed

lemma image_preserves_per:
  assumes "A A' Reflect X Y" and
    "B B' Reflect X Y"and
    "C C' Reflect X Y" and
    "Per A B C"
  shows "Per A' B' C'"
proof cases
  assume "X = Y"
  thus ?thesis using midpoint_preserves_per
    using assms(1) assms(2) assms(3) assms(4) image__midpoint l7_2  by blast
next
  assume P1: "X ≠ Y"
  have P2: "X ≠ Y ∧ A A' ReflectL X Y"
    using P1 assms(1) is_image_is_image_spec by blast
  have P3: "X ≠ Y ∧ B B' ReflectL X Y"
    using P1 assms(2) is_image_is_image_spec by blast
  have P4: "X ≠ Y ∧ C C' ReflectL X Y"
    using P1 assms(3) is_image_is_image_spec by blast
  thus ?thesis using image_spec_preserves_per
    using P2 P3 assms(4) by blast
qed

lemma l10_12:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "Cong A C A' C'"
proof cases
  assume P1: "B = C"
  hence "B' = C'"
    using assms(4) cong_reverse_identity by blast
  thus ?thesis
    using P1 assms(3) by blast
next
  assume P2: "B ≠ C"
  have "Cong A C A' C'"
  proof cases
    assume "A = B"
    thus ?thesis
      using assms(3) assms(4) cong_diff_3 by force
  next
    assume P3: "A ≠ B"
    obtain X where P4: "X Midpoint B B'"
      using midpoint_existence by blast
    obtain A1 where P5: "X Midpoint A' A1"
      using Mid_perm symmetric_point_construction by blast
    obtain C1 where P6: "X Midpoint C' C1"
      using Mid_perm symmetric_point_construction by blast
    have Q1: "A' B' C' Cong3 A1 B C1"
      using Cong3_def P4 P5 P6 l7_13 l7_2 by blast
    have Q2: "Per A1 B C1"
      using assms(2)Q1 l8_10  by blast
    have Q3: "Cong A B A1 B"
      by (metis Cong3_def Q1 cong_symmetry assms(3) cong_inner_transitivity)
    have Q4: "Cong B C B C1"
      by (metis Cong3_def Q1 cong_symmetry assms(4) cong_inner_transitivity)
    obtain Y where P7: "Y Midpoint C C1"
      using midpoint_existence by auto
    hence R1: "C1 C Reflect B Y" using cong_midpoint__image
      using Q4 by blast
    obtain A2 where R2: "A1 A2 Reflect B Y"
      using l10_6_existence by blast
    have R3: "Cong C A2 C1 A1"
      using R1 R2 l10_10 by blast
    have R5: "B B Reflect B Y"
      using image_triv by blast
    have R6: "Per A2 B C" using image_preserves_per
      using Q2 R1 R2 image_triv by blast
    have R7: "Cong A B A2 B"
      using l10_10 Cong_perm Q3 R2 cong_transitivity image_triv by blast
    obtain Z where R7A: "Z Midpoint A A2"
      using midpoint_existence by blast
    have "Cong B A B A2"
      using Cong_perm R7 by blast
    hence T1: "A2 A Reflect B Z" using  R7A cong_midpoint__image
      by blast
    obtain C0 where T2: "B Midpoint C C0"
      using symmetric_point_construction by blast
    have T3: "Cong A C A C0"
      using T2 assms(1) per_double_cong by blast
    have T4: "Cong A2 C A2 C0"
      using R6 T2 per_double_cong by blast
    have T5: "C0 C Reflect B Z"
    proof -
      have "C0 C Reflect Z B"
      proof cases
        assume "A = A2"
        thus ?thesis
          by (metis R7A T2 T3 cong_midpoint__image midpoint_distinct_3)
      next
        assume "A ≠ A2"
        thus ?thesis using l4_17 cong_midpoint__image
          by (metis R7A T2 T3 T4 midpoint_col not_col_permutation_3)
      qed
      thus ?thesis
        using is_image_rev by blast
    qed
    have T6: "Cong A C A2 C0"
      using T1 T5 l10_10 by auto
    have R4: "Cong A C A2 C"
      by (metis T4 T6 cong_symmetry cong_inner_transitivity)
    hence Q5: "Cong A C A1 C1"
      by (meson R3 cong_inner_transitivity not_cong_3421)
    thus ?thesis
      using Cong3_def Q1 Q5 cong_symmetry cong_transitivity by blast
  qed
  thus ?thesis by blast
qed

lemma l10_16:
  assumes "¬ Col A B C" and
    "¬ Col A' B' P" and
    "Cong A B A' B'"
  shows "∃ C'. A B C Cong3 A' B' C' ∧ A' B' OS P C'"
proof cases
  assume "A = B"
  thus ?thesis
    using assms(1) not_col_distincts by auto
next
  assume P1: "A ≠ B"
  obtain X where P2: "Col A B X ∧ A B Perp C X"
    using assms(1) l8_18_existence by blast
  obtain X' where P3: "A B X Cong3 A' B' X'"
    using P2 assms(3) l4_14 by blast
  obtain Q where P4: "A' B' Perp Q X' ∧ A' B' OS P Q"
    using P2 P3 assms(2) l10_15 l4_13 by blast
  obtain C' where P5: "X' Out C' Q ∧ Cong X' C' X C"
    by (metis P2 P4 l6_11_existence perp_distinct)
  have P6: "Cong A C A' C'"
  proof cases
    assume "A = X"
    thus ?thesis
      by (metis Cong3_def P3 P5 cong_4321 cong_commutativity cong_diff_3)
  next
    assume "A ≠ X"
    have P7: "Per A X C"
      using P2 col_trivial_3 l8_16_1 l8_2 by blast
    have P8: "Per A' X' C'"
    proof -
      have "X' PerpAt A' X' X' C'"
      proof -
        have Z1: "A' X' Perp X' C'"
        proof -
          have W1: "X' ≠ C'"
            using P5 out_distinct by blast
          have W2: "X' Q Perp A' B'"
            using P4 Perp_perm by blast
          hence "X' C' Perp A' B'"
            by (metis P5 Perp_perm W1 col_trivial_3 not_col_permutation_5 out_col perp_col2_bis)
          thus ?thesis
            by (metis Cong3_def P2 P3 Perp_perm ‹A ≠ X› col_trivial_3 cong_identity 
                l4_13 perp_col2_bis)
        qed
        have Z2: "Col X' A' X'"
          using not_col_distincts by blast
        have "Col X' X' C'"
          by (simp add: col_trivial_1)
        thus ?thesis
          by (simp add: Z1 Z2 l8_14_2_1b_bis)
      qed
      thus ?thesis
        by (simp add: perp_in_per)
    qed
    have P9: "Cong A X A' X'"
      using Cong3_def P3 by auto
    have "Cong X C X' C'"
      using Cong_perm P5 by blast
    thus ?thesis using l10_12
      using P7 P8 P9 by blast
  qed
  have P10: "Cong B C B' C'"
  proof cases
    assume "B = X"
    thus ?thesis
      by (metis Cong3_def P3 P5 cong_4321 cong_commutativity cong_diff_3)
  next
    assume "B ≠ X"
    have Q1: "Per B X C"
      using P2 col_trivial_2 l8_16_1 l8_2 by blast
    have "X' PerpAt B' X' X' C'"
    proof -
      have Q2: "B' X' Perp X' C'"
      proof -
        have R1: "B' ≠ X'"
          using Cong3_def P3 ‹B ≠ X› cong_identity by blast
        have "X' C' Perp B' A'"
        proof -
          have S1: "X' ≠ C'"
            using Out_def P5 by blast
          have S2: "X' Q Perp B' A'"
            using P4 Perp_perm by blast
          have "Col X' Q C'"
            using Col_perm P5 out_col by blast
          thus ?thesis
            using S1 S2 perp_col by blast
        qed
        hence R2: "B' A' Perp X' C'"
          using Perp_perm by blast
        have R3: "Col B' A' X'"
          using Col_perm P2 P3 l4_13 by blast
        thus ?thesis
          using R1 R2 perp_col by blast
      qed
      have Q3: "Col X' B' X'"
        by (simp add: col_trivial_3)
      have "Col X' X' C'"
        by (simp add: col_trivial_1)
      thus ?thesis using l8_14_2_1b_bis
        using Q2 Q3 by blast
    qed
    hence Q2: "Per B' X' C'"
      by (simp add: perp_in_per)
    have Q3: "Cong B X B' X'"
      using Cong3_def P3 by blast
    have Q4: "Cong X C X' C'"
      using P5 not_cong_3412 by blast
    thus ?thesis
      using Q1 Q2 Q3 l10_12 by blast
  qed
  have P12: "A' B' OS C' Q ⟷ X' Out C' Q ∧ ¬ Col A' B' C'" using l9_19 l4_13
    by (meson P2 P3 P5 one_side_not_col123 out_one_side_1)
  hence P13: "A' B' OS C' Q" using l4_13
    by (meson P2 P3 P4 P5 l6_6 one_side_not_col124 out_one_side_1)
  thus ?thesis
    using Cong3_def P10 P4 P6 assms(3) one_side_symmetry one_side_transitivity by blast
qed

lemma cong_cop_image__col:
  assumes "P ≠ P'" and
    "P P' Reflect A B" and
    "Cong P X P' X" and
    "Coplanar A B P X"
  shows "Col A B X"
proof -
  have P1: "(A ≠ B ∧ P P' ReflectL A B) ∨ (A = B ∧ A Midpoint P' P)"
    by (metis assms(2) image__midpoint is_image_is_image_spec)
  {
    assume Q1: "A ≠ B ∧ P P' ReflectL A B"
    then obtain M where Q2: "M Midpoint P' P ∧ Col A B M"
      using ReflectL_def by blast
    have "Col A B X"
    proof cases
      assume R1: "A = M"
      have R2: "P A Perp A B"
      proof -
        have S1: "P ≠ A"
          using Q2 R1 assms(1) midpoint_distinct_2 by blast
        have S2: "P P' Perp A B"
          using Perp_perm Q1 ReflectL_def assms(1) by blast
        have "Col P P' A"
          using Q2 R1 midpoint_col not_col_permutation_3 by blast
        thus ?thesis using perp_col
          using S1 S2 by blast
      qed
      have R3: "Per P A B"
        by (simp add: R2 perp_comm perp_per_1)
      hence R3A: "Per B A P" using l8_2
        by blast
      have "A Midpoint P P' ∧ Cong X P X P'"
        using Cong_cases Q2 R1 assms(3) l7_2 by blast
      hence R4: "Per X A P"
        using Per_def by blast
      have R5: "Coplanar P B X A"
        using assms(4) ncoplanar_perm_20 by blast
      have "P ≠ A"
        using R2 perp_not_eq_1 by auto
      thus ?thesis using R4 R5 R3A
        using cop_per2__col not_col_permutation_1 by blast
    next
      assume T1: "A ≠ M"
      have T3: "P ≠ M"
        using Q2 assms(1) l7_3_2 sym_preserve_diff by blast
      have T2: "P M Perp M A"
      proof -
        have T4: "P P' Perp M A"
          using Perp_perm Q1 Q2 ReflectL_def T1 assms(1) col_trivial_3 perp_col0 by blast
        have "Col P P' M"
          by (simp add: Col_perm Q2 midpoint_col)
        thus ?thesis using T3 T4 perp_col by blast
      qed
      hence "M P Perp A M"
        using perp_comm by blast
      hence "M PerpAt M P A M"
        using perp_perp_in by blast
      hence "M PerpAt P M M A"
        by (simp add: perp_in_comm)
      hence U1: "Per P M A"
        by (simp add: perp_in_per)
      have U2: "Per X M P" using l7_2 cong_commutativity
        using Per_def Q2 assms(3) by blast
      have "Col A X M"
      proof -
        have W2: "Coplanar P A X M"
          by (meson Q1 Q2 assms(4) col_cop2__cop coplanar_perm_13 ncop_distincts)
        have "Per A M P"
          by (simp add: U1 l8_2)
        thus ?thesis using cop_per2__col
          using U2 T3 W2 by blast
      qed
      thus ?thesis
        using Q2 T1 col2__eq not_col_permutation_4 by blast
    qed
  }
  hence P2: "(A ≠ B ∧ P P' ReflectL A B) ⟶ Col A B X" by blast
  have "(A = B ∧ A Midpoint P' P) ⟶ Col A B X"
    using col_trivial_1 by blast
  thus ?thesis using P1 P2 by blast
qed

lemma cong_cop_per2_1:
  assumes "A ≠ B" and
    "Per A B X" and
    "Per A B Y" and
    "Cong B X B Y" and
    "Coplanar A B X Y"
  shows "X = Y ∨ B Midpoint X Y"
  by (meson Per_cases assms(1) assms(2) assms(3) assms(4) assms(5) cop_per2__col 
      coplanar_perm_3 l7_20_bis not_col_permutation_5)

lemma cong_cop_per2:
  assumes "A ≠ B" and
    "Per A B X" and
    "Per A B Y" and
    "Cong B X B Y" and
    "Coplanar A B X Y"
  shows "X = Y ∨ X Y ReflectL A B"
proof -
  have "X = Y ∨ B Midpoint X Y"
    using assms(1) assms(2) assms(3) assms(4) assms(5) cong_cop_per2_1 by blast
  thus ?thesis
    by (metis Mid_perm Per_def Reflect_def assms(1) assms(3) cong_midpoint__image 
        symmetric_point_uniqueness)
qed

lemma cong_cop_per2_gen:
  assumes "A ≠ B" and
    "Per A B X" and
    "Per A B Y" and
    "Cong B X B Y" and
    "Coplanar A B X Y"
  shows "X = Y ∨ X Y Reflect A B"
proof -
  have "X = Y ∨ B Midpoint X Y"
    using assms(1) assms(2) assms(3) assms(4) assms(5) cong_cop_per2_1 by blast
  thus ?thesis
    using assms(2) cong_midpoint__image l10_4 per_double_cong by blast
qed

lemma ex_perp_cop:
  assumes "A ≠ B"
  shows "∃ Q. A B Perp Q C ∧ Coplanar A B P Q"
proof -
  {
    assume "Col A B C ∧ Col A B P"
    hence "∃ Q. A B Perp Q C ∧ Coplanar A B P Q"
      using assms ex_ncol_cop l10_15 ncop__ncols by blast
  }
  hence T1: "(Col A B C ∧ Col A B P) ⟶
(∃ Q. A B Perp Q C ∧ Coplanar A B P Q)" by blast
  {
    assume "¬Col A B C ∧ Col A B P"
    hence "∃ Q. A B Perp Q C ∧ Coplanar A B P Q"
      by (metis Perp_cases ncop__ncols not_col_distincts perp_exists)
  }
  hence T2: "(¬Col A B C ∧ Col A B P) ⟶
(∃ Q. A B Perp Q C ∧ Coplanar A B P Q)" by blast
  {
    assume "Col A B C ∧ ¬Col A B P"
    hence "∃ Q. A B Perp Q C ∧ Coplanar A B P Q"
      using l10_15 os__coplanar by blast
  }
  hence T3: "(Col A B C ∧ ¬Col A B P) ⟶
(∃ Q. A B Perp Q C ∧ Coplanar A B P Q)" by blast
  {
    assume "¬Col A B C ∧ ¬Col A B P"
    hence "∃ Q. A B Perp Q C ∧ Coplanar A B P Q"
      using l8_18_existence ncop__ncols perp_right_comm by blast
  }
  hence "(¬Col A B C ∧ ¬Col A B P) ⟶
(∃ Q. A B Perp Q C ∧ Coplanar A B P Q)" by blast
  thus ?thesis using T1 T2 T3 by blast
qed

lemma hilbert_s_version_of_pasch_aux:
  assumes "Coplanar A B C P" and
    "¬ Col A I P" and
    "¬ Col B C P" and
    "Bet B I C" and
    "B ≠ I" and
    "I ≠ C" and
    "B ≠ C"
  shows "∃ X. Col I P X ∧ 
((Bet A X B ∧ A ≠ X ∧ X ≠ B ∧ A ≠ B) ∨ (Bet A X C ∧ A ≠ X ∧ X ≠ C ∧ A ≠ C))"
proof -
  have T1: "I P TS B C"
    using Col_perm assms(3) assms(4) assms(5) assms(6) bet__ts bet_col 
      col_transitivity_1 by blast
  have T2: "Coplanar A P B I"
    using assms(1) assms(4) bet_cop__cop coplanar_perm_6 ncoplanar_perm_9 by blast
  have T3: "I P TS A B ∨ I P TS A C"
    by (meson T1 T2 TS_def assms(2) cop_nos__ts coplanar_perm_21 l9_2 l9_8_2)
  have T4: "I P TS A B ⟶ (∃ X. Col I P X ∧
((Bet A X B ∧ A ≠ X ∧ X ≠ B ∧ A ≠ B) ∨ (Bet A X C ∧ A ≠ X ∧ X ≠ C ∧ A ≠ C)))"
    by (metis TS_def not_col_permutation_2 ts_distincts)
  have "I P TS A C ⟶ (∃ X. Col I P X ∧
((Bet A X B ∧ A ≠ X ∧ X ≠ B ∧ A ≠ B) ∨ (Bet A X C ∧ A ≠ X ∧ X ≠ C ∧ A ≠ C)))"
    by (metis TS_def not_col_permutation_2 ts_distincts)
  thus ?thesis using T3 T4 by blast
qed

lemma hilbert_s_version_of_pasch:
  assumes "Coplanar A B C P" and
    "¬ Col C Q P" and
    "¬ Col A B P" and
    "BetS A Q B"
  shows "∃ X. Col P Q X ∧ (BetS A X C ∨ BetS B X C)"
proof -
  obtain X where "Col Q P X ∧
(Bet C X A ∧ C ≠ X ∧ X ≠ A ∧ C ≠ A ∨ Bet C X B ∧ C ≠ X ∧ X ≠ B ∧ C ≠ B)"
    using BetSEq assms(1) assms(2) assms(3) assms(4) coplanar_perm_12 
      hilbert_s_version_of_pasch_aux by fastforce
  thus ?thesis
    by (metis BetS_def Bet_cases Col_perm)
qed

lemma two_sides_cases:
  assumes "¬ Col PO A B" and
    "PO P OS A B"
  shows  "PO A TS P B ∨ PO B TS P A"
  by (meson assms(1) assms(2) cop_nts__os l9_31 ncoplanar_perm_3 not_col_permutation_4 
      one_side_not_col124 one_side_symmetry os__coplanar)

lemma not_par_two_sides:
  assumes "C ≠ D" and
    "Col A B I" and
    "Col C D I" and
    "¬ Col A B C"
  shows "∃ X Y. Col C D X ∧ Col C D Y ∧ A B TS X Y"
proof -
  obtain pp :: "'p ⇒ 'p ⇒ 'p" where
    f1: "∀p pa. Bet p pa (pp p pa) ∧ pa ≠ (pp p pa)"
    by (meson point_construction_different)
  hence f2: "∀p pa pb pc. (Col pc pb p ∨ ¬ Col pc pb (pp p pa)) ∨ ¬ Col pc pb pa"
    by (meson Col_def colx)
  have f3: "∀p pa. Col pa p pa"
    by (meson Col_def between_trivial)
  have f4: "∀p pa. Col pa p p"
    by (meson Col_def between_trivial)
  have f5: "Col I D C"
    by (meson Col_perm assms(3))
  have f6: "∀p pa. Col (pp pa p) p pa"
    using f4 f3 f2 by blast
  hence f7: "∀p pa. Col pa (pp pa p) p"
    by (meson Col_perm)
  hence f8: "∀p pa pb pc. (pc pb TS p (pp p pa) ∨ Col pc pb p) ∨ ¬ Col pc pb pa"
    using f2 f1 by (meson l9_18)
  have "I = D ∨ Col D (pp D I) C"
    using f7 f5 f3 colx by blast
  hence "I = D ∨ Col C D (pp D I)"
    using Col_perm by blast
  thus ?thesis
    using f8 f6 f3 by (metis Col_perm assms(2) assms(4))
qed

lemma cop_not_par_other_side:
  assumes "C ≠ D" and
    "Col A B I" and
    "Col C D I" and
    "¬ Col A B C" and
    "¬ Col A B P" and
    "Coplanar A B C P"
  shows "∃ Q. Col C D Q ∧ A B TS P Q"
proof -
  obtain X Y where P1:"Col C D X ∧ Col C D Y ∧ A B TS X Y"
    using assms(1) assms(2) assms(3) assms(4) not_par_two_sides by blast
  hence "Coplanar C A B X"
    using Coplanar_def assms(1) assms(2) assms(3) col_transitivity_1 by blast
  hence "Coplanar A B P X"
    using assms(4) assms(6) col_permutation_3 coplanar_trans_1 ncoplanar_perm_2 
      ncoplanar_perm_6 by blast
  thus ?thesis
    by (meson P1 l9_8_2 TS_def assms(5) cop_nts__os not_col_permutation_2 one_side_symmetry)
qed

lemma cop_not_par_same_side:
  assumes "C ≠ D" and
    "Col A B I" and
    "Col C D I" and
    "¬ Col A B C" and
    "¬ Col A B P" and
    "Coplanar A B C P"
  shows "∃ Q. Col C D Q ∧ A B OS P Q"
proof -
  obtain X Y where P1: "Col C D X ∧ Col C D Y ∧ A B TS X Y"
    using assms(1) assms(2) assms(3) assms(4) not_par_two_sides by blast
  hence "Coplanar C A B X"
    using Coplanar_def assms(1) assms(2) assms(3) col_transitivity_1 by blast
  hence "Coplanar A B P X"
    using assms(4) assms(6) col_permutation_1 coplanar_perm_2 coplanar_trans_1 
      ncoplanar_perm_14 by blast
  thus ?thesis
    by (meson P1 TS_def assms(5) cop_nts__os l9_2 l9_8_1 not_col_permutation_2)
qed

lemma perp_bisect_equiv_defA:
  assumes "P Q PerpBisect A B"
  shows "P Q PerpBisectBis A B" 
proof -
  have P1: "A B ReflectL P Q ∧ A ≠ B"
    using Perp_bisect_def assms by auto 
  then obtain X where P2: "X Midpoint B A ∧ Col P Q X" 
    using ReflectL_def by auto 
  have "P Q Perp B A ∨ B = A" 
    using P1 ReflectL_def by auto
  have "X Midpoint A B"
    using P2 l7_2 by blast 
  moreover
  have "X PerpAt P Q A B"
    using P1 P2 ‹P Q Perp B A ∨ B = A› calculation col_permutation_2 l8_14_2_1b_bis 
      midpoint_col perp_right_comm by blast 
  ultimately
  show ?thesis
    using Perp_bisect_bis_def by blast 
qed

lemma perp_bisect_equiv_defB:
  assumes "P Q PerpBisectBis A B"
  shows "P Q PerpBisect A B" 
proof -
  obtain I where P1: "I PerpAt P Q A B ∧ I Midpoint A B"
    using Perp_bisect_bis_def assms by blast
  hence "A ≠ B"
    using perp_in_distinct by blast 
  have "P Q Perp B A ∨ B = A"
    using ‹I PerpAt P Q A B ∧ I Midpoint A B› perp_in_perp perp_right_comm by blast
  moreover
  have "I Midpoint B A"
    by (meson Mid_perm P1) 
  moreover
  have "Col P Q I" 
    using P1 by (meson perp_in_col Tarski_neutral_dimensionless_axioms) 
  ultimately
  have "A B ReflectL P Q ∧ A ≠ B" 
    using ReflectL_def ‹A ≠ B› by blast 
  thus ?thesis
    by (simp add: Perp_bisect_def) 
qed

lemma perp_bisect_equiv_def:
  shows "P Q PerpBisect A B ⟷ P Q PerpBisectBis A B"
  using perp_bisect_equiv_defA perp_bisect_equiv_defB by blast 

lemma perp_bisect_sym_1:
  assumes "P Q PerpBisect A B"
  shows "Q P PerpBisect A B" 
proof -
  have "P Q PerpBisectBis A B"
    by (simp add: assms perp_bisect_equiv_defA)
  then obtain x where "x PerpAt P Q A B ∧ x Midpoint A B"
    using Perp_bisect_bis_def by blast
  hence "Q P PerpBisectBis A B"
    using Perp_bisect_bis_def Perp_in_cases by blast 
  thus ?thesis
    by (simp add: perp_bisect_equiv_defB)
qed

lemma perp_bisect_sym_2:
  assumes "P Q PerpBisect A B"
  shows "P Q PerpBisect B A" 
proof -
  have "P Q PerpBisectBis A B"
    by (simp add: assms perp_bisect_equiv_defA)
  then obtain x where "x PerpAt P Q A B ∧ x Midpoint A B"
    using Perp_bisect_bis_def by blast
  hence "P Q PerpBisectBis B A"
    using Perp_bisect_bis_def l7_2 perp_in_right_comm by blast 
  thus ?thesis
    by (simp add: perp_bisect_equiv_defB)
qed

lemma perp_bisect_sym_3:
  assumes "A B PerpBisect C D"
  shows "B A PerpBisect D C"
  by (meson assms perp_bisect_sym_1 perp_bisect_sym_2)

lemma perp_bisect_perp:
  assumes "P Q PerpBisect A B"
  shows "P Q Perp A B" 
proof -
  have "P Q PerpBisectBis A B"
    by (simp add: assms perp_bisect_equiv_defA)
  then obtain x where "x PerpAt P Q A B ∧ x Midpoint A B"
    using Perp_bisect_bis_def by blast
  thus ?thesis
    using perp_in_perp by blast 
qed

lemma perp_bisect_cong_1:
  assumes "P Q PerpBisect A B"
  shows "Cong A P B P" 
proof -
  have "P Q PerpBisectBis A B"
    using assms perp_bisect_equiv_def by auto 
  then obtain I where "I PerpAt P Q A B ∧ I Midpoint A B"
    using Perp_bisect_bis_def by blast
  hence "Cong P A P B" 
    using per_double_cong perp_in_per_1 by blast 
  thus ?thesis
    using Cong_perm by blast 
qed

lemma perp_bisect_cong_2:
  assumes "P Q PerpBisect A B"
  shows "Cong A Q B Q"
  using assms perp_bisect_cong_1 perp_bisect_sym_1 by blast

lemma perp_bisect_cong2:
  assumes "P Q PerpBisect A B"
  shows "Cong A P B P ∧ Cong A Q B Q"
  using assms perp_bisect_cong_1 perp_bisect_cong_2 by blast 

lemma perp_bisect_cong:
  assumes (*"¬ Col A B C" and
"pO A1 PerpBisect B C" and
"pO B1 PerpBisect A C" and
"pO C1 PerpBisect A B" and*)
    "Cong A pO B pO" and
    "Cong B pO C pO"
  shows "Cong A pO C pO"
  using assms(1) assms(2) cong_transitivity by blast 

lemma cong_cop_perp_bisect:
  assumes "P ≠ Q" and
    "A ≠ B" and
    "Coplanar P Q A B" and
    "Cong A P B P" and
    "Cong A Q B Q"
  shows "P Q PerpBisect A B" 
proof -
  obtain I where "I Midpoint A B"
    using midpoint_existence by blast
  moreover
  have "Bet A I B"
    by (simp add: calculation midpoint_bet) 
  have "Cong A I B I"
    using Cong_perm ‹I Midpoint A B› midpoint_cong by blast
  have "I PerpAt P Q A B" 
  proof -
    have "Per P I A"
      using Per_def assms(4) calculation not_cong_2143 by blast 
    have "A ≠ I"
      using ‹Cong A I B I› assms(2) cong_reverse_identity by blast
    hence "B ≠ I"
      using ‹Cong A I B I› cong_identity by blast 
    thus ?thesis 
    proof cases
      assume "P = I"
      thus ?thesis
        using assms(1) assms(2) assms(5) calculation cong_perp_or_mid perp_in_left_comm by blast 
    next
      assume "P ≠ I"
      have "Col I P Q" 
      proof -
        have "Coplanar A P Q I"
          using ‹Bet A I B› assms(3) bet_cop__cop ncoplanar_perm_8 by blast 
        moreover
        have "Per Q I A"
          using Per_def ‹I Midpoint A B› assms(5) not_cong_2143 by blast 
        ultimately
        show ?thesis
          using ‹A ≠ I› ‹Per P I A› col_permutation_2 cop_per2__col by blast 
      qed
      moreover
      have "Col I A B"
        using ‹Bet A I B› bet_col not_col_permutation_4 by blast 
      ultimately
      show ?thesis 
        by (metis assms(1) assms(2) perp_in_col_perp_in ‹A ≠ I› ‹Bet A I B› ‹P ≠ I› 
            ‹Per P I A› bet_col col_per_perp l8_15_1 l8_2 not_col_permutation_2) 
    qed
  qed
  ultimately 
  show ?thesis
    using Perp_bisect_bis_def perp_bisect_equiv_defB by blast 
qed

lemma cong_mid_perp_bisect:
  assumes "P ≠ Q" and
    "A ≠ B" and
    "Cong A P B P" and
    "Q Midpoint A B"
  shows "P Q PerpBisect A B"
  using Perp_bisect_bis_def assms(1) assms(2) assms(3) assms(4) cong_perp_or_mid 
    perp_bisect_equiv_defB by blast 

lemma perp_bisect_is_on_perp_bisect:
  assumes "P IsOnPerpBisect A B" and
    "P IsOnPerpBisect B C" 
  shows "P IsOnPerpBisect A C"
  by (metis Is_on_perp_bisect_def cong_3421 assms(1) assms(2) cong_transitivity) 

lemma perp_mid_perp_bisect:
  assumes "C Midpoint A B" and
    "C D Perp A B"
  shows "C D PerpBisect A B" 
proof -
  have "C PerpAt C D A B"
    using assms(1) assms(2) l8_14_2_1b_bis midpoint_col not_col_distincts by blast 
  hence "C D PerpBisectBis A B"
    using assms(1) Perp_bisect_bis_def by blast 
  thus ?thesis
    by (simp add: perp_bisect_equiv_defB) 
qed

lemma cong_cop2_perp_bisect_col:
  assumes "Coplanar A C D E" and
    "Coplanar B C D E" and
    "Cong C D C E" and
    "A B PerpBisect D E"
  shows "Col A B C" 
proof -
  have "Cong D A E A"
    using assms(4) perp_bisect_cong2 by blast
  have "A B PerpBisectBis D E"
    by (simp add: assms(4) perp_bisect_equiv_defA)
  then obtain F where P1: "F PerpAt A B D E ∧ F Midpoint D E"
    using Perp_bisect_bis_def by blast  
  hence "Bet D F E ∧ Cong D F F E"
    by (simp add: midpoint_bet midpoint_cong) 
  have "D ≠ E"
    using P1 perp_in_distinct by blast
  have "Col A B F ∧ Col D E F" using perp_in_col
    using P1 by blast
  hence "A B Perp D E"
    using P1 perp_in_perp by blast 
  {
    assume "A ≠ C"
    hence "A C Perp D E"
      using ‹Cong D A E A› ‹D ≠ E› assms(1) assms(3) cong_cop_perp_bisect not_cong_2143 
        perp_bisect_perp by blast 
    hence ?thesis
      using NCol_cases ‹A B Perp D E› assms(2) cop_perp2__col coplanar_perm_23 
        perp_right_comm by blast 
  }
  thus ?thesis
    using col_trivial_3 by blast 
qed

lemma perp_bisect_cop2_existence:
  assumes "A ≠ B"
  shows "∃ P Q. P Q PerpBisect A B ∧ Coplanar A B C P ∧ Coplanar A B C Q" 
proof -
  obtain M where P1: "M Midpoint A B"
    using midpoint_existence by blast
  have "Bet A M B"
    by (simp add: P1 midpoint_bet) 
  obtain Q where P2: "A B Perp Q M ∧ Coplanar A B C Q" 
    using ex_perp_cop assms(1) by blast
  have "A B ReflectL M Q" 
  proof -
    have "M Midpoint B A"
      using P1 l7_2 by blast 
    moreover
    have "Col M Q M"
      by (simp add: col_trivial_3) 
    moreover
    have "M Q Perp B A ∨ B = A"
      by (simp add: P2 Perp_perm Tarski_neutral_dimensionless_axioms) 
    ultimately
    show ?thesis 
      using ReflectL_def col_trivial_3 by blast  
  qed
  moreover
  have "Coplanar A B C M"
    using ‹Bet A M B› bet_col ncop__ncol ncoplanar_perm_4 by blast 
  ultimately
  show ?thesis 
    using assms(1) P2 Perp_bisect_def by blast 
qed

lemma perp_bisect_existence:
  assumes "A ≠ B"
  shows "∃ P Q. P Q PerpBisect A B"
proof -
  obtain P Q where "P Q PerpBisect A B ∧ Coplanar A B C P ∧ Coplanar A B C Q" 
    using perp_bisect_cop2_existence assms(1) by blast
  thus ?thesis by blast
qed

lemma perp_bisect_existence_cop:
  assumes "A ≠ B"
  shows "∃ P Q. P Q PerpBisect A B ∧ Coplanar A B C P ∧ Coplanar A B C Q" 
  using perp_bisect_cop2_existence assms(1) by blast

lemma l11_3:
  assumes "A B C CongA D E F"
  shows "∃ A' C' D' F'. B Out A' A ∧ B Out C C' ∧ 
E Out D' D ∧ E Out F F' ∧ 
A' B C' Cong3 D' E F'"
proof -
  obtain A' C' D' F' where "Bet B A A'" and "Cong A A' E D" and "Bet B C C'" and 
    "Cong C C' E F" and "Bet E D D'" and "Cong D D' B A" and 
    "Bet E F F'" and "Cong F F' B C" and "Cong A' C' D' F'" 
    using CongA_def assms by auto
  hence "A' B C' Cong3 D' E F'"
    by (meson Cong3_def between_symmetry l2_11_b not_cong_1243 not_cong_4312)
  thus ?thesis 
    by (metis CongA_def l6_6 ‹Bet B A A'› ‹Bet B C C'› ‹Bet E D D'› 
        ‹Bet E F F'› assms bet_out)
qed

lemma l11_aux:
  assumes "B Out A A'" and
    "E Out D D'" and
    "Cong B A' E D'" and
    "Bet B A A0" and
    "Bet E D D0" and
    "Cong A A0 E D" and
    "Cong D D0 B A"
  shows "Cong B A0 E D0 ∧ Cong A' A0 D' D0"
proof -
  have "Cong B A0 E D0"
    by (meson Bet_cases assms(4) assms(5) assms(6) assms(7) l2_11_b 
        not_cong_1243 not_cong_4312)
  moreover
  have "Bet E D D' ∨ Bet E D' D"
    using Out_def assms(2) by auto
  moreover
  have "Bet B A A' ∨ Bet B A' A"
    using Out_def assms(1) by auto
  {
    assume "Bet B A A' ∧ Bet E D' D"
    have "Cong A0 A' D0 D'" 
    proof -
      have "Bet B A' A0" 
      proof -
        have "Bet E D' D0" 
        proof -
          let ?C = "D"
          have "Bet E D' ?C" 
            using ‹Bet B A A' ∧ Bet E D' D› by auto
          moreover have "Bet E ?C D0" 
            by (simp add: assms(5))
          ultimately show ?thesis 
            using between_exchange4 by blast
        qed
        moreover have "B Out A' A0" 
          by (metis Out_def ‹Bet B A A' ∧ Bet E D' D› assms(1) assms(4) bet_out l5_1)
        ultimately show ?thesis 
          by (metis cong_preserves_bet  ‹Cong B A0 E D0› assms(3) cong_symmetry)
      qed
      hence "Bet A0 A' B" 
        using Bet_cases by blast
      moreover have "Bet D0 D' E" 
        using Bet_cases ‹Bet B A A' ∧ Bet E D' D› assms(5) between_exchange4 by blast
      ultimately show ?thesis 
        by (meson l4_3 ‹Cong B A0 E D0› assms(3) not_cong_2143)
    qed
    hence "Cong A' A0 D' D0" 
      using not_cong_2143 by blast
  }
  moreover
  {
    assume "Bet B A' A"
    have "E Out D D0"
      using assms(2) assms(5) bet_out out_diff1 by blast
    have "Cong A' A0 D' D0" 
      using assms(2) assms(3) assms(4) between_exchange4 cong_preserves_bet l4_3_1 l6_6 l6_7 
      by (meson ‹Bet B A' A› ‹Cong B A0 E D0› ‹E Out D D0›)
  }
  moreover
  have "Bet B A A' ⟶ Cong A' A0 D' D0" 
    by (metis (no_types, lifting) Out_cases ‹Cong B A0 E D0› assms(1) assms(2) assms(3) 
        assms(4) assms(5) bet_out l6_7 out_cong_cong out_diff1)
  have "Bet E D D' ⟶ Cong A' A0 D' D0" 
    using ‹Bet B A A' ⟶ Cong A' A0 D' D0› ‹Bet B A A' ∨ Bet B A' A› calculation(4) by blast
  moreover have "Bet E D' D ⟶ Cong A' A0 D' D0" 
    using ‹Bet B A A' ∨ Bet B A' A› ‹Bet B A A' ⟶ Cong A' A0 D' D0› calculation(4) by blast
  ultimately show ?thesis 
    using  ‹Cong B A0 E D0› by blast
qed

lemma l11_3_bis:
  assumes "∃ A' C' D' F'. 
(B Out A' A ∧ B Out C' C ∧ E Out D' D ∧ E Out F' F ∧ A' B C' Cong3 D' E F')"
  shows "A B C CongA D E F"
proof -
  obtain A' C' D' F' where "B Out A' A" and "B Out C' C" and "E Out D' D" and
    "E Out F' F" and "A' B C' Cong3 D' E F'"
    using assms by blast
  obtain A0 where "Bet B A A0" and "Cong A A0 E D"
    using segment_construction by blast
  obtain C0 where "Bet B C C0" and "Cong C C0 E F"
    using segment_construction by blast
  obtain D0 where "Bet E D D0" and "Cong D D0 B A"
    using segment_construction by blast
  obtain F0 where "Bet E F F0" and "Cong F F0 B C"
    using segment_construction by blast
  have "A ≠ B ∧ C ≠ B ∧ D ≠ E ∧ F ≠ E" 
    using assms out_diff2 by blast
  moreover
  have "Cong A0 C0 D0 F0"
  proof -
    have "Cong B A0 E D0 ∧ Cong A' A0 D' D0"
    proof -
      have "B Out A A'" 
        by (simp add: ‹B Out A' A› l6_6)
      moreover have "E Out D D'" 
        using Out_cases ‹E Out D' D› by auto
      moreover have "Cong B A' E D'" 
        using Cong3_def ‹A' B C' Cong3 D' E F'› not_cong_2143 by blast
      ultimately show ?thesis 
        using l11_aux  ‹Bet B A A0› ‹Bet E D D0› ‹Cong A A0 E D› ‹Cong D D0 B A› by blast
    qed
    have "Cong B C0 E F0 ∧ Cong C' C0 F' F0"
    proof -
      have "Cong B C0 E F0" 
        by (meson Bet_cases ‹Bet B C C0› ‹Bet E F F0› ‹Cong C C0 E F› ‹Cong F F0 B C› 
            l2_11_b not_cong_1243 not_cong_4321)
      moreover have "Cong C' C0 F' F0" 
        by (meson Cong3_def ‹A' B C' Cong3 D' E F'› ‹B Out C' C› ‹Bet B C C0› ‹Bet E F F0› 
            ‹Cong C C0 E F› ‹Cong F F0 B C› ‹E Out F' F› l11_aux l6_6)
      ultimately show ?thesis     
        by blast
    qed
    have "B A' A0 Cong3 E D' D0" 
      using Cong3_def ‹A' B C' Cong3 D' E F'› ‹Cong B A0 E D0 ∧ Cong A' A0 D' D0› 
        cong_3_swap by blast
    have "B C' C0 Cong3 E F' F0" 
      using Cong3_def ‹A' B C' Cong3 D' E F'› ‹Cong B C0 E F0 ∧ Cong C' C0 F' F0› by blast
    have "Cong C0 A' F0 D'"
    proof -
      have "B C' C0 A' FSC E F' F0 D'"
      proof -
        have "Col B C' C0" 
          by (metis Bet_cases Col_def Out_def ‹B Out C' C› ‹Bet B C C0› bet_out l6_7)
        moreover have "Cong B A' E D'" 
          using Cong3_def ‹B A' A0 Cong3 E D' D0› by presburger
        moreover have "Cong C' A' F' D'" 
          using Cong3_def ‹A' B C' Cong3 D' E F'› not_cong_2143 by blast
        ultimately show ?thesis 
          by (simp add: FSC_def ‹B C' C0 Cong3 E F' F0›)
      qed
      have "B ≠ C'" 
        using ‹B Out C' C› l6_3_1 by blast
      thus ?thesis 
        using ‹B C' C0 A' FSC E F' F0 D'› l4_16 by blast
    qed
    hence "B A' A0 C0 FSC E D' D0 F0" 
      using FSC_def  bet_out l6_7 not_cong_2143 out_col 
      by (meson ‹A ≠ B ∧ C ≠ B ∧ D ≠ E ∧ F ≠ E› ‹B A' A0 Cong3 E D' D0› ‹B Out A' A› 
          ‹Bet B A A0› ‹Cong B C0 E F0 ∧ Cong C' C0 F' F0›)
    moreover
    have "B ≠ A'" 
      using ‹B Out A' A› out_distinct by blast
    ultimately show ?thesis 
      using l4_16 by auto
  qed
  ultimately show ?thesis 
    using CongA_def ‹Bet B A A0› ‹Bet B C C0› ‹Bet E D D0› ‹Bet E F F0› ‹Cong A A0 E D› 
      ‹Cong C C0 E F› ‹Cong D D0 B A› ‹Cong F F0 B C› by auto
qed

lemma l11_4_1:
  assumes "A B C CongA D E F" and
    (*"A ≠ B" and "C ≠ B" and "D ≠ E" and "F ≠ E" and*)
    "B Out A' A" and
    "B Out C' C" and
    "E Out D' D" and
    "E Out F' F" and
    "Cong B A' E D'" and 
    "Cong B C' E F'"
  shows "Cong A' C' D' F'"
proof -
  obtain A0 C0 D0 F0 where "B Out A0 A" and "B Out C C0" and "E Out D0 D" and 
    "E Out F F0" and "A0 B C0 Cong3 D0 E F0"
    using assms(1) l11_3 by blast
  have "B Out A' A0" 
    using ‹B Out A0 A› assms(2) l6_6 l6_7 by blast
  have "E Out D' D0" 
    using Out_cases ‹E Out D0 D› assms(4) l6_7 by blast
  have "Cong A' A0 D' D0"
  proof -
    have "Cong B A0 E D0" 
      using Cong3_def Cong_cases ‹A0 B C0 Cong3 D0 E F0› by blast
    thus ?thesis 
      using ‹B Out A' A0› ‹E Out D' D0› assms(6) out_cong_cong by blast
  qed
  have "Cong A' C0 D' F0"
  proof -
    have "B A0 A' C0 FSC E D0 D' F0" 
      using Cong3_def Cong_perm FSC_def assms(6) not_col_permutation_5 out_col 
      by (meson ‹A0 B C0 Cong3 D0 E F0› ‹B Out A' A0› ‹Cong A' A0 D' D0›)
    thus ?thesis 
      using l4_16 Tarski_neutral_dimensionless_axioms out_diff2 ‹B Out A' A0› by blast
  qed
  have "B Out C' C0" 
    using ‹B Out C C0› assms(3) l6_7 by blast
  have "E Out F' F0" 
    by (meson l6_7 ‹E Out F F0› assms(5))
  hence "Cong C' C0 F' F0" 
    using Cong3_def out_cong_cong ‹A0 B C0 Cong3 D0 E F0› ‹B Out C' C0› assms(7) by fastforce
  hence "B C0 C' A' FSC E F0 F' D'" 
    by (meson Col_def Cong3_def FSC_def Out_def ‹A0 B C0 Cong3 D0 E F0› ‹B Out C' C0› 
        ‹Cong A' C0 D' F0› assms(6) assms(7) between_symmetry not_cong_2143)
  hence "Cong C' A' F' D'" 
    using ‹B Out C' C0› l4_16 out_diff2 by blast
  thus ?thesis 
    using not_cong_2143 by blast
qed

lemma l11_4_2:
  assumes "A ≠ B" and
    "C ≠ B" and
    "D ≠ E" and
    "F ≠ E" and
    "∀ A' C' D' F'. (B Out A' A ∧ B Out C' C ∧ E Out D' D ∧ E Out F' F ∧ Cong B A' E D' ∧ 
Cong B C' E F' ⟶ Cong A' C' D' F')"
  shows "A B C CongA D E F"
proof -
  obtain A' where "Bet B A A'" and "Cong A A' E D"
    using segment_construction by blast
  obtain C' where "Bet B C C'" and "Cong C C' E F"
    using segment_construction by blast
  obtain D' where "Bet E D D'" and "Cong D D' B A"
    using segment_construction by blast
  obtain F' where "Bet E F F'" and "Cong F F' B C"
    using segment_construction by blast
  have "Cong A' B D' E" 
    by (meson Bet_cases ‹Bet B A A'› ‹Bet E D D'› ‹Cong A A' E D› ‹Cong D D' B A› 
        l2_11_b not_cong_2134 not_cong_3421)
  have "Cong B C' E F'" 
    using between_symmetry cong_3421 cong_right_commutativity l2_11_b 
    by (meson ‹Bet B C C'› ‹Bet E F F'› ‹Cong C C' E F› ‹Cong F F' B C›)
  have "B Out A' A ∧ B Out C' C ∧ E Out D' D ∧ E Out F' F ∧ A' B C' Cong3 D' E F'"
  proof -
    have "B Out A' A" 
      using ‹Bet B A A'› assms(1) bet_out l6_6 by presburger
    moreover have "B Out C' C" 
      by (simp add: ‹Bet B C C'› assms(2) bet_out l6_6)
    moreover have "E Out D' D" 
      by (simp add: ‹Bet E D D'› assms(3) bet_out l6_6) 
    moreover have "E Out F' F" 
      by (simp add: ‹Bet E F F'› assms(4) bet_out l6_6)
    moreover have "A' B C' Cong3 D' E F'" 
      using Cong3_def Cong_cases ‹Cong A' B D' E› ‹Cong B C' E F'› assms(5) 
        calculation(1) calculation(2) calculation(3) calculation(4) by blast
    ultimately show ?thesis
      by blast
  qed
  thus ?thesis
    using l11_3_bis by blast
qed

lemma conga_refl:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "A B C CongA A B C"
  by (meson CongA_def assms(1) assms(2) cong_reflexivity segment_construction)

lemma conga_sym:
  assumes "A B C CongA A' B' C'"
  shows "A' B' C' CongA A B C"
proof -
  obtain A0 C0 D0 F0 where "Bet B A A0" and "Cong A A0 B' A'" and "Bet B C C0" and
    "Cong C C0 B' C'" and "Bet B' A' D0" and "Cong A' D0 B A" and
    "Bet B' C' F0" and "Cong C' F0 B C" and "Cong A0 C0 D0 F0"
    using CongA_def assms by auto
  hence "∃p pa pb pc. Bet B' A' p ∧ Cong A' p B A ∧ Bet B' C' pa ∧ Cong C' pa B C ∧
Bet B A pb ∧ Cong A pb B' A' ∧Bet B C pc ∧ Cong C pc B' C' ∧ 
Cong p pa pb pc"
    using cong_symmetry Tarski_neutral_dimensionless_axioms by blast
  thus ?thesis
    using CongA_def assms by auto
qed

lemma l11_10:
  assumes "A B C CongA D E F" and
    "B Out A' A" and
    "B Out C' C" and
    "E Out D' D" and
    "E Out F' F"
  shows "A' B C' CongA D' E F'"
proof -
  have "A' ≠ B"
    using assms(2) out_distinct by auto
  moreover have "C' ≠ B"
    using Out_def assms(3) by force
  moreover have "D' ≠ E"
    using Out_def assms(4) by blast
  moreover have "F' ≠ E"
    using assms(5) out_diff1 by auto
  moreover have "∀ A'0 C'0 D'0 F'0. (B Out A'0 A' ∧ B Out C'0 C' ∧ E Out D'0 D' ∧ 
E Out F'0 F' ∧ Cong B A'0 E D'0 ∧ Cong B C'0 E F'0) 
⟶ Cong A'0 C'0 D'0 F'0"
    by (meson assms(1) assms(2) assms(3) assms(4) assms(5) l11_4_1 l6_7)
  ultimately show ?thesis 
    using l11_4_2 by blast
qed

lemma out2__conga:
  assumes "B Out A' A" and
    "B Out C' C"
  shows "A B C CongA A' B C'" 
proof -
  have "A B C CongA A B C" 
    using assms(1) assms(2) conga_refl out_diff2 by auto
  moreover have "B Out A A" 
    using assms(1) out_distinct out_trivial by blast
  moreover have "B Out C C" 
    using assms(2) out_distinct out_trivial by blast
  ultimately show ?thesis 
    using assms(1) assms(2) l11_10 by blast 
qed

lemma cong3_diff:
  assumes "A ≠ B" and
    "A B C Cong3 A' B' C'"
  shows "A' ≠ B'"
  using Cong3_def assms(1) assms(2) cong_diff by blast

lemma cong3_diff2:
  assumes "B ≠ C" and
    "A B C Cong3 A' B' C'"
  shows "B' ≠ C'"
  using Cong3_def assms(1) assms(2) cong_diff by blast

lemma cong3_conga:
  assumes "A ≠ B" and
    "C ≠ B" and
    "A B C Cong3 A' B' C'"
  shows "A B C CongA A' B' C'"
  by (metis assms(1) assms(2) assms(3) cong3_diff cong3_diff2 l11_3_bis out_trivial)

lemma cong3_conga2:
  assumes "A B C Cong3 A' B' C'" and
    "A B C CongA A'' B'' C''"
  shows "A' B' C' CongA A'' B'' C''"
proof -
  obtain A0 C0 A2 C2 where "Bet B A A0" and "Cong A A0 B'' A''" and "Bet B C C0" and
    "Cong C C0 B'' C''" and "Bet B'' A'' A2" and "Cong A'' A2 B A" and 
    "Bet B'' C'' C2" and "Cong C'' C2 B C" and "Cong A0 C0 A2 C2"
    using CongA_def assms(2) by auto
  obtain A1 where "Bet B' A' A1" and "Cong A' A1 B'' A''"
    using segment_construction by blast
  obtain C1 where "Bet B' C' C1" and "Cong C' C1 B'' C''"
    using segment_construction by blast
  have "Cong B'' A'' A' A1" 
    using Cong_cases ‹Cong A' A1 B'' A''› by blast
  hence "Cong A A0 A' A1"
    by (metis cong_transitivity ‹Cong A A0 B'' A''›)
  have "Cong B A0 B' A1" 
    using Cong3_def assms(1) cong_commutativity l2_11_b 
    by (meson ‹Bet B A A0› ‹Bet B' A' A1› ‹Cong A A0 A' A1›)
  have "Cong C C0 C' C1" 
    using cong_inner_transitivity cong_symmetry ‹Cong C C0 B'' C''› ‹Cong C' C1 B'' C''› by blast
  have "B A A0 C FSC B' A' A1 C'" 
    using FSC_def  Cong3_def assms(1) bet_col l4_3 ‹Bet B A A0› ‹Bet B' A' A1› 
      ‹Cong A A0 A' A1› ‹Cong B A0 B' A1› by presburger
  hence "Cong A0 C A1 C'" 
    using CongA_def assms(2) l4_16 by force
  hence "B C C0 A0 FSC B' C' C1 A1" 
    using Cong3_def FSC_def assms(1) bet_col cong_commutativity  ‹Bet B C C0› 
      ‹Bet B' C' C1› ‹Cong B A0 B' A1› ‹Cong C C0 C' C1› l2_11_b by presburger
  have "Cong B A B' A'" 
    using Cong3_def Cong_cases assms(1) by blast
  hence "Cong A'' A2 B' A'"
    using ‹Cong A'' A2 B A› cong_transitivity by blast
  have "Cong B C B' C'" 
    using Cong3_def assms(1) by blast
  hence "Cong C'' C2 B' C'"
    using ‹Cong C'' C2 B C› cong_transitivity by blast
  have "Cong C0 A0 C2 A2" 
    using ‹Cong A0 C0 A2 C2› not_cong_2143 by blast
  have "Cong C1 A1 A0 C0" 
    by (metis CongA_def l4_16 ‹B C C0 A0 FSC B' C' C1 A1› assms(2) cong_3421)
  hence "Cong A1 C1 A2 C2" 
    using Cong_cases ‹Cong A0 C0 A2 C2› cong_transitivity by blast
  thus ?thesis 
    by (metis CongA_def assms(1) assms(2) cong3_diff cong3_diff2 ‹Bet B' A' A1› 
        ‹Bet B' C' C1› ‹Bet B'' A'' A2› ‹Bet B'' C'' C2› ‹Cong A' A1 B'' A''› 
        ‹Cong A'' A2 B' A'› ‹Cong C' C1 B'' C''› ‹Cong C'' C2 B' C'›)
qed

lemma conga_diff1:
  assumes "A B C CongA A' B' C'"
  shows "A ≠ B"
  using CongA_def assms by blast

lemma conga_diff2:
  assumes "A B C CongA A' B' C'"
  shows "C ≠ B"
  using CongA_def assms by blast

lemma conga_diff45:
  assumes "A B C CongA A' B' C'"
  shows "A' ≠ B'"
  using CongA_def assms by blast

lemma conga_diff56:
  assumes "A B C CongA A' B' C'"
  shows "C' ≠ B'"
  using CongA_def assms by blast

lemma conga_trans:
  assumes "A B C CongA A' B' C'" and
    "A' B' C' CongA A'' B'' C''"
  shows "A B C CongA A'' B'' C''"
proof -
  obtain A0 C0 A1 C1 where "Bet B A A0" and "Cong A A0 B' A'" and "Bet B C C0" and 
    "Cong C C0 B' C'" and "Bet B' A' A1" and "Cong A' A1 B A" and
    "Bet B' C' C1" and "Cong C' C1 B C" and "Cong A0 C0 A1 C1"
    using CongA_def assms(1) by auto
  have "A''≠ B''"  
    using CongA_def assms(2) by auto
  have "C'' ≠ B''"
    using CongA_def assms(2) by auto
  have "A1 B' C1 CongA A'' B'' C''"
  proof -
    have "B' Out A1 A'" 
      using Out_def assms(2) bet_neq12__neq conga_diff1 ‹Bet B' A' A1› by metis
    moreover have "B' Out C1 C'" 
      using Out_def assms(1) bet_neq12__neq conga_diff56 ‹Bet B' C' C1› by metis
    moreover have "B'' Out A'' A''" 
      by (simp add: ‹A'' ≠ B''› out_trivial)
    moreover have "B'' Out C'' C''" 
      by (simp add: ‹C'' ≠ B''› out_trivial)
    ultimately show ?thesis 
      using assms(2) l11_10 by blast
  qed
  have "A0 B C0 CongA A' B' C'" 
    using Out_cases conga_diff1 conga_diff2 conga_diff45 assms(1) bet_out 
      conga_diff56 l11_10 l5_3
    by (meson ‹Bet B A A0› ‹Bet B C C0› ‹Bet B' A' A1› ‹Bet B' C' C1›)
  have "Cong B A0 B' A1" 
    using between_symmetry cong_3421 l2_11_b not_cong_1243 
    by (meson ‹Bet B A A0› ‹Bet B' A' A1› ‹Cong A A0 B' A'› ‹Cong A' A1 B A›)
  have "Cong B C0 B' C1" 
    using between_symmetry cong_3421 l2_11_b not_cong_1243 
    by (meson ‹Bet B C C0› ‹Bet B' C' C1› ‹Cong C C0 B' C'› ‹Cong C' C1 B C›)
  have "A0 B C0 Cong3 A1 B' C1" 
    using Cong3_def ‹Cong A0 C0 A1 C1› ‹Cong B A0 B' A1› ‹Cong B C0 B' C1› 
      not_cong_2143 by blast
  hence "A0 B C0 CongA A'' B'' C''" 
    by (meson cong3_symmetry ‹A1 B' C1 CongA A'' B'' C''› cong3_conga2)
  thus ?thesis 
  proof -
    have "B Out A A0" 
      using CongA_def assms(1) bet_out ‹Bet B A A0› by presburger
    moreover have "B Out C C0" 
      using CongA_def assms(1) bet_out ‹Bet B C C0› by presburger
    moreover have "B'' Out A'' A''" 
      by (simp add: ‹A'' ≠ B''› out_trivial)
    moreover have "B'' Out C'' C''" 
      using ‹C'' ≠ B''› out_trivial by auto
    ultimately show ?thesis 
      using ‹A0 B C0 CongA A'' B'' C''›  l11_10 by blast
  qed
qed

lemma conga_pseudo_refl:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "A B C CongA C B A"
  by (meson CongA_def assms(1) assms(2) between_trivial cong_pseudo_reflexivity 
      segment_construction)

lemma conga_trivial_1:
  assumes "A ≠ B" and
    "C ≠ D"
  shows "A B A CongA C D C"
  by (meson CongA_def assms(1) assms(2) cong_trivial_identity segment_construction)

lemma l11_13:
  assumes "A B C CongA D E F" and
    "Bet A B A'" and
    "A'≠ B" and
    "Bet D E D'" and
    "D'≠ E"
  shows "A' B C CongA D' E F"
proof -
  obtain A'' C'' D'' F'' where "Bet B A A''" and "Cong A A'' E D" and "Bet B C C''" and
    "Cong C C'' E F" and "Bet E D D''" and "Cong D D'' B A" and "Bet E F F''" and 
    "Cong F F'' B C" and "Cong A'' C'' D'' F''"
    using CongA_def assms(1) by auto
  obtain A0 where "Bet B A' A0" and "Cong A' A0 E D'"
    using segment_construction by blast
  obtain D0 where "Bet E D' D0" and "Cong D' D0 B A'"
    using segment_construction by blast
  have "Cong A0 C'' D0 F''"
  proof -
    have "A'' B A0 C'' OFSC D'' E D0 F''"
    proof -
      have "Bet A'' B A0"
      proof -
        have "Bet A'' A B" 
          by (simp add: ‹Bet B A A''› between_symmetry)
        have "Bet A B A0" 
          using ‹Bet B A' A0› assms(2) assms(3) outer_transitivity_between by blast
        have "A ≠ B"
          using CongA_def assms(1) by blast
        thus ?thesis 
          using ‹Bet A B A0› ‹Bet A'' A B› outer_transitivity_between2 by blast
      qed
      moreover have "Bet D'' E D0" 
        using Bet_perm outer_transitivity_between CongA_def 
        by (metis ‹Bet E D D''› ‹Bet E D' D0› assms(1) assms(4) assms(5))
      moreover have "Cong A'' B D'' E" 
        using between_symmetry cong_3421 cong_left_commutativity l2_11_b 
        by (meson ‹Bet B A A''› ‹Bet E D D''› ‹Cong A A'' E D› ‹Cong D D'' B A›)
      moreover have "Cong B A0 E D0" 
        using between_symmetry cong_3421 cong_right_commutativity l2_11_b 
        by (meson ‹Bet B A' A0› ‹Bet E D' D0› ‹Cong A' A0 E D'› ‹Cong D' D0 B A'›)
      moreover have "Cong B C'' E F''"
        using between_symmetry cong_3421 cong_right_commutativity l2_11_b 
        by (meson ‹Bet B C C''› ‹Bet E F F''› ‹Cong C C'' E F› ‹Cong F F'' B C›)
      ultimately show ?thesis 
        by (simp add: OFSC_def ‹Cong A'' C'' D'' F''› )
    qed
    have "A'' ≠ B" 
      using ‹Bet B A A''› assms(1) bet_neq23__neq conga_diff1 by blast
    thus ?thesis 
      using ‹A'' B A0 C'' OFSC D'' E D0 F''› five_segment_with_def by auto
  qed
  thus ?thesis 
    using CongA_def ‹Bet B A' A0› ‹Bet B C C''› ‹Bet E D' D0› ‹Bet E F F''› 
      ‹Cong A' A0 E D'› ‹Cong C C'' E F› ‹Cong D' D0 B A'› ‹Cong F F'' B C› 
      assms(1) assms(3) assms(5) by auto
qed

lemma conga_right_comm:
  assumes "A B C CongA D E F"
  shows "A B C CongA F E D"
  by (metis conga_diff45 conga_trans assms conga_diff56 conga_pseudo_refl)

lemma conga_left_comm:
  assumes "A B C CongA D E F"
  shows "C B A CongA D E F"
  by (meson assms conga_right_comm conga_sym)

lemma conga_comm:
  assumes "A B C CongA D E F"
  shows "C B A CongA F E D"
  by (meson conga_left_comm conga_right_comm Tarski_neutral_dimensionless_axioms assms)

lemma conga_line:
  assumes "A ≠ B" and
    "B ≠ C" and
    "A' ≠ B'" and
    "B' ≠ C'"
    and "Bet A B C" and
    "Bet A' B' C'"
  shows "A B C CongA A' B' C'"
  by (metis Bet_cases assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
      conga_trivial_1 l11_13)

lemma l11_14:
  assumes "Bet A B A'" and
    "A ≠ B" and
    "A' ≠ B" and
    "Bet C B C'" and
    "B ≠ C" and
    "B ≠ C'"
  shows "A B C CongA A' B C'"
  by (metis Bet_perm assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
      conga_pseudo_refl conga_right_comm l11_13)

lemma l11_16:
  assumes "Per A B C" and
    "A ≠ B" and
    "C ≠ B" and
    "Per A' B' C'" and
    "A'≠ B'" and
    "C'≠ B'"
  shows "A B C CongA A' B' C'"
proof -
  obtain C0 where "Bet B C C0" and "Cong C C0 B' C'"
    using segment_construction by blast
  obtain C1 where "Bet B' C' C1" and "Cong C' C1 B C"
    using segment_construction by blast
  obtain A0 where "Bet B A A0" and "Cong A A0 B' A'"
    using segment_construction by blast
  obtain A1 where "Bet B' A' A1" and "Cong A' A1 B A"
    using segment_construction by blast
  have "Cong A0 C0 A1 C1"
  proof -
    have "Per A0 B C0"
      using l8_3 assms(1) assms(2) assms(3) bet_col per_col 
      by (metis ‹Bet B A A0› ‹Bet B C C0›)
    moreover have "Per A1 B' C1"
      using l8_3 assms(4) assms(5) assms(6) bet_col per_col 
      by (metis ‹Bet B' A' A1› ‹Bet B' C' C1›)
    moreover have "Cong A0 B A1 B'"
      using between_symmetry cong_3421 cong_left_commutativity l2_11_b 
      by (meson ‹Bet B A A0› ‹Bet B' A' A1› ‹Cong A A0 B' A'› ‹Cong A' A1 B A›)
    moreover have "Cong B C0 B' C1"
      using between_symmetry cong_3421 l2_11_b not_cong_1243 
      by (meson ‹Bet B C C0› ‹Bet B' C' C1› ‹Cong C C0 B' C'› ‹Cong C' C1 B C›)
    ultimately show ?thesis 
      using l10_12 by auto
  qed
  thus ?thesis 
    using CongA_def ‹Bet B A A0› ‹Bet B C C0› ‹Bet B' A' A1› ‹Bet B' C' C1› 
      ‹Cong A A0 B' A'› ‹Cong A' A1 B A› ‹Cong C C0 B' C'› ‹Cong C' C1 B C› 
      assms(2) assms(3) assms(5) assms(6) by auto
qed

lemma l11_17:
  assumes "Per A B C" and
    "A B C CongA A' B' C'"
  shows "Per A' B' C'"
proof -
  obtain A0 C0 A1 C1 where "Bet B A A0" and "Cong A A0 B' A'" and "Bet B C C0" and
    "Cong C C0 B' C'" and "Bet B' A' A1" and "Cong A' A1 B A" and "Bet B' C' C1" and
    "Cong C' C1 B C" and "Cong A0 C0 A1 C1"
    using CongA_def assms(2) by auto
  have "Per A0 B C0"
  proof -
    have "B ≠ C"
      using assms(2) conga_diff2 by blast
    moreover have "Per A0 B C"
      using l8_2 assms(1) assms(2) bet_col conga_diff1 per_col 
      by (metis ‹Bet B A A0›)
    moreover have "Col B C C0" 
      by (simp add: ‹Bet B C C0› bet_col)
    ultimately show ?thesis 
      using per_col by blast
  qed
  have "Per A1 B' C1"
  proof -
    have "A0 B C0 Cong3 A1 B' C1"
    proof -
      have "Cong A0 B A1 B'" 
        using Bet_cases Cong3_def l2_11_b not_cong_2134 not_cong_3421 
        by (meson ‹Bet B A A0› ‹Bet B' A' A1› ‹Cong A A0 B' A'› ‹Cong A' A1 B A›)
      moreover have "Cong B C0 B' C1" 
        by (meson ‹Bet B C C0› ‹Bet B' C' C1› ‹Cong C C0 B' C'› ‹Cong C' C1 B C› 
            between_symmetry cong_3421 l2_11_b not_cong_1243)
      ultimately show ?thesis 
        by (simp add: Cong3_def ‹Cong A0 C0 A1 C1›)
    qed
    thus ?thesis 
      using ‹Per A0 B C0› l8_10 by blast
  qed
  have "B' ≠ C1"
    using assms(2) between_identity conga_diff56 ‹Bet B' C' C1› by blast
  moreover have "Per A' B' C1"
  proof -
    have "B' ≠ A1"
      using assms(2) between_identity conga_diff45 ‹Bet B' A' A1› by blast
    moreover have "Col B' A1 A'" 
      using Bet_cases Col_def ‹Bet B' A' A1› by blast
    ultimately show ?thesis 
      using l8_3 ‹Per A1 B' C1› by blast
  qed
  moreover have "Col B' C1 C'" 
    using ‹Bet B' C' C1› bet_col1 between_trivial by blast
  ultimately show ?thesis 
    using per_col by blast
qed

lemma l11_18_1:
  assumes "Bet C B D" and
    "B ≠ C" and
    "B ≠ D" and
    "A ≠ B" and
    "Per A B C"
  shows "A B C CongA A B D"
proof -
  have "Per A B D" 
    using Bet_cases Col_def assms(1) assms(2) assms(5) per_col by blast
  thus ?thesis 
    using assms(2) assms(3) assms(4) assms(5) l11_16 by auto
qed

lemma l11_18_2:
  assumes "Bet C B D" and
    "A B C CongA A B D"
  shows "Per A B C"
proof -
  obtain A0 C0 A1 D0 where P1: "Bet B A A0 ∧ Cong A A0 B A ∧ Bet B C C0 ∧
Cong C C0 B D ∧ Bet B A A1 ∧ Cong A A1 B A ∧
Bet B D D0 ∧ Cong D D0 B C ∧ Cong A0 C0 A1 D0"
    using CongA_def assms(2) by auto
  have P2: "A0 = A1"
    by (metis P1 assms(2) conga_diff45 construction_uniqueness)
  have P3: "Per A0 B C0"
  proof -
    have Q1: "Bet C0 B D0"
    proof -
      have R1: "Bet C0 C B"
        using P1 between_symmetry by blast
      have R2: "Bet C B D0"
      proof -
        have S1: "Bet C B D"
          by (simp add: assms(1))
        have S2: "Bet B D D0"
          using P1 by blast
        have "B ≠ D"
          using assms(2) conga_diff56 by blast
        thus ?thesis
          using S1 S2 outer_transitivity_between by blast
      qed
      have "C ≠ B"
        using assms(2) conga_diff2 by auto
      thus ?thesis
        using R1 R2 outer_transitivity_between2 by blast
    qed
    have Q2: "Cong C0 B B D0"
      by (meson P1 between_symmetry cong_3421 l2_11_b not_cong_1243)
    have "Cong A0 C0 A0 D0"
      using P1 P2 by blast
    thus ?thesis
      using Per_def Q1 Q2 midpoint_def by blast
  qed
  have P4: "B ≠ C0"
    using P1 assms(2) bet_neq12__neq conga_diff2 by blast
  have P5: "Per A B C0"
    by (metis P1 P3 l8_3 assms(2) bet_col bet_col1 bet_neq21__neq col_transitivity_1 
        conga_diff45)
  have "Col B C0 C" using P1
    using NCol_cases bet_col by blast
  thus ?thesis
    using P4 P5 per_col by blast
qed

lemma cong3_preserves_out:
  assumes "A Out B C" and
    "A B C Cong3 A' B' C'"
  shows "A' Out B' C'"
  by (meson assms(1) assms(2) col_permutation_4 cong3_symmetry cong_3_swap 
      l4_13 l4_6 not_bet_and_out or_bet_out out_col)

lemma l11_21_a:
  assumes "B Out A C" and
    "A B C CongA A' B' C'"
  shows "B' Out A' C'"
proof -
  obtain A0 C0 A1 C1 where P1: "Bet B A A0 ∧
Cong A A0 B' A' ∧ Bet B C C0 ∧
Cong C C0 B' C' ∧ Bet B' A' A1 ∧
Cong A' A1 B A ∧ Bet B' C' C1 ∧
Cong C' C1 B C ∧ Cong A0 C0 A1 C1"
    using CongA_def assms(2) by auto
  have P2: "B Out A0 C0"
    by (metis P1 assms(1) bet_out l6_6 l6_7 out_diff1)
  have P3: "B' Out A1 C1"
  proof -
    have "B A0 C0 Cong3 B' A1 C1"
      by (meson Cong3_def P1 between_symmetry cong_right_commutativity l2_11_b not_cong_4312)
    thus ?thesis
      using P2 cong3_preserves_out by blast
  qed
  thus ?thesis
    by (metis P1 assms(2) bet_out conga_diff45 conga_diff56 l6_6 l6_7)
qed

lemma l11_21_b:
  assumes "B Out A C" and
    "B' Out A' C'"
  shows "A B C CongA A' B' C'"
  using assms(1) assms(2) between_trivial2 conga_trivial_1 l11_10 out2_bet_out out_distinct
  by meson

lemma conga_cop__or_out_ts:
  assumes "Coplanar A B C C'" and
    "A B C CongA A B C'"
  shows "B Out C C' ∨ A B TS C C'"
proof -
  obtain A0 C0 A1 C1 where P1: "Bet B A A0 ∧
Cong A A0 B A ∧Bet B C C0 ∧
Cong C C0 B C' ∧Bet B A A1 ∧
Cong A A1 B A ∧Bet B C' C1 ∧
Cong C' C1 B C ∧ Cong A0 C0 A1 C1"
    using CongA_def assms(2) by auto
  have P2: "A0 = A1" using P1
    by (metis assms(2) conga_diff1 construction_uniqueness)
  have "B Out C C' ∨ A B TS C C'"
  proof cases
    assume "C0 = C1"
    thus ?thesis
      by (metis P1 assms(2) bet2__out conga_diff2 conga_diff56)
  next
    assume R1: "C0 ≠ C1"
    obtain M where R2: "M Midpoint C0 C1"
      using midpoint_existence by blast
    have R3: "Cong B C0 B C1"
      by (meson Bet_cases P1 l2_11_b not_cong_2134 not_cong_3421)
    have R3A: "Cong A0 C0 A0 C1"
      using P1 P2 by blast
    hence R4: "Per A0 M C0" using R2
      using Per_def by blast
    have R5: "Per B M C0"
      using Per_def R2 R3 by auto
    hence R6: "Per B M C1"
      using R2 l8_4 by blast
    have R7: "B ≠ A0"
      using P1 assms(2) bet_neq12__neq conga_diff45 by blast
    hence "Cong A C0 A C1"
      by (meson Col_perm P1 R3 R3A bet_col l4_17)
    hence R9: "Per A M C0"
      using Per_def R2 by blast
    hence R10: "Per A M C1"
      by (meson R2 l8_4 Tarski_neutral_dimensionless_axioms)
    have R11: "Col B A M"
    proof -
      have S1: "Coplanar C0 B A M"
      proof -
        have "Coplanar B A C0 M"
        proof -
          have T1: "Coplanar B A C0 C1"
          proof -
            have "Coplanar A C0 B C'"
            proof -
              have "Coplanar A C' B C0"
              proof -
                have U1: "Coplanar A C' B C"
                  by (simp add: assms(1) coplanar_perm_4)
                have U2: "B ≠ C"
                  using assms(2) conga_diff2 by blast
                have "Col B C C0"
                  by (simp add: P1 bet_col)
                thus ?thesis
                  by (meson col_cop__cop Tarski_neutral_dimensionless_axioms U1 U2)
              qed
              thus ?thesis
                using ncoplanar_perm_5 by blast
            qed
            thus ?thesis
              by (metis P1 col_cop__cop assms(2) bet_col conga_diff56 coplanar_perm_12)
          qed
          have "Col C0 C1 M"
            using Col_perm R2 midpoint_col by blast
          thus ?thesis
            using T1 R1 col_cop__cop by blast
        qed
        thus ?thesis
          using ncoplanar_perm_8 by blast
      qed
      have "C0 ≠ M"
        using R1 R2 midpoint_distinct_1 by blast
      thus ?thesis
        using R5 R9 S1 cop_per2__col by blast
    qed
    have "B Out C C' ∨ A B TS C C'"
    proof cases
      assume Q1: "B = M"
      have Q2: "¬ Col A B C"
        by (metis Col_def P1 Q1 R9 assms(2) conga_diff1 conga_diff2 l6_16_1 l8_9 
            not_bet_and_out out_trivial)
      have Q3: "¬ Col A B C'"
        by (metis Col_def P1 Q1 R10 assms(2) conga_diff1 conga_diff56 l6_16_1 l8_9 
            not_bet_and_out out_trivial)
      have Q4: "Col B A B"
        by (simp add: col_trivial_3)
      have "Bet C B C'"
      proof -
        have S1: "Bet C1 C' B"
          using Bet_cases P1 by blast
        have "Bet C1 B C"
        proof -
          have T1: "Bet C0 C B"
            using Bet_cases P1 by blast
          have "Bet C0 B C1"
            by (simp add: Q1 R2 midpoint_bet)
          thus ?thesis
            using T1 between_exchange3 between_symmetry by blast
        qed
        thus ?thesis
          using S1 between_exchange3 between_symmetry by blast
      qed
      thus ?thesis
        by (metis Q2 Q3 Q4 bet__ts col_permutation_4 invert_two_sides)
    next
      assume L1: "B ≠ M"
      have L2: "B M TS C0 C1"
      proof -
        have M1: "¬ Col C0 B M"
          by (metis (no_types) Col_perm L1 R1 R2 R5 is_midpoint_id l8_9)
        have M2: "¬ Col C1 B M"
          using Col_perm L1 R1 R2 R6 l8_9 midpoint_not_midpoint by blast
        have M3: "Col M B M"
          using col_trivial_3 by auto
        have "Bet C0 M C1"
          by (simp add: R2 midpoint_bet)
        thus ?thesis
          using M1 M2 M3 TS_def by blast
      qed
      have "A B TS C C'"
      proof -
        have W2: "A B TS C C1"
        proof -
          have V1: "A B TS C0 C1"
            using L2 P1 R11 R7 col_two_sides cong_diff invert_two_sides 
              not_col_permutation_5 by blast
          have "B Out C0 C"
            using L2 Out_def P1 TS_def assms(2) col_trivial_1 conga_diff2 by auto
          thus ?thesis
            using V1 col_trivial_3 l9_5 by blast
        qed
        hence W1: "A B TS C' C"
        proof -
          have Z1: "A B TS C1 C"
            by (simp add: W2 l9_2)
          have Z2: "Col B A B"
            using not_col_distincts by blast
          have "B Out C1 C'"
            using L2 Out_def P1 TS_def assms(2) col_trivial_1 conga_diff56 by auto
          thus ?thesis
            using Z1 Z2 l9_5 by blast
        qed
        thus ?thesis
          by (simp add: l9_2)
      qed
      thus ?thesis by blast
    qed
    thus ?thesis by blast
  qed
  thus ?thesis by blast
qed

lemma conga_os__out:
  assumes "A B C CongA A B C'" and
    "A B OS C C'"
  shows "B Out C C'"
  using assms(1) assms(2) conga_cop__or_out_ts l9_9 os__coplanar by blast

lemma cong2_conga_cong:
  assumes "A B C CongA A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "Cong A C A' C'"
  using assms(1) assms(2) assms(3) cong_4321 l11_3 l11_4_1 not_cong_3412 out_distinct out_trivial 
  by meson

lemma angle_construction_1:
  assumes "¬ Col A B C" and
    "¬ Col A' B' P"
  shows "∃ C'. (A B C CongA A' B' C' ∧ A' B' OS C' P)"
proof -
  obtain C0 where P1: "Col B A C0 ∧ B A Perp C C0"
    using assms(1) col_permutation_4 l8_18_existence by blast
  have "∃ C'. (A B C CongA A' B' C' ∧ A' B' OS C' P)"
  proof cases
    assume P1A: "B = C0"
    obtain C' where P2: "Per C' B' A' ∧ Cong C' B' C B ∧ A' B' OS C' P"
      by (metis assms(1) assms(2) col_trivial_1 col_trivial_2 ex_per_cong)
    have P3: "A B C CongA A' B' C'"
      by (metis P1 P2 l8_2 os_distincts P1A assms(1) l11_16 not_col_distincts perp_per_1)
    thus ?thesis using P2 by blast
  next
    assume P4: "B ≠ C0"
    have "∃ C'. (A B C CongA A' B' C' ∧ A' B' OS C' P)"
    proof cases
      assume R1: "B Out A C0"
      obtain C0' where R2: "B' Out A' C0' ∧ Cong B' C0' B C0"
        by (metis P4 assms(2) col_trivial_1 segment_construction_3)
      have "∃ C'. Per C' C0' B' ∧ Cong C' C0' C C0 ∧ B' C0' OS C' P"
      proof -
        have R4: "B' ≠ C0'"
          using Out_def R2 by auto
        have R5: "C ≠ C0"
          using P1 perp_distinct by blast
        have R6: "Col B' C0' C0'"
          by (simp add: col_trivial_2)
        have "¬ Col B' C0' P"
          using NCol_cases R2 R4 assms(2) col_transitivity_1 out_col by blast
        hence "∃ C'. Per C' C0' B' ∧ Cong C' C0' C C0 ∧ B' C0' OS C' P" 
          using R4 R5 R6 ex_per_cong by blast
        thus ?thesis by auto
      qed
      then obtain C' where R7: "Per C' C0' B' ∧ Cong C' C0' C C0 ∧ B' C0' OS C' P" 
        by auto
      hence R8: "C0 B C Cong3 C0' B' C'"
        by (meson Cong3_def P1 R2 col_trivial_2 l10_12 l8_16_1 not_col_permutation_2 
            not_cong_2143 not_cong_4321)
      have R9: "A B C CongA A' B' C'"
      proof -
        have S1: "C0 B C CongA C0' B' C'"
          by (metis P4 R8 assms(1) cong3_conga not_col_distincts)
        have S3: "B Out C C"
          using assms(1) not_col_distincts out_trivial by force
        have "B' ≠ C'"
          using R8 assms(1) cong3_diff2 not_col_distincts by blast
        hence "B' Out C' C'"
          using out_trivial by auto
        thus ?thesis
          using S1 R1 S3 R2 l11_10 by blast
      qed
      have "B' A' OS C' P"
      proof -
        have T1: "Col B' C0' A'"
          by (meson NCol_cases R2 out_col Tarski_neutral_dimensionless_axioms)
        have "B' ≠ A'"
          using assms(2) col_trivial_1 by auto
        thus ?thesis
          using T1 R7 col_one_side by blast
      qed
      hence "A' B' OS C' P"
        by (simp add: invert_one_side)
      thus ?thesis
        using R9 by blast
    next
      assume U1: "¬ B Out A C0"
      hence U2: "Bet A B C0"
        using NCol_perm P1 or_bet_out by blast
      obtain C0' where U3: "Bet A' B' C0' ∧ Cong B' C0' B C0"
        using segment_construction by blast
      have U4: "∃ C'. Per C' C0' B' ∧ Cong C' C0' C C0 ∧ B' C0' OS C' P"
      proof -
        have V2: "C ≠ C0"
          using Col_cases P1 assms(1) by blast
        have "B' ≠ C0'"
          using P4 U3 cong_diff_3 by blast
        hence "¬ Col B' C0' P"
          using Col_def U3 assms(2) col_transitivity_1 by blast
        thus ?thesis using ex_per_cong
          using V2 not_col_distincts by blast
      qed
      then obtain C' where U5: "Per C' C0' B' ∧ Cong C' C0' C C0 ∧ B' C0' OS C' P"
        by blast
      have U98: "A B C CongA A' B' C'"
      proof -
        have X1: "C0 B C Cong3 C0' B' C'"
        proof -
          have X2: "Cong C0 B C0' B'"
            using Cong_cases U3 by blast
          have X3: "Cong C0 C C0' C'"
            using U5 not_cong_4321 by blast
          have "Cong B C B' C'"
          proof -
            have Y1: "Per C C0 B"
              using P1 col_trivial_3 l8_16_1 by blast
            have "Cong C C0 C' C0'"
              using U5 not_cong_3412 by blast
            thus ?thesis
              using Cong_perm Y1 U5 X2 l10_12 by blast
          qed
          thus ?thesis
            by (simp add: Cong3_def X2 X3)
        qed
        have X22: "Bet C0 B A"
          using U2 between_symmetry by blast
        have X24: "Bet C0' B' A'"
          using Bet_cases U3 by blast
        have "A' ≠ B'"
          using assms(2) not_col_distincts by blast
        thus ?thesis
          by (metis P4 X1 X22 X24 assms(1) cong3_conga l11_13 not_col_distincts)
      qed
      have "A' B' OS C' P"
      proof -
        have "B' A' OS C' P"
        proof -
          have W1: "Col B' C0' A'"
            by (simp add: Col_def U3)
          have "B' ≠ A'"
            using assms(2) not_col_distincts by blast
          thus ?thesis
            using W1 U5 col_one_side by blast
        qed
        thus ?thesis
          by (simp add: invert_one_side)
      qed
      thus ?thesis
        using U98 by blast
    qed
    thus ?thesis by auto
  qed
  thus ?thesis by auto
qed

lemma angle_construction_2:
  assumes "A ≠ B" (*and
"A ≠ C"*) and
    "B ≠ C" (*and
"A' ≠ B'"*) and
    "¬ Col A' B' P"
  shows "∃ C'. (A B C CongA A' B' C' ∧ (A' B' OS C' P ∨ Col A' B' C'))"
  by (metis Col_def angle_construction_1 assms(1) assms(2) assms(3) col_trivial_3 
      conga_line l11_21_b or_bet_out out_trivial point_construction_different)

lemma ex_conga_ts:
  assumes "¬ Col A B C" and
    "¬ Col A' B' P"
  shows "∃ C'. A B C CongA A' B' C' ∧ A' B' TS C' P"
proof -
  obtain P' where P1: "A' Midpoint P P'"
    using symmetric_point_construction by blast
  have P2: "¬ Col A' B' P'"
    by (metis P1 assms(2) col_transitivity_1 midpoint_col midpoint_distinct_2 not_col_distincts)
  obtain C' where P3:
    "A B C CongA A' B' C' ∧ A' B' OS C' P'"
    using P2 angle_construction_1 assms(1) by blast
  have "A' B' TS P' P"
    using P1 P2 assms(2) bet__ts l9_2 midpoint_bet not_col_distincts by auto
  thus ?thesis
    using P3 l9_8_2 one_side_symmetry by blast
qed

lemma l11_15:
  assumes "¬ Col A B C" and
    "¬ Col D E P"
  shows
    "∃ F. (A B C CongA D E F ∧ E D OS F P) ∧
(∀ F1 F2. ((A B C CongA D E F1 ∧ E D OS F1 P) ∧
(A B C CongA D E F2 ∧ E D OS F2 P))
⟶ E Out F1 F2)"
proof -
  obtain F where P1: "A B C CongA D E F ∧  D E OS F P"
    using angle_construction_1 assms(1) assms(2) by blast
  hence P2: "A B C CongA D E F ∧ E D OS F P"
    using invert_one_side by blast
  have "(∀ F1 F2. ((A B C CongA D E F1 ∧ E D OS F1 P) ∧
(A B C CongA D E F2 ∧ E D OS F2 P)) ⟶ E Out F1 F2)"
  proof -
    {
      fix F1 F2
      assume P3: "((A B C CongA D E F1 ∧ E D OS F1 P) ∧
  (A B C CongA D E F2 ∧ E D OS F2 P))"
      hence P4: "A B C CongA D E F1" by simp
      have P5: "E D OS F1 P" using P3 by simp
      have P6: "A B C CongA D E F2" using P3 by simp
      have P7: "E D OS F2 P" using P3 by simp
      have P8: "D E F1 CongA D E F2"
        using P4 conga_sym P6 conga_trans by blast
      have "D E OS F1 F2"
        using P5 P7 invert_one_side one_side_symmetry one_side_transitivity by blast
      hence "E Out F1 F2" using P8 conga_os__out
        by (meson P3 conga_sym conga_trans)
    }
    thus ?thesis by auto
  qed
  thus ?thesis
    using P2 by blast
qed

lemma l11_19:
  assumes "Per A B P1" and
    "Per A B P2" and
    "A B OS P1 P2"
  shows "B Out P1 P2"
proof cases
  assume "Col A B P1"
  thus ?thesis
    using assms(3) col123__nos by blast
next
  assume P1: "¬ Col A B P1"
  have "B Out P1 P2"
  proof cases
    assume "Col A B P2"
    thus ?thesis
      using assms(3) one_side_not_col124 by blast
  next
    assume P2: "¬ Col A B P2"
    obtain x where "A B P1 CongA A B x ∧ B A OS x P2 ∧
(∀ F1 F2. ((A B P1 CongA A B F1 ∧ B A OS F1 P2) ∧
(A B P1 CongA A B F2 ∧ B A OS F2 P2))⟶ B Out F1 F2)"
      using P1 P2 l11_15 by blast
    thus ?thesis
      by (metis P1 P2 assms(1) assms(2) assms(3) conga_os__out l11_16 not_col_distincts)
  qed
  thus ?thesis
    by simp
qed

lemma l11_22_bet:
  assumes "Bet A B C" and
    "P' B' TS A' C'" and
    "A B P CongA A' B' P'" and
    "P B C CongA P' B' C'"
  shows "Bet A' B' C'"
proof -
  obtain C'' where P1: "Bet A' B' C'' ∧ Cong B' C'' B C"
    using segment_construction by blast
  have P2: "C B P CongA C'' B' P'"
    by (metis P1 assms(1) assms(3) assms(4) cong_diff_3 conga_diff2 l11_13)
  have P3: "C'' B' P' CongA C' B' P'"
    by (meson P2 conga_sym Tarski_neutral_dimensionless_axioms assms(4) conga_comm conga_trans)
  have P4: "B' Out C' C'' ∨ P' B' TS C' C''"
  proof -
    have P5: "Coplanar P' B' C' C''"
      by (meson P1 TS_def assms(2) bet__coplanar coplanar_trans_1 ncoplanar_perm_1 
          ncoplanar_perm_8 ts__coplanar)
    have "P' B' C' CongA P' B' C''"
      using P3 conga_comm conga_sym by blast
    thus ?thesis
      by (simp add: P5 conga_cop__or_out_ts)
  qed
  have P6: "B' Out C' C'' ⟶ Bet A' B' C'"
  proof -
    {
      assume "B' Out C' C''"
      hence "Bet A' B' C'"
        using P1 bet_out_out_bet between_exchange4 between_trivial2 col_trivial_3 
          l6_6 not_bet_out by blast
    }
    thus ?thesis by simp
  qed
  have "P' B' TS C' C'' ⟶ Bet A' B' C'"
  proof -
    {
      assume P7: "P' B' TS C' C''"
      hence "Bet A' B' C'"
      proof cases
        assume "Col C' B' P'"
        thus ?thesis
          using Col_perm TS_def assms(2) by blast
      next
        assume Q1: "¬ Col C' B' P'"
        hence Q2: "B' ≠ P'"
          using not_col_distincts by blast
        have Q3: "B' P' TS A' C''"
          by (metis Col_perm P1 TS_def P7 assms(2) col_trivial_3)
        have Q4: "B' P' OS C' C''"
          using P7 Q3 assms(2) invert_two_sides l9_8_1 l9_9 by blast
        thus ?thesis
          using P7 invert_one_side l9_9 by blast
      qed
    }
    thus ?thesis by simp
  qed
  thus ?thesis using P6 P4 by blast
qed

lemma l11_22a:
  assumes "B P TS A C" and
    "B' P' TS A' C'" and
    "A B P CongA A' B' P'" and
    "P B C CongA P' B' C'"
  shows "A B C CongA A' B' C'"
proof -
  have P1: "A ≠ B ∧ A' ≠ B' ∧ P ≠ B ∧ P' ≠ B' ∧ C ≠ B ∧ C' ≠ B'"
    using assms(3) assms(4) conga_diff1 conga_diff2 conga_diff45 conga_diff56 by auto
  have P2: "A ≠ C ∧ A' ≠ C'"
    using assms(1) assms(2) not_two_sides_id by blast
  obtain A'' where P3: "B' Out A' A'' ∧ Cong B' A'' B A"
    using P1 segment_construction_3 by force
  have P4: "¬ Col A B P"
    using TS_def assms(1) by blast
  obtain T where P5: "Col T B P ∧ Bet A T C"
    using TS_def assms(1) by blast
  have "A B C CongA A' B' C'"
  proof cases
    assume "B = T"
    thus ?thesis
      by (metis P1 P5 assms(2) assms(3) assms(4) conga_line invert_two_sides l11_22_bet)
  next
    assume P6: "B ≠ T"
    have "A B C CongA A' B' C'"
    proof cases
      assume P7A: "Bet P B T"
      obtain T'' where T1: "Bet P' B' T'' ∧ Cong B' T'' B T"
        using segment_construction by blast
      have "∃ T''. Col B' P' T'' ∧ (B' Out P' T'' ⟷ B Out P T) ∧ Cong B' T'' B T"
      proof -
        have T2: "Col B' P' T''" using T1
          by (simp add: bet_col col_permutation_4)
        have "(B' Out P' T'' ⟷ B Out P T) ∧ Cong B' T'' B T"
          using P7A T1 not_bet_and_out by blast
        thus ?thesis using T2 by blast
      qed
      then obtain T'' where T3:
        "Col B' P' T'' ∧ (B' Out P' T'' ⟷ B Out P T) ∧ Cong B' T'' B T" by blast
      hence T4: "B' ≠ T''"
        using P6 cong_diff_3 by blast
      obtain C'' where T5: "Bet A'' T'' C'' ∧ Cong T'' C'' T C"
        using segment_construction by blast
      have "T B A CongA T'' B' A'" 
      proof -
        have "P B A CongA P' B' A'" 
          by (simp add: assms(3) conga_comm)
        moreover
        have "Col P' B' T''" 
          using T3 Col_cases by blast
        hence "Bet P' B' T''"
          using P7A T3 not_bet_and_out not_out_bet by blast
        ultimately show ?thesis 
          using T4 P6 P7A l11_13 by blast
      qed
      hence T6: "A B T CongA A' B' T''"
        using Out_cases P5 P6 T3 T4 P7A assms(3) between_symmetry col_permutation_4 
          conga_comm l11_13 l6_4_1 or_bet_out by blast
      have T7: "A B T CongA A'' B'  T''"
      proof -
        have "B Out A A" 
          using P4 not_col_distincts out_trivial by presburger
        moreover have "B Out T T" 
          using P6 not_col_distincts out_trivial by presburger
        moreover have "B' Out A'' A'" 
          using P3 l6_6 by blast
        ultimately show ?thesis
          using l11_10 T4 T6 out_trivial by presburger
      qed
      hence T8: "Cong A T A'' T''"
        using P3 T3 cong2_conga_cong cong_4321 not_cong_3412 by blast
      have T9: "Cong A C A'' C''"
        using P5 T5 T8 cong_symmetry l2_11_b by blast
      have "A ≠ T" 
        using P4 P5 by auto
      hence T10: "Cong C B C'' B'"
        using P3 T3 T5 T8 cong_commutativity cong_symmetry five_segment P5
        by meson 
      have "A B C Cong3 A'' B' C''"
        using Cong3_def P3 T10 T9 not_cong_2143 not_cong_4321 by blast
      hence T11: "A B C CongA A'' B' C''"
        by (simp add: cong3_conga Tarski_neutral_dimensionless_axioms P1)
      have "C B T Cong3 C'' B' T''"
        by (simp add: Cong3_def T10 T3 T5 cong_4321 cong_symmetry)
      hence T12: "C B T CongA C'' B' T''"
        using P1 P6 cong3_conga by auto
      have T13: "P B C CongA P' B' C''"
      proof -
        have "Bet T B P"
          using Bet_perm P7A by blast
        moreover have "Bet T'' B' P'"
          using Col_perm P7A T3 l6_6 not_bet_and_out or_bet_out by blast
        ultimately show ?thesis
          using P1 T12 conga_comm l11_13 by blast
      qed
      have T14: "P' B' C' CongA P' B' C''"
      proof -
        have "P' B' C' CongA P B C"
          by (simp add: assms(4) conga_sym)
        thus ?thesis
          using T13 conga_trans by blast
      qed
      have T15: "B' Out C' C'' ∨ P' B' TS C' C''"
      proof -
        have K7: "Coplanar P' B' C' C''"
        proof -
          have K8: "Coplanar A' P' B' C'"
            using assms(2) coplanar_perm_14 ts__coplanar by blast
          have K8A: "Coplanar P' C'' B' A''"
          proof -
            have "Col P' B' T'' ∧ Col C'' A'' T''"
              using Col_def Col_perm T3 T5 by blast
            hence "Col P' C'' T'' ∧ Col B' A'' T'' ∨ 
Col P' B' T'' ∧ Col C'' A'' T'' ∨ 
Col P' A'' T'' ∧ Col C'' B' T''" by simp
            thus ?thesis
              using Coplanar_def by auto
          qed
          hence "Coplanar A' P' B' C''"
          proof -
            have K9: "B' ≠ A''"
              using P3 out_distinct by blast
            have "Col B' A'' A'"
              using Col_perm P3 out_col by blast
            thus ?thesis
              using K8A K9 col_cop__cop coplanar_perm_19 by blast
          qed
          thus ?thesis
            by (meson K8 TS_def assms(2) coplanar_perm_7 coplanar_trans_1 ncoplanar_perm_2)
        qed
        thus ?thesis
          by (simp add: T14 K7 conga_cop__or_out_ts)
      qed
      have "A B C CongA A' B' C'"
      proof cases
        assume "B' Out C' C''"
        thus ?thesis
          using P1 P3 T11 l11_10 out_trivial by blast
      next
        assume W1: "¬ B' Out C' C''"
        hence W1A: " P' B' TS C' C''" using T15 by simp
        have W2: "B' P' TS A'' C'"
          using P3 assms(2) col_trivial_1 l9_5 by blast
        hence W3: "B' P' OS A'' C''"
          using T15 W1 invert_two_sides l9_2 l9_8_1 by blast
        have W4: "B' P' TS A''  C''"
        proof -
          have "¬ Col A' B' P'"
            using TS_def assms(2) by auto
          thus ?thesis
            using Col_perm T3 T5 W3 one_side_chara by blast
        qed
        thus ?thesis
          using W1A W2 invert_two_sides l9_8_1 l9_9 by blast
      qed
      thus ?thesis by simp
    next
      assume R1: "¬ Bet P B T"
      hence R2: "B Out P T"
        using Col_cases P5 l6_4_2 by blast
      have R2A: "∃ T''. Col B' P' T'' ∧ (B' Out P' T'' ⟷ B Out P T) ∧ Cong B' T'' B T"
      proof -
        obtain T'' where R3: "B' Out P' T'' ∧ Cong B' T'' B T"
          using P1 P6 segment_construction_3 by fastforce
        thus ?thesis
          using R2 out_col by blast
      qed
      then obtain T'' where R4: "Col B' P' T'' ∧ 
(B' Out P' T'' ⟷ B Out P T) ∧ 
Cong B' T'' B T" by auto
      have R5: "B' ≠ T''"
        using P6 R4 cong_diff_3 by blast
      obtain C'' where R6: "Bet A'' T'' C'' ∧ Cong T'' C'' T C"
        using segment_construction by blast
      have R7: "A B T CongA A' B' T''"
        using P1 R2 R4 assms(3) l11_10 l6_6 out_trivial by auto
      have R8: "A B T CongA A'' B'  T''"
        using P3 P4 R2 R4 assms(3) l11_10 l6_6 not_col_distincts out_trivial by blast
      have R9: "Cong A T A'' T''"
        using Cong_cases P3 R4 R8 cong2_conga_cong by blast
      have R10: "Cong A C A'' C''"
        using P5 R6 R9 l2_11_b not_cong_3412 by blast
      have R11: "Cong C B C'' B'"
      proof -
        have "Cong T C T'' C''" 
          using Cong_cases R6 by blast
        moreover have "Cong A B A'' B'"
          by (metis P3 Cong_cases)
        moreover have "Cong T B T'' B'" 
          using R4 not_cong_4321 by blast
        moreover have "A ≠ T" 
          using P4 P5 by auto
        ultimately show ?thesis 
          using R9 P5 R6 five_segment by blast
      qed
      have "A B C Cong3 A'' B' C''"
        by (simp add: Cong3_def P3 R10 R11 cong_4321 cong_commutativity)
      hence R12: "A B C CongA A'' B' C''"
        using P1 by (simp add: cong3_conga)
      have "C B T Cong3 C'' B' T''"
        using Cong3_def R11 R4 R6 not_cong_3412 not_cong_4321 by blast
      hence R13: "C B T CongA C'' B' T''"
        using P1 P6 cong3_conga Tarski_neutral_dimensionless_axioms by fastforce
      have R13A: "¬ Col A' B' P'"
        using TS_def assms(2) by blast
      have R14: "B' Out C' C'' ∨ P' B' TS C' C''"
      proof -
        have S1: "Coplanar P' B' C' C''"
        proof -
          have T1: "Coplanar A' P' B' C'"
            using assms(2) ncoplanar_perm_14 ts__coplanar by blast
          have "Coplanar A' P' B' C''"
          proof -
            have U6: "B' ≠ A''"
              using P3 out_diff2 by blast
            have "Coplanar P' C'' B' A''"
            proof -
              have "Col P' B' T'' ∧ Col C'' A'' T''"
                using Col_def Col_perm R4 R6 by blast
              thus ?thesis using Coplanar_def by auto
            qed
            thus ?thesis
              by (meson Col_cases P3 U6 col_cop__cop ncoplanar_perm_21 ncoplanar_perm_6 out_col)
          qed
          thus ?thesis
            using NCol_cases R13A T1 coplanar_trans_1 by blast
        qed
        have "P' B' C' CongA P' B' C''"
        proof -
          have "C B P CongA C'' B' P'"
            using P1 R12 R13 R2 R4 conga_diff56 l11_10 out_trivial by presburger
          hence "C' B' P' CongA C'' B' P'"
            by (meson conga_trans Tarski_neutral_dimensionless_axioms assms(4) 
                conga_comm conga_sym)
          thus ?thesis
            by (simp add: conga_comm)
        qed
        thus ?thesis
          by (simp add: S1 conga_cop__or_out_ts)
      qed
      have S1: "B Out A A"
        using P4 not_col_distincts out_trivial by blast
      have S2: "B Out C C"
        using TS_def assms(1) not_col_distincts out_trivial by auto
      have S3: "B' Out A' A''" using P3 by simp
      have "A B C CongA A' B' C'"
      proof cases
        assume "B' Out C' C''"
        thus ?thesis using S1 S2 S3
          using R12 l11_10 by blast
      next
        assume "¬ B' Out C' C''"
        hence Z3: "P' B' TS C' C''" using R14 by simp
        have Q1: "B' P' TS A'' C'"
          using S3 assms(2) l9_5 not_col_distincts by blast
        have Q2: "B' P' OS A'' C''"
        proof -
          have "B' P' TS C'' C'"
          proof -
            have "B' P' TS C' C''" using Z3
              using invert_two_sides by blast
            thus ?thesis
              by (simp add: l9_2)
          qed
          thus ?thesis
            using Q1 l9_8_1 by blast
        qed
        have "B' P' TS A''  C''"
          using Col_perm Q2 R4 R6 one_side_chara by blast
        thus ?thesis
          using Q2 l9_9 by blast
      qed
      thus ?thesis using S1 S2 S3
        using R12 l11_10 by blast
    qed
    thus ?thesis by simp
  qed
  thus ?thesis by simp
qed

lemma l11_22b:
  assumes "B P OS A C" and
    "B' P' OS A' C'" and
    "A B P CongA A' B' P'" and
    "P B C CongA P' B' C'"
  shows "A B C CongA A' B' C'"
proof -
  obtain D where P1: "Bet A B D ∧ Cong B D A B"
    using segment_construction by blast
  obtain D' where P2: "Bet A' B' D' ∧ Cong B' D' A' B'"
    using segment_construction by blast
  have P3: "D B P CongA D' B' P'"
  proof -
    have Q3: "D ≠ B"
      by (metis P1 assms(1) col_trivial_3 cong_diff_3 one_side_not_col124 one_side_symmetry)
    have Q5: "D' ≠ B'"
      by (metis P2 assms(2) col_trivial_3 cong_diff_3 one_side_not_col124 one_side_symmetry)
    thus ?thesis
      using assms(3) P1 Q3 P2 l11_13 by blast
  qed
  have P5: "D B C CongA D' B' C'"
  proof -
    have Q1: "B P TS D C"
      by (metis P1 assms(1) bet__ts col_trivial_3 cong_diff_3 l9_2 l9_8_2 one_side_not_col124 
          one_side_symmetry)
    have "B' P' TS D' C'" 
      by (metis Cong_perm P2 assms(2) bet__ts between_cong between_trivial2 l9_2 l9_8_2 
          one_side_not_col123 point_construction_different ts_distincts)
    thus ?thesis
      using assms(4) Q1 P3 l11_22a by blast
  qed
  have P6: "Bet D B A"
    using Bet_perm P1 by blast
  have P7: "A ≠ B"
    using assms(3) conga_diff1 by auto
  have P8: "Bet D' B' A'"
    using Bet_cases P2 by blast
  have "A' ≠ B'"
    using assms(3) conga_diff45 by blast
  thus ?thesis
    using P5 P6 P7 P8 l11_13 by blast
qed

lemma l11_22:
  assumes "((B P TS A C ∧ B' P' TS A' C')∨(B P OS A C ∧ B' P' OS A' C'))" and
    "A B P CongA A' B' P'" and
    "P B C CongA P' B' C'"
  shows "A B C CongA A' B' C'"
  by (meson assms(1) assms(2) assms(3) l11_22a l11_22b)

lemma l11_24:
  assumes "P InAngle A B C"
  shows "P InAngle C B A"
proof -
  obtain X where "Bet A X C" and "X = B ∨ B Out X P" 
    using InAngle_def assms by auto
  thus ?thesis 
    using Bet_cases InAngle_def assms by auto
qed

lemma col_in_angle:
  assumes "A ≠ B" and
    "C ≠ B" and
    "P ≠ B" and
    "B Out A P ∨ B Out C P"
  shows "P InAngle A B C"
  by (meson InAngle_def assms(1) assms(2) assms(3) assms(4) between_trivial between_trivial2)

lemma out321__inangle:
  assumes "C ≠ B" and
    "B Out A P"
  shows "P InAngle A B C"
  using assms(1) assms(2) col_in_angle out_distinct by auto

lemma inangle1123:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "A InAngle A B C"
  by (simp add: assms(1) assms(2) out321__inangle out_trivial)

lemma out341__inangle:
  assumes "A ≠ B" and
    "B Out C P"
  shows "P InAngle A B C"
  using assms(1) assms(2) col_in_angle out_distinct by auto

lemma inangle3123:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "C InAngle A B C"
  by (simp add: assms(1) assms(2) inangle1123 l11_24)

lemma in_angle_two_sides:
  assumes "¬ Col B A P" and
    "¬ Col B C P" and
    "P InAngle A B C"
  shows "P B TS A C"           
  by (metis InAngle_def TS_def assms(1) assms(2) assms(3) not_col_distincts 
      not_col_permutation_1 out_col)

lemma in_angle_out:
  assumes "B Out A C" and
    "P InAngle A B C"
  shows "B Out A P"
  by (metis InAngle_def assms(1) assms(2) not_bet_and_out out2_bet_out)

lemma col_in_angle_out:
  assumes "Col B A P" and
    "¬ Bet A B C" and
    "P InAngle A B C"
  shows "B Out A P"
proof -
  obtain X where P1: "Bet A X C ∧ (X = B ∨ B Out X P)"
    using InAngle_def assms(3) by auto
  have "B Out A P"
  proof cases
    assume "X = B"
    thus ?thesis
      using P1 assms(2) by blast
  next
    assume P2: "X ≠ B"
    thus ?thesis
    proof -
      have f1: "Bet B A P ∨ A Out B P"
        by (meson assms(1) l6_4_2)
      have f2: "B Out X P"
        using P1 P2 by blast
      have f3: "(Bet B P A ∨Bet B A P) ∨Bet P B A"
        using f1 by (meson Bet_perm Out_def)
      have f4: "Bet B P X ∨Bet P X B"
        using f2 by (meson Bet_perm Out_def)
      hence f5: "((Bet B P X ∨Bet X B A) ∨Bet B P A) ∨Bet B A P"
        using f3 by (meson between_exchange3)
      have "∀p. Bet p X C ∨ ¬Bet A p X"
        using P1 between_exchange3 by blast
      hence f6: "(P = B ∨Bet B A P) ∨Bet B P A"
        using f5 f3 by (meson Bet_perm P2 assms(2) outer_transitivity_between2)
      have f7: "Bet C X A"
        using Bet_perm P1 by blast
      have "P ≠ B"
        using f2 by (simp add: Out_def)
      moreover
      { assume "Bet B B C"
        hence "A ≠ B"
          using assms(2) by blast }
      ultimately have "A ≠ B"
        using f7 f4 f1 by (meson Bet_perm Out_def P2 between_exchange3 
            outer_transitivity_between2)
      thus ?thesis
        using f6 f2 by (simp add: Out_def)
    qed
  qed
  thus ?thesis by blast
qed

lemma l11_25_aux:
  assumes "P InAngle A B C" and
    "¬ Bet A B C" and
    "B Out A' A"
  shows "P InAngle A' B C"
proof -
  have P1: "Bet B A' A ∨ Bet B A A'"
    using Out_def assms(3) by auto
  {
    assume P2: "Bet B A' A"
    obtain X where P3: "Bet A X C ∧ (X = B ∨ B Out X P)"
      using InAngle_def assms(1) by auto
    obtain T where P4: "Bet A' T C ∧ Bet X T B"
      using Bet_perm P2 P3 inner_pasch by blast
    {
      assume "X = B"
      hence "P InAngle A' B C"
        using P3 assms(2) by blast
    }
    {
      assume "B Out X P"
      hence "P InAngle A' B C"
        by (metis InAngle_def P4 assms(1) assms(3) bet_out_1 l6_7 out_diff1)
    }
    hence "P InAngle A' B C"
      using P3 ‹X = B ⟹ P InAngle A' B C› by blast
  }
  {
    assume Q0: "Bet B A A'"
    obtain X where Q1: "Bet A X C ∧ (X = B ∨ B Out X P)"
      using InAngle_def assms(1) by auto
    {
      assume "X = B"
      hence "P InAngle A' B C"
        using Q1 assms(2) by blast
    }
    {
      assume Q2: "B Out X P"
      obtain T where Q3: "Bet A' T C ∧ Bet B X T"
        using Bet_perm Q1 Q0 outer_pasch by blast
      hence "P InAngle A' B C"
        by (metis InAngle_def Q0 Q2 assms(1) bet_out l6_6 l6_7 out_diff1)
    }
    hence "P InAngle A' B C"
      using ‹X = B ⟹ P InAngle A' B C› Q1 by blast
  }
  thus ?thesis
    using P1 ‹Bet B A' A ⟹ P InAngle A' B C› by blast
qed

lemma l11_25:
  assumes "P InAngle A B C" and
    "B Out A' A" and
    "B Out C' C" and
    "B Out P' P"
  shows "P' InAngle A' B C'"
proof cases
  assume "Bet A B C"
  thus ?thesis
    by (metis Bet_perm InAngle_def assms(2) assms(3) assms(4) bet_out__bet l6_6 out_distinct)
next
  assume P1: "¬ Bet A B C"
  have P2: "P InAngle A' B C"
    using P1 assms(1) assms(2) l11_25_aux by blast
  have P3: "P InAngle A' B C'"
  proof -
    have "P InAngle C' B A'" using l11_25_aux
      using Bet_perm P1 P2 assms(2) assms(3) bet_out__bet l11_24 by blast
    thus ?thesis using l11_24 by blast
  qed
  obtain X where P4: "Bet A' X C' ∧ (X = B ∨ B Out X P)"
    using InAngle_def P3 by auto
  {
    assume "X = B"
    hence "P' InAngle A' B C'"
      using InAngle_def P3 P4 assms(4) out_diff1 by auto
  }
  {
    assume "B Out X P"
    hence "P' InAngle A' B C'"
    proof -
      have "∀p. B Out p P' ∨ ¬ B Out p P"
        by (meson Out_cases assms(4) l6_7)
      thus ?thesis
        by (metis (no_types) InAngle_def P3 assms(4) out_diff1)
    qed
  }
  thus ?thesis
    using InAngle_def P4 assms(2) assms(3) assms(4) out_distinct by auto
qed

lemma inangle_distincts:
  assumes "P InAngle A B C"
  shows "A ≠ B ∧ C ≠ B ∧ P ≠ B"
  using InAngle_def assms by auto

lemma segment_construction_0:
  shows "∃ B'. Cong A' B' A B"
  using segment_construction by blast

lemma angle_construction_3:
  assumes "A ≠ B" and
    "C ≠ B" and
    "A' ≠ B'"
  shows "∃ C'. A B C CongA A' B' C'"
  by (metis angle_construction_2 assms(1) assms(2) assms(3) not_col_exists)

lemma l11_28:
  assumes "A B C Cong3 A' B' C'" and
    "Col A C D"
  shows "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
proof cases
  assume P1: "A = C"
  have "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
  proof cases
    assume "A = B"
    thus ?thesis
      by (metis P1 assms(1) cong3_diff cong3_symmetry cong_3_swap_2 not_cong_3421 
          segment_construction_0)
  next
    assume "A ≠ B"
    have "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
    proof cases
      assume "A = D"
      thus ?thesis
        using Cong3_def P1 assms(1) cong_trivial_identity by blast
    next
      assume "A ≠ D"
      have "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
      proof cases
        assume "B = D"
        thus ?thesis
          using Cong3_def assms(1) cong_3_swap_2 cong_trivial_identity by blast
      next
        assume Q1: "B ≠ D"
        obtain D'' where Q2: "B A D CongA B' A' D''"
          by (metis ‹A ≠ B› ‹A ≠ D› angle_construction_3 assms(1) cong3_diff)
        obtain D' where Q3: "A' Out D'' D' ∧ Cong A' D' A D"
          by (metis Q2 ‹A ≠ D› conga_diff56 segment_construction_3)
        have Q5: "Cong A D A' D'"
          using Q3 not_cong_3412 by blast
        have "B A D CongA B' A' D'"
          using Q2 Q3 ‹A ≠ B› ‹A ≠ D› conga_diff45 l11_10 l6_6 out_trivial by auto
        hence "Cong B D B' D'"
          using Cong3_def Cong_perm Q5 assms(1) cong2_conga_cong by blast
        thus ?thesis
          using Cong3_def P1 Q5 assms(1) cong_reverse_identity by blast
      qed
      thus ?thesis by simp
    qed
    thus ?thesis by simp
  qed
  thus ?thesis by simp
next
  assume Z1: "A ≠ C"
  have  "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
  proof cases
    assume "A = D"
    thus ?thesis
      using Cong3_def Cong_perm assms(1) cong_trivial_identity by blast
  next
    assume "A ≠ D"
    {
      assume "Bet A C D"
      obtain D' where W1: "Bet A' C' D' ∧ Cong C' D' C D"
        using segment_construction by blast
      have W2: "Cong A D A' D'"
        by (meson Cong3_def W1 ‹Bet A C D› assms(1) cong_symmetry l2_11_b)
      have W3: "Cong B D B' D'"
      proof -
        have X1: "Cong C D C' D'"
          using W1 not_cong_3412 by blast
        have "Cong C B C' B'"
          using Cong3_def assms(1) cong_commutativity by presburger
        hence W4: "A C D B OFSC A' C' D' B'"
          using Cong3_def OFSC_def W1 X1 ‹Bet A C D› assms(1) by blast
        have "Cong D B D' B'"
          using W4 ‹A ≠ C› five_segment_with_def by blast
        thus ?thesis
          using Z1 not_cong_2143 by blast
      qed
      have "Cong C D C' D'"
        by (simp add: W1 cong_symmetry)
      hence "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
        using W2 W3 by blast
    }
    {
      assume W3B: "Bet C D A"
      then obtain D' where W4A: "Bet A' D' C' ∧ A D C Cong3 A' D' C'"
        using Bet_perm Cong3_def assms(1) l4_5 by blast
      have W5: "Cong A D A' D'"
        using Cong3_def W4A by blast
      have "A D C B IFSC A' D' C' B'"
        by (meson Bet_perm Cong3_def Cong_perm IFSC_def W4A W3B assms(1))
      hence "Cong D B D' B'"
        using l4_2 by blast
      hence W6: "Cong B D B' D'"
        using Cong_perm by blast
      hence "Cong C D C' D'"
        using Cong3_def W4A not_cong_2143 by blast
      hence "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
        using W5 W6 by blast
    }
    {
      assume W7: "Bet D A C"
      obtain D' where W7A: "Bet C' A' D' ∧ Cong A' D' A D"
        using segment_construction by blast
      hence W8: "Cong A D A' D'"
        using Cong_cases by blast
      have "C A D B OFSC C' A' D' B'"
        by (meson Bet_perm Cong3_def Cong_perm OFSC_def W7 W7A assms(1))
      hence "Cong D B D' B'"
        using Z1 five_segment_with_def by auto
      hence w9: "Cong B D B' D'"
        using Cong_perm by blast
      have "Cong C D C' D'"
      proof -
        have L1: "Bet C A D"
          using Bet_perm W7 by blast
        have L2: "Bet C' A' D'"
          using Bet_perm W7
          using W7A by blast
        have "Cong C A C' A'" using assms(1)
          using Cong3_def assms(1) not_cong_2143 by blast
        thus ?thesis using l2_11
          using L1 L2 W8 l2_11 by blast
      qed
      hence "∃ D'. (Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D')"
        using W8 w9 by blast
    }
    thus ?thesis
      using Bet_cases ‹Bet A C D ⟹ ∃D'. Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D'› 
        ‹Bet C D A ⟹ ∃D'. Cong A D A' D' ∧ Cong B D B' D' ∧ Cong C D C' D'› 
        assms(2) third_point by blast
  qed
  thus ?thesis
    by blast
qed

lemma bet_conga__bet:
  assumes "Bet A B C" and
    "A B C CongA A' B' C'"
  shows "Bet A' B' C'"
proof -
  obtain A0 C0 A1 C1 where P1:"
Bet B A A0 ∧Cong A A0 B' A' ∧
Bet B C C0 ∧Cong C C0 B' C' ∧
Bet B' A' A1 ∧Cong A' A1 B A ∧
Bet B' C' C1 ∧Cong C' C1 B C ∧
Cong A0 C0 A1 C1" using CongA_def assms(2)
    by auto
  have "Bet C B A0" using P1 outer_transitivity_between
    by (metis assms(1) assms(2) between_symmetry conga_diff1)
  hence "Bet A0 B C"
    using Bet_cases by blast
  hence P2: "Bet A0 B C0"
    using P1 assms(2) conga_diff2 outer_transitivity_between by blast
  have P3: "A0 B C0 Cong3 A1 B' C1"
  proof -
    have Q1: "Cong A0 B A1 B'"
      by (meson Bet_cases P1 l2_11_b not_cong_1243 not_cong_4312)
    have Q3: "Cong B C0 B' C1"
      using P1 between_symmetry cong_3421 l2_11_b not_cong_1243 by blast
    thus ?thesis
      by (simp add: Cong3_def Q1 P1)
  qed
  hence P4: "Bet A1 B' C1" using P2 l4_6 by blast
  hence "Bet A' B' C1"
    using P1 Bet_cases between_exchange3 by blast
  thus ?thesis using between_inner_transitivity P1 by blast
qed

lemma in_angle_one_side:
  assumes "¬ Col A B C" and
    "¬ Col B A P" and
    "P InAngle A B C"
  shows "A B OS P C"
proof -
  obtain X where P1: "Bet A X C ∧ (X = B ∨ B Out X P)"
    using InAngle_def assms(3) by auto
  {
    assume "X = B"
    hence  "A B OS P C"
      using P1 assms(1) bet_col by blast
  }
  {
    assume P2: "B Out X P"
    obtain C' where P2A: "Bet C A C' ∧ Cong A C' C A"
      using segment_construction by blast
    have "A B TS X C'"
    proof -
      have Q1: "¬ Col X A B"
        by (metis Col_def P1 assms(1) assms(2) col_transitivity_2 out_col)
      have Q2 :"¬ Col C' A B"
        by (metis Col_def Cong_perm P2A assms(1) cong_diff l6_16_1)
      have "∃ T. Col T A B ∧ Bet X T C'"
        using Bet_cases P1 P2A between_exchange3 col_trivial_1 by blast
      thus ?thesis
        by (simp add: Q1 Q2 TS_def)
    qed
    hence P3: "A B TS P C'"
      using P2 col_trivial_3 l9_5 by blast
    hence "A B TS C C'"
      using P1 P2 bet_out bet_ts__os between_trivial col123__nos col_trivial_3 
        invert_two_sides l6_6 l9_2 l9_5 
      by (metis P2A assms(1) bet__ts)
    hence "A B OS P C"
      using OS_def P3 by blast
  }
  thus ?thesis
    using P1 ‹X = B ⟹ A B OS P C› by blast
qed

lemma inangle_one_side:
  assumes "¬ Col A B C" and
    "¬ Col A B P" and
    "¬ Col A B Q" and
    "P InAngle A B C" and
    "Q InAngle A B C"
  shows "A B OS P Q"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) in_angle_one_side 
      not_col_permutation_4 one_side_symmetry one_side_transitivity)

lemma inangle_one_side2:
  assumes "¬ Col A B C" and
    "¬ Col A B P" and
    "¬ Col A B Q" and
    "¬ Col C B P" and
    "¬ Col C B Q" and
    "P InAngle A B C" and
    "Q InAngle A B C"
  shows "A B OS P Q ∧ C B OS P Q"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) 
      inangle_one_side l11_24 not_col_permutation_3)

lemma col_conga_col:
  assumes "Col A B C" and
    "A B C CongA D E F"
  shows  "Col D E F"
proof -
  {
    assume "Bet A B C"
    hence "Col D E F"
      using Col_def assms(2) bet_conga__bet by blast
  }
  {
    assume "Bet B C A"
    hence "Col D E F"
      by (meson Col_perm l11_21_a ‹Bet A B C ⟹ Col D E F› assms(1) assms(2) 
          or_bet_out out_col)
  }
  {
    assume "Bet C A B"
    hence "Col D E F"
      by (meson Col_perm l11_21_a ‹Bet A B C ⟹ Col D E F› assms(1) assms(2) 
          or_bet_out out_col)
  }
  thus ?thesis
    using Col_def ‹Bet A B C ⟹ Col D E F› ‹Bet B C A ⟹ Col D E F› assms(1) by blast
qed

lemma ncol_conga_ncol:
  assumes "¬ Col A B C" and
    "A B C CongA D E F"
  shows "¬ Col D E F"
  using assms(1) assms(2) col_conga_col conga_sym by blast

lemma angle_construction_4:
  assumes "A ≠ B" and
    "C ≠ B" and
    "A' ≠ B'"
  shows "∃C'. (A B C CongA A' B' C' ∧ Coplanar A' B' C' P)"
proof cases
  assume "Col A' B' P"
  thus ?thesis
    using angle_construction_3 assms(1) assms(2) assms(3) ncop__ncols by blast
next
  assume "¬ Col A' B' P"
  {
    assume "Col A B C"
    hence "∃C'. (A B C CongA A' B' C' ∧ Coplanar A' B' C' P)"
      by (meson angle_construction_3 assms(1) assms(2) assms(3) col__coplanar col_conga_col)
  }
  {
    assume "¬ Col A B C"
    then obtain C' where "A B C CongA A' B' C' ∧ A' B' OS C' P"
      using ‹¬ Col A' B' P› angle_construction_1 by blast
    hence  "∃C'. (A B C CongA A' B' C' ∧ Coplanar A' B' C' P)"
      using os__coplanar by blast
  }
  thus ?thesis
    using ‹Col A B C ⟹ ∃C'. A B C CongA A' B' C' ∧ Coplanar A' B' C' P› by blast
qed

lemma lea_distincts:
  assumes "A B C LeA D E F"
  shows "A≠B ∧ C≠B ∧ D≠E ∧ F≠E"
  by (metis LeA_def conga_diff1 conga_diff2 assms inangle_distincts)

lemma l11_29_a:
  assumes "A B C LeA D E F"
  shows "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
proof -
  obtain P where P1: "P InAngle D E F ∧ A B C CongA D E P"
    using LeA_def assms by blast
  hence P2: "E ≠ D ∧ B ≠ A ∧ E ≠ F ∧ E ≠ P ∧ B ≠ C"
    using conga_diff1 conga_diff2 inangle_distincts by blast
  hence P3: "A ≠ B ∧ C ≠ B" by blast
  {
    assume Q1: "Bet A B C"
    hence Q2: "Bet D E P"
      by (meson P1 bet_conga__bet Tarski_neutral_dimensionless_axioms)
    have Q3: "C InAngle A B C"
      by (simp add: P3 inangle3123)
    obtain X where Q4: "Bet D X F ∧ (X = E ∨ E Out X P)"
      using InAngle_def P1 by auto
    have "A B C CongA D E F"
    proof -
      {
        assume R1: "X = E"
        have R2: "Bet E F P ∨ Bet E P F"
        proof -
          have R3: "D ≠ E" using P2 by blast
          have "Bet D E F"
            using Col_def Col_perm P1 Q2 col_in_angle_out not_bet_and_out by blast
          have "Bet D E P" using Q2 by blast
          thus ?thesis using l5_2
            using R3 ‹Bet D E F› by blast
        qed
        have "A B C CongA D E F"
        proof -
          have "B Out A A" 
            using P3 out_trivial by auto
          moreover have "B Out C C" 
            using P3 out_trivial by auto
          moreover have "E Out D D" 
            using P2 out_trivial by auto
          moreover have "E Out F P" 
            using Out_def P2 R2 by blast
          ultimately show ?thesis 
            using P1 l11_10 by blast
        qed
      }
      {
        assume S1: "E Out X P"
        have S2: "E Out P F"
        proof -
          {
            assume "Bet E X P"
            hence "E Out P F"
            proof -
              have "Bet E X F"
                by (meson Bet_perm Q2 Q4 ‹Bet E X P› between_exchange3)
              thus ?thesis
                by (metis Bet_perm S1 bet2__out between_equality_2 between_trivial2 
                    out2_bet_out out_diff1)
            qed
          }
          {
            assume "Bet E P X"
            hence "Bet D P X" 
              using Q2 S1 out_diff2 outer_transitivity_between2 by blast
            hence "Bet D P F" 
              using Q4 between_exchange4 by blast
            hence "E Out P F" 
              by (metis P2 Q2 bet_out between_exchange3)
          }
          thus ?thesis
            using Out_def S1 ‹Bet E X P ⟹ E Out P F› by blast
        qed
        hence "A B C CongA D E F"
          by (metis Bet_perm P2 Q1 Q2 bet_out__bet conga_line)
      }
      thus ?thesis
        using Q4 ‹X = E ⟹ A B C CongA D E F› by blast
    qed
    hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
      using conga_diff1 conga_diff2 inangle3123 by blast
  }
  {
    assume "B Out A C"
    obtain Q where "D E F CongA A B Q"
      by (metis P2 angle_construction_3)
    hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
      by (metis conga_comm ‹B Out A C› conga_diff1 conga_sym out321__inangle)
  }
  {
    assume ZZ: "¬ Col A B C"
    have Z1: "D ≠ E"
      using P2 by blast
    have Z2: "F ≠ E"
      using P2 by blast
    have Z3: "Bet D E F ∨ E Out D F ∨ ¬ Col D E F"
      using not_bet_out by blast
    {
      assume "Bet D E F"
      obtain Q where Z4: "Bet A B Q ∧ Cong B Q E F"
        using segment_construction by blast
      hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
        by (metis InAngle_def P3 Z1 Z2 ‹Bet D E F› conga_line point_construction_different)
    }
    {
      assume "E Out D F"
      hence Z5: "E Out D P"
        using P1 in_angle_out by blast
      have "D E P CongA A B C"
        by (simp add: P1 conga_sym)
      hence Z6: "B Out A C" using l11_21_a Z5
        by blast
      hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
        using ‹B Out A C ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› by blast
    }
    {
      assume W1: "¬ Col D E F"
      obtain Q where W2: "D E F CongA A B Q ∧ A B OS Q C"
        using W1 ZZ angle_construction_1 by blast
      obtain DD where W3: "E Out D DD ∧ Cong E DD B A"
        using P3 Z1 segment_construction_3 by force
      obtain FF where W4: "E Out F FF ∧ Cong E FF B Q"
        by (metis P2 W2 conga_diff56 segment_construction_3)
      hence W5: "P InAngle DD E FF"
        using Out_cases P1 P2 W3 l11_25 out_trivial by fastforce
      obtain X where W6: "Bet DD X FF ∧ (X = E ∨ E Out X P)"
        using InAngle_def W5 by presburger
      {
        assume W7: "X = E"
        have W8: "Bet D E F"
        proof -
          have W10: "E Out DD D"
            by (simp add: W3 l6_6)
          have "E Out FF F"
            by (simp add: W4 l6_6)
          thus ?thesis using W6 W7 W10 bet_out_out_bet by blast
        qed
        hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
          using ‹Bet D E F ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› by blast
      }
      {
        assume V1: "E Out X P"
        have "B ≠ C ∧ E ≠ X"
          using P3 V1 out_diff1 by blast
        then obtain CC where V2: "B Out C CC ∧ Cong B CC E X"
          using segment_construction_3 by blast
        hence V3: "A B CC CongA DD E X"
          using P1 P2 V1 W3 l11_10 l6_6 out_trivial by force
        have V4: "Cong A CC DD X"
        proof -
          have "Cong A B DD E"
            using W3 not_cong_4321 by blast
          thus ?thesis
            using V2 V3 cong2_conga_cong by blast
        qed
        have V5: "A B Q CongA DD E FF"
        proof -
          have U1: "D E F CongA A B Q"
            by (simp add: W2)
          hence U1A: "A B Q CongA D E F"
            by (simp add: conga_sym)
          have U2: "B Out A A"
            by (simp add: P3 out_trivial)
          have U3: "B Out Q Q"
            using W2 conga_diff56 out_trivial by blast
          have U4: "E Out DD D"
            using W3 l6_6 by blast
          have "E Out FF F"
            by (simp add: W4 l6_6)
          thus ?thesis using l11_10
            using U1A U2 U3 U4 by blast
        qed
        hence V6: "Cong A Q DD FF"
          using Cong_perm W3 W4 cong2_conga_cong by blast
        have "CC B Q CongA X E FF"
        proof -
          have U1: "B A OS CC Q"
            by (metis V2 W2 col124__nos invert_one_side one_side_symmetry 
                one_side_transitivity out_one_side)
          have U2: "E DD OS X FF"
          proof -
            have "¬ Col DD E FF"
              by (metis Col_perm OS_def TS_def U1 V5 ncol_conga_ncol)
            hence "¬ Col E DD X"
              by (metis Col_def V2 V4 W6 ZZ cong_identity l6_16_1 os_distincts out_one_side)
            hence "DD E OS X FF"
              by (metis Col_perm W6 bet_out not_col_distincts one_side_reflexivity 
                  out_out_one_side)
            thus ?thesis
              by (simp add: invert_one_side)
          qed
          have "CC B A CongA X E DD"
            by (simp add: V3 conga_comm)
          thus ?thesis
            using U1 U2 V5 l11_22b by blast
        qed
        hence V8: "Cong CC Q X FF"
          using V2 W4 cong2_conga_cong cong_commutativity not_cong_3412 by blast
        have V9: "CC InAngle A B Q"
        proof -
          have T2: "Q ≠ B"
            using W2 conga_diff56 by blast
          have T3: "CC ≠ B"
            using V2 out_distinct by blast
          have "Bet A CC Q"
          proof -
            have T4: "DD X FF Cong3 A CC Q"
              using Cong3_def V4 V6 V8 not_cong_3412 by blast
            thus ?thesis
              using W6 l4_6 by blast
          qed
          hence "∃ X0. Bet A X0 Q ∧ (X0 = B ∨ B Out X0 CC)"
            using out_trivial by blast
          thus ?thesis
            by (simp add: InAngle_def P3 T2 T3)
        qed
        hence "C InAngle A B Q"
          using V2 inangle_distincts l11_25 out_trivial by blast
        hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
          using W2 conga_sym by blast
      }
      hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
        using W6 ‹X = E ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› by blast
    }
    hence "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
      using Z3 ‹E Out D F ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› 
        ‹Bet D E F ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› by blast
  }
  thus ?thesis
    using ‹B Out A C ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› 
      ‹Bet A B C ⟹ ∃Q. C InAngle A B Q ∧ A B Q CongA D E F› not_bet_out by blast
qed

lemma in_angle_line:
  assumes "P ≠ B" and
    "A ≠ B" and
    "C ≠ B" and
    "Bet A B C"
  shows "P InAngle A B C"
  using InAngle_def assms(1) assms(2) assms(3) assms(4) by auto

lemma l11_29_b:
  assumes "∃ Q. (C InAngle A B Q ∧ A B Q CongA D E F)"
  shows "A B C LeA D E F"
proof -
  obtain Q where P1: "C InAngle A B Q ∧ A B Q CongA D E F"
    using assms by blast
  obtain X where P2: "Bet A X Q ∧ (X = B ∨ B Out X C)"
    using InAngle_def P1 by auto
  {
    assume P2A: "X = B"
    obtain P where P3: "A B C CongA D E P"
      using angle_construction_3 assms conga_diff45 inangle_distincts by fastforce
    have "P InAngle D E F"
    proof -
      have O1: "Bet D E F"
        by (metis P1 P2 bet_conga__bet P2A)
      have O2: "P ≠ E"
        using P3 conga_diff56 by auto
      have O3: "D ≠ E"
        using P3 conga_diff45 by auto
      have "F ≠ E"
        using P1 conga_diff56 by blast
      thus ?thesis using in_angle_line
        by (simp add: O1 O2 O3)
    qed
    hence "A B C LeA D E F"
      using LeA_def P3 by blast
  }
  {
    assume G1: "B Out X C"
    obtain DD where G2: "E Out D DD ∧ Cong E DD B A"
      by (metis assms conga_diff1 conga_diff45 segment_construction_3)
    have G3: "D ≠ E ∧ DD ≠ E"
      using G2 out_diff1 out_diff2 by blast
    obtain FF where G3G: "E Out F FF ∧ Cong E FF B Q"
      by (metis P1 conga_diff56 inangle_distincts segment_construction_3)
    hence G3A: "F ≠ E"
      using out_diff1 by blast
    have G3B: "FF ≠ E"
      using G3G out_distinct by blast
    have G4: "Bet A B C ∨ B Out A C ∨ ¬ Col A B C"
      using not_bet_out by blast
    {
      assume G5: "Bet A B C"
      have G6: "F InAngle D E F"
        by (simp add: G3 G3A inangle3123)
      have "A B C CongA A B Q" 
      proof -
        have "A ≠ B" 
          using P1 conga_diff1 by blast
        hence "B Out A A" 
          using out_trivial by blast
        moreover 
        have "B Out Q C"
        proof -
          {
            assume "Bet B X C"
            hence "Bet A B X" 
              using G5 between_inner_transitivity by blast
            hence "Bet B X Q" 
              using P2 between_exchange3 by blast
            hence "B Out Q C" 
              by (metis G1 bet_out l6_6 l6_7 out_diff1)
          }
          moreover
          {
            assume "Bet B C X"
            hence "Bet B X Q" 
              by (metis G5 P2 between_exchange3 l6_3_1 outer_transitivity_between)
            hence "Bet B C Q" 
              using ‹Bet B C X› between_exchange4 by blast
            hence "B Out Q C" 
              by (metis G1 Out_def between_identity)
          }
          ultimately show ?thesis 
            using G1 Out_def by blast
        qed
        ultimately show ?thesis 
          by (simp add: out2__conga)
      qed
      hence "A B C CongA D E F" 
        using P1 conga_trans by blast
      hence  "A B C LeA D E F"
        using G6 LeA_def by blast
    }
    {
      assume G8: "B Out A C"
      have G9: "D InAngle D E F"
        by (simp add: G3 G3A inangle1123)
      have "A B C CongA D E D"
        by (simp add: G3 G8 l11_21_b out_trivial)
      hence  "A B C LeA D E F" using G9 LeA_def by blast
    }
    {
      assume R1: "¬ Col A B C"
      have R2: "Bet A B Q ∨ B Out A Q ∨ ¬ Col A B Q"
        using not_bet_out by blast
      {
        assume R3: "Bet A B Q"
        obtain P where R4: "A B C CongA D E P"
          by (metis G3 LeA_def ‹Bet A B C ⟹ A B C LeA D E F› angle_construction_3 
              not_bet_distincts)
        have R5: "P InAngle D E F"
        proof -
          have R6: "P ≠ E"
            using R4 conga_diff56 by auto
          have "Bet D E F"
            by (metis P1 R3 bet_conga__bet)
          thus ?thesis
            by (simp add: R6 G3 G3A in_angle_line)
        qed
        hence  "A B C LeA D E F" using R4 R5 LeA_def by blast
      }
      {
        assume S1: "B Out A Q"
        have S2: "B Out A C"
          using G1 P2 S1 l6_7 out_bet_out_1 by blast
        have S3: "Col A B C"
          by (simp add: Col_perm S2 out_col)
        hence  "A B C LeA D E F"
          using R1 by blast
      }
      {
        assume S3B: "¬ Col A B Q"
        obtain P where S4: "A B C CongA D E P ∧ D E OS P F"
          by (meson P1 R1 ncol_conga_ncol Tarski_neutral_dimensionless_axioms 
              S3B angle_construction_1)
        obtain PP where S4A: "E Out P PP ∧ Cong E PP B X"
          by (metis G1 S4 os_distincts out_diff1 segment_construction_3)
        have S5: "P InAngle D E F"
        proof -
          have "PP InAngle DD E FF"
          proof -
            have Z3: "PP ≠ E"
              using S4A l6_3_1 by blast
            have Z4: "Bet DD PP FF"
            proof -
              have L1: "C B Q CongA P E F"
              proof -
                have K1: "B A OS C Q"
                  using Col_perm P1 R1 S3B in_angle_one_side invert_one_side by blast
                have K2: "E D OS P F"
                  by (simp add: S4 invert_one_side)
                have "C B A CongA P E D"
                  by (simp add: S4 conga_comm)
                thus ?thesis
                  using K1 K2 P1 l11_22b by auto
              qed
              have L2: "Cong DD FF A Q"
              proof -
                have "DD E FF CongA A B Q"
                proof -
                  have L3: "A B Q CongA D E F"
                    by (simp add: P1)
                  hence L3A: "D E F CongA A B Q"
                    using conga_sym by blast
                  have L4: "E Out DD D"
                    using G2 Out_cases by auto
                  have L5: "E Out FF F"
                    using G3G Out_cases by blast
                  have L6: "B Out A A"
                    using S3B not_col_distincts out_trivial by auto
                  have "B Out Q Q"
                    by (metis S3B not_col_distincts out_trivial)
                  thus ?thesis using L3A L4 L5 L6 l11_10
                    by blast
                qed
                have L2B: "Cong DD E A B"
                  using Cong_perm G2 by blast
                have "Cong E FF B Q"
                  by (simp add: G3G)
                thus ?thesis
                  using L2B ‹DD E FF CongA A B Q› cong2_conga_cong by auto
              qed
              have L8: "Cong A X DD PP"
              proof -
                have L9: "A B X CongA DD E PP"
                proof -
                  have L9B: "B Out A A"
                    using S3B not_col_distincts out_trivial by blast
                  have L9D: "E Out D D "
                    using G3 out_trivial by auto
                  have "E Out PP P"
                    using Out_cases S4A by blast
                  thus ?thesis using l11_10 S4 L9B G1 L9D
                    using G2 Out_cases by blast
                qed
                have L10: "Cong A B DD E"
                  using G2 not_cong_4321 by blast
                have "Cong B X E PP"
                  using Cong_perm S4A by blast
                thus ?thesis
                  using L10 L9 cong2_conga_cong by blast
              qed
              have "A X Q Cong3 DD PP FF"
              proof -
                have L12B: "Cong A Q DD FF"
                  using L2 not_cong_3412 by blast
                have "Cong X Q PP FF"
                proof -
                  have L13A: "X B Q CongA PP E FF"
                  proof -
                    have L13AC: "B Out Q Q"
                      by (metis S3B col_trivial_2 out_trivial)
                    have L13AD: "E Out PP P"
                      by (simp add: S4A l6_6)
                    have "E Out FF F"
                      by (simp add: G3G l6_6)
                    thus ?thesis
                      using L1 G1 L13AC L13AD l11_10 by blast
                  qed
                  have L13B: "Cong X B PP E"
                    using S4A not_cong_4321 by blast
                  have "Cong B Q E FF"
                    using G3G not_cong_3412 by blast
                  thus ?thesis
                    using L13A L13B cong2_conga_cong by auto
                qed
                thus ?thesis
                  by (simp add: Cong3_def L12B L8)
              qed
              thus ?thesis using P2 l4_6 by blast
            qed
            have "PP = E ∨ E Out PP PP"
              using out_trivial by auto
            thus ?thesis
              using InAngle_def G3 G3B Z3 Z4 by auto
          qed
          thus ?thesis
            using G2 G3G S4A l11_25 by blast
        qed
        hence  "A B C LeA D E F"
          using S4 LeA_def by blast
      }
      hence  "A B C LeA D E F"
        using R2 ‹B Out A Q ⟹ A B C LeA D E F› ‹Bet A B Q ⟹ A B C LeA D E F› by blast
    }
    hence "A B C LeA D E F"
      using G4 ‹B Out A C ⟹ A B C LeA D E F› ‹Bet A B C ⟹ A B C LeA D E F› by blast
  }
  thus ?thesis
    using P2 ‹X = B ⟹ A B C LeA D E F› by blast
qed

lemma bet_in_angle_bet:
  assumes "Bet A B P" and
    "P InAngle A B C"
  shows "Bet A B C"
  by (metis (no_types) Col_def Col_perm assms(1) assms(2) col_in_angle_out not_bet_and_out)

lemma lea_line:
  assumes "Bet A B P" and
    "A B P LeA A B C"
  shows "Bet A B C"
  by (metis bet_conga__bet l11_29_a assms(1) assms(2) bet_in_angle_bet)

lemma eq_conga_out:
  assumes "A B A CongA D E F"
  shows "E Out D F"
  by (metis CongA_def assms l11_21_a out_trivial)

lemma out_conga_out:
  assumes "B Out A C" and
    "A B C CongA D E F"
  shows "E Out D F"
  using assms(1) assms(2) l11_21_a by blast

lemma conga_ex_cong3:
  assumes "A B C CongA A' B' C'"
  shows "∃ AA CC. ((B Out A AA ∧ B Out C CC) ⟶ AA B CC Cong3 A' B' C')"
  using out_diff2 by blast

lemma conga_preserves_in_angle:
  assumes "A B C CongA A' B' C'" and
    "A B I CongA A' B' I'" and
    "I InAngle A B C" and "A' B' OS I' C'"
  shows "I' InAngle A' B' C'"
proof -
  have P1: "A ≠ B"
    using assms(1) conga_diff1 by auto
  have P2: "B ≠ C"
    using assms(1) conga_diff2 by blast
  have P3: "A' ≠ B'"
    using assms(1) conga_diff45 by auto
  have P4: "B' ≠ C'"
    using assms(1) conga_diff56 by blast
  have P5: "I ≠ B"
    using assms(2) conga_diff2 by auto
  have P6: "I' ≠ B'"
    using assms(2) conga_diff56 by blast
  have P7: "Bet A B C ∨ B Out A C ∨ ¬ Col A B C"
    using l6_4_2 by blast
  {
    assume "Bet A B C"
    have Q1: "Bet A' B' C'"
      using ‹Bet A B C› assms(1) assms(4) bet_col col124__nos col_conga_col by blast
    hence "I' InAngle A' B' C'"
      using assms(4) bet_col col124__nos by auto
  }
  {
    assume "B Out A C"
    hence "I' InAngle A' B' C'"
      by (metis P4 assms(2) assms(3) in_angle_out l11_21_a out321__inangle)
  }
  {
    assume Z1: "¬ Col A B C"
    have Q2: "Bet A B I ∨ B Out A I ∨ ¬ Col A B I"
      by (simp add: or_bet_out)
    {
      assume "Bet A B I"
      hence "I' InAngle A' B' C'"
        using ‹Bet A B C ⟹ I' InAngle A' B' C'› assms(3) bet_in_angle_bet by blast
    }
    {
      assume "B Out A I"
      hence "I' InAngle A' B' C'"
        using P4 assms(2) l11_21_a out321__inangle by auto
    }
    {
      assume "¬ Col A B I"
      obtain AA' where Q3: "B' Out A' AA' ∧ Cong B' AA' B A"
        using P1 P3 segment_construction_3 by presburger
      obtain CC' where Q4: "B' Out C' CC' ∧ Cong B' CC' B C"
        using P2 P4 segment_construction_3 by presburger
      obtain J where Q5: "Bet A J C ∧ (J = B ∨ B Out J I)"
        using InAngle_def assms(3) by auto
      have Q6: "B ≠ J"
        using Q5 Z1 bet_col by auto
      have Q7: "¬ Col A B J"
        using Q5 Q6 ‹¬ Col A B I› col_permutation_2 col_transitivity_1 out_col by blast
      have "¬ Col A' B' I'"
        by (metis assms(4) col123__nos)
      hence "∃ C'. (A B J CongA A' B' C' ∧ A' B' OS C' I')"
        using Q7 angle_construction_1 by blast
      then obtain J' where Q8: "A B J CongA A' B' J' ∧ A' B' OS J' I'" by blast
      have Q9: "B' ≠ J'"
        using Q8 conga_diff56 by blast
      obtain JJ' where Q10: "B' Out J' JJ' ∧ Cong B' JJ' B J"
        using segment_construction_3 Q6 Q9 by blast
      have Q11: "¬ Col A' B' J'"
        using Q8 col123__nos by blast
      have Q12: "A' ≠ JJ'"
        by (metis Col_perm Q10 Q11 out_col)
      have Q13: "B' ≠ JJ'"
        using Q10 out_distinct by blast
      have Q14: "¬ Col A' B' JJ'"
        using Col_perm Q10 Q11 Q13 l6_16_1 out_col by blast
      have Q15: "A B C CongA AA' B' CC'"
      proof -
        have T2: "C ≠ B" using P2 by auto
        have T3: "AA' ≠ B'"
          using Out_def Q3 by blast
        have T4: "CC' ≠ B'"
          using Q4 out_distinct by blast
        have T5: "∀ A' C' D' F'. (B Out A' A ∧ B Out C' C ∧ B' Out D' AA' ∧
    B' Out F' CC' ∧Cong B A' B' D' ∧ Cong B C' B' F' 
    ⟶ Cong A' C' D' F')"
          using Q3 Q4 l11_4_1 Tarski_neutral_dimensionless_axioms assms(1) l6_6 l6_7 
          by blast
        thus ?thesis using P1 T2 T3 T4 l11_4_2 by blast
      qed
      have Q16: "A' B' J' CongA A' B' JJ'"
      proof -
        have P9: "B' Out A' A'"
          by (simp add: P3 out_trivial)
        have "B' Out JJ' J'"
          using Out_cases Q10 by auto
        thus ?thesis
          using l11_10
          by (simp add: P9 out2__conga)
      qed
      have Q17: "B' Out I' JJ' ∨ A' B' TS I' JJ'"
      proof -
        have "Coplanar A' I' B' J'"
          by (metis Q8 ncoplanar_perm_3 os__coplanar)
        hence "Coplanar A' I' B' JJ'"
          using Q10 Q9 col_cop__cop out_col by blast
        hence R1: "Coplanar A' B' I' JJ'" using coplanar_perm_2
          by blast
        have "A' B' I' CongA A' B' JJ'"
        proof -
          have R2: "A' B' I' CongA A B I"
            by (simp add: assms(2) conga_sym)
          have "A B I CongA A' B' JJ'"
          proof -
            have f1: "∀p pa pb. ¬ p Out pa pb ∧ ¬ p Out pb pa ∨ p Out pa pb"
              using Out_cases by blast
            hence f2: "B' Out JJ' J'"
              using Q10 by blast
            have "B Out J I"
              by (metis Q5 Q6)
            thus ?thesis
              using f2 f1 by (meson P3 Q8 l11_10 Tarski_neutral_dimensionless_axioms 
                  ‹¬ Col A B I› col_one_side_out col_trivial_2 one_side_reflexivity out_trivial)
          qed
          thus ?thesis
            using R2 conga_trans by blast
        qed
        thus ?thesis using R1 conga_cop__or_out_ts by blast
      qed
      {
        assume Z2: "B' Out I' JJ'"
        have Z3: "J B C CongA J' B' C'"
        proof -
          have R1: "B A OS J C"
            by (metis Q5 Q7 Z1 bet_out invert_one_side not_col_distincts out_one_side)
          have R2: "B' A' OS J' C'"
            by (meson Q10 Z2 assms(4) invert_one_side l6_6 one_side_symmetry out_out_one_side)
          have  "J B A CongA J' B' A'"
            using Q8 conga_comm by blast
          thus ?thesis using assms(1) R1 R2 l11_22b by blast
        qed
        hence "I' InAngle A' B' C'"
        proof -
          have "A J C Cong3 AA' JJ' CC'"
          proof -
            have R8: "Cong A J AA' JJ'"
            proof -
              have R8A: "A B J CongA AA' B' JJ'"
              proof -
                have R8AB: "B Out A A"
                  by (simp add: P1 out_trivial)
                have R8AC: "B Out J I"
                  using Q5 Q6 by auto
                have R8AD: "B' Out AA' A'"
                  using Out_cases Q3 by auto
                have "B' Out JJ' I'"
                  using Out_cases Z2 by blast
                thus ?thesis
                  using assms(2) R8AB R8AC R8AD l11_10 by blast
              qed
              have R8B: "Cong A B AA' B'"
                using Q3 not_cong_4321 by blast
              have R8C: "Cong B J B' JJ'"
                using Q10 not_cong_3412 by blast
              thus ?thesis
                using R8A R8B cong2_conga_cong by blast
            qed
            have LR8A: "Cong A C AA' CC'"
              using Q15 Q3 Q4 cong2_conga_cong cong_4321 cong_symmetry by blast
            have "Cong J C JJ' CC'"
            proof -
              have K1:"B' Out JJ' J'"
                using Out_cases Q10 by auto
              have "B' Out CC' C'"
                using Out_cases Q4 by auto
              hence "J' B' C' CongA JJ' B' CC'" using K1
                by (simp add: out2__conga)
              hence LR9A: "J B C CongA JJ' B' CC'"
                using Z3 conga_trans by blast                                     
              have LR9B: "Cong J B JJ' B'"
                using Q10 not_cong_4321 by blast
              have "Cong B C B' CC'"
                using Q4 not_cong_3412 by blast
              thus ?thesis
                using LR9A LR9B cong2_conga_cong by blast
            qed
            thus ?thesis using R8 LR8A
              by (simp add: Cong3_def)
          qed
          hence R10: "Bet AA' JJ' CC'" using Q5 l4_6 by blast
          have "JJ' InAngle AA' B' CC'"
          proof -
            have R11: "AA' ≠ B'"
              using Out_def Q3 by auto
            have R12: "CC' ≠ B'"
              using Out_def Q4 by blast
            have "Bet AA' JJ' CC' ∧ (JJ' = B' ∨ B' Out JJ' JJ')"
              using R10 out_trivial by auto
            thus ?thesis
              using InAngle_def Q13 R11 R12 by auto
          qed
          thus ?thesis
            using Z2 Q3 Q4 l11_25 by blast
        qed
      }
      {
        assume X1: "A' B' TS I' JJ'"
        have "A' B' OS I' J'"
          by (simp add: Q8 one_side_symmetry)
        hence X2: "B' A' OS I' JJ'"
          using Q10 invert_one_side out_out_one_side by blast
        hence "I' InAngle A' B' C'"
          using X1 invert_one_side l9_9 by blast
      }
      hence "I' InAngle A' B' C'"
        using Q17 ‹B' Out I' JJ' ⟹ I' InAngle A' B' C'› by blast
    }
    hence "I' InAngle A' B' C'"
      using Q2 ‹B Out A I ⟹ I' InAngle A' B' C'› ‹Bet A B I ⟹ I' InAngle A' B' C'› by blast
  }
  thus ?thesis
    using P7 ‹B Out A C ⟹ I' InAngle A' B' C'› ‹Bet A B C ⟹ I' InAngle A' B' C'› by blast
qed

lemma l11_30:
  assumes "A B C LeA D E F" and
    "A B C CongA A' B' C'" and
    "D E F CongA D' E' F'"
  shows "A' B' C' LeA D' E' F'"
proof -
  obtain Q where P1: "C InAngle A B Q ∧ A B Q CongA D E F"
    using assms(1) l11_29_a by blast
  have P1A: "C InAngle A B Q" 
    using P1 by simp
  have P1B: "A B Q CongA D E F" 
    using P1 by simp
  have P2: "A ≠ B"
    using P1A inangle_distincts by auto
  have P3: "C ≠ B"
    using P1A inangle_distincts by blast
  have P4: "A' ≠ B'"
    using CongA_def assms(2) by blast
  have P5: "C' ≠ B'"
    using CongA_def assms(2) by auto
  have P6: "D ≠ E"
    using CongA_def P1B by blast
  have P7: "F ≠ E"
    using CongA_def P1B by blast
  have P8: "D' ≠ E'"
    using CongA_def assms(3) by blast
  have P9: "F' ≠ E'"
    using CongA_def assms(3) by blast
  have P10: "Bet A' B' C' ∨ B' Out A' C' ∨ ¬ Col A' B' C'"
    using or_bet_out by blast
  {
    assume "Bet A' B' C'"
    hence "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
      by (metis P1 P4 P5 P8 P9 assms(2) assms(3) bet_conga__bet bet_in_angle_bet 
          conga_line conga_sym inangle3123)
  }
  {
    assume R1: "B' Out A' C'"
    obtain Q' where R2: "D' E' F' CongA A' B' Q'"
      using P4 P8 P9 angle_construction_3 by blast
    hence "C' InAngle A' B' Q'"
      using col_in_angle P1 R1 conga_diff56 out321__inangle by auto
    hence "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
      using R2 conga_sym by blast
  }
  {
    assume R3: "¬ Col A' B' C'"
    have R3A: "Bet D' E' F' ∨ E' Out D' F' ∨ ¬ Col D' E' F'"
      using or_bet_out by blast
    {
      assume "Bet D' E' F'"
      have "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
        by (metis P4 P5 P8 P9 ‹Bet D' E' F'› conga_line in_angle_line 
            point_construction_different)
    }
    {
      assume R4A: "E' Out D' F'"
      obtain Q' where R4: "D' E' F' CongA A' B' Q'"
        using P4 P8 P9 angle_construction_3 by blast
      hence R5: "B' Out A' Q'" using out_conga_out R4A by blast
      have R6: "A B Q CongA D' E' F'"
        using P1 assms(3) conga_trans by blast
      hence R7: "B Out A Q" using out_conga_out R4A R4
        using conga_sym by blast
      have R8: "B Out A C"
        using P1A R7 in_angle_out by blast
      hence R9: "B' Out A' C'" using out_conga_out assms(2)
        by blast
      have "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
        by (simp add: R9 ‹B' Out A' C' ⟹ ∃Q'. C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F'›)
    }
    {
      assume "¬ Col D' E' F'"
      obtain QQ where S1: "D' E' F' CongA A' B' QQ ∧ A' B' OS QQ C'"
        using R3 ‹¬ Col D' E' F'› angle_construction_1 by blast
      have S1A: "A B Q CongA A' B' QQ" using S1
        using P1 assms(3) conga_trans by blast
      have "A' B' OS C' QQ" using S1
        by (simp add: S1 one_side_symmetry)
      hence S2: "C' InAngle A' B' QQ" using conga_preserves_in_angle S1A
        using P1A assms(2) by blast
      have S3: "A' B' QQ CongA D' E' F'"
        by (simp add: S1 conga_sym)
      hence "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
        using S2 by auto
    }
    hence "∃ Q'. (C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F')"
      using R3A ‹E' Out D' F' ⟹ ∃Q'. C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F'› 
        ‹Bet D' E' F' ⟹ ∃Q'. C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F'› by blast
  }
  thus ?thesis using l11_29_b
    using P10 ‹B' Out A' C' ⟹ ∃Q'. C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F'› 
      ‹Bet A' B' C' ⟹ ∃Q'. C' InAngle A' B' Q' ∧ A' B' Q' CongA D' E' F'› by blast
qed

lemma l11_31_1:
  assumes "B Out A C" and
    "D ≠ E" and
    "F ≠ E"
  shows "A B C LeA D E F"
  by (metis (full_types) LeA_def assms(1) assms(2) assms(3) l11_21_b out321__inangle 
      segment_construction_3)

lemma l11_31_2:
  assumes "A ≠ B" and
    "C ≠ B" and
    "D ≠ E" and
    "F ≠ E" and
    "Bet D E F"
  shows "A B C LeA D E F"
  by (metis LeA_def angle_construction_3 assms(1) assms(2) assms(3) assms(4) assms(5) 
      conga_diff56 in_angle_line)

lemma lea_refl:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "A B C LeA A B C"
  by (meson assms(1) assms(2) conga_refl l11_29_b out341__inangle out_trivial)

lemma conga__lea:
  assumes "A B C CongA D E F"
  shows "A B C LeA D E F"
  by (metis conga_diff1 conga_diff2 l11_30 assms conga_refl lea_refl)

lemma conga__lea456123:
  assumes "A B C CongA D E F"
  shows "D E F LeA A B C"
  by (simp add: conga__lea Tarski_neutral_dimensionless_axioms assms conga_sym)

lemma lea_left_comm:
  assumes "A B C LeA D E F"
  shows "C B A LeA D E F"
  by (metis assms conga_pseudo_refl conga_refl l11_30 lea_distincts)

lemma lea_right_comm:
  assumes "A B C LeA D E F"
  shows "A B C LeA F E D"
  by (meson assms conga_right_comm l11_29_a l11_29_b)

lemma lea_comm:
  assumes"A B C LeA D E F"
  shows "C B A LeA F E D"
  using assms lea_left_comm lea_right_comm by blast

lemma lta_left_comm:
  assumes "A B C LtA D E F"
  shows "C B A LtA D E F"
  by (meson LtA_def conga_left_comm lea_left_comm assms)

lemma lta_right_comm:
  assumes "A B C LtA D E F"
  shows "A B C LtA F E D"
  by (meson LtA_def conga_comm lea_comm lta_left_comm assms)

lemma lta_comm:
  assumes "A B C LtA D E F"
  shows "C B A LtA F E D"
  using assms lta_left_comm lta_right_comm by blast

lemma lea_out4__lea:
  assumes "A B C LeA D E F" and
    "B Out A A'" and
    "B Out C C'" and
    "E Out D D'" and
    "E Out F F'"
  shows "A' B C' LeA D' E F'"
  using assms(1) assms(2) assms(3) assms(4) assms(5) l11_30 l6_6 out2__conga by auto


lemma lea121345:
  assumes "A ≠ B" and
    "C ≠ D" and
    "D ≠ E"
  shows "A B A LeA C D E"
  using assms(1) assms(2) assms(3) l11_31_1 out_trivial by auto

lemma inangle__lea:
  assumes "P InAngle A B C"
  shows "A B P LeA A B C"
  by (metis l11_29_b assms conga_refl inangle_distincts)

lemma inangle__lea_1:
  assumes "P InAngle A B C"
  shows "P B C LeA A B C"
  by (simp add: inangle__lea lea_comm assms l11_24)

lemma inangle__lta:
  assumes "¬ Col P B C" and
    "P InAngle A B C"
  shows "A B P LtA A B C"
  by (metis LtA_def TS_def conga_cop__or_out_ts conga_os__out inangle__lea ncol_conga_ncol 
      assms(1) assms(2) col_one_side_out col_trivial_3 in_angle_one_side inangle__coplanar 
      invert_two_sides l11_21_b ncoplanar_perm_12 not_col_permutation_3 one_side_reflexivity)

lemma in_angle_trans:
  assumes "C InAngle A B D" and
    "D InAngle A B E"
  shows "C InAngle A B E"
proof -
  obtain CC where P1: "Bet A CC D ∧ (CC = B ∨ B Out CC C)"
    using InAngle_def assms(1) by auto
  obtain DD where P2: "Bet A DD E ∧ (DD = B ∨ B Out DD D)"
    using InAngle_def assms(2) by auto
  hence P3: "Bet A DD E" by simp
  have P4: "DD = B ∨ B Out DD D" using P2 by simp
  {
    assume "CC = B ∧ DD = B"
    hence "C InAngle A B E"
      using InAngle_def P2 assms(1) assms(2) by auto
  }
  {
    assume "CC = B ∧ B Out DD D"
    hence "C InAngle A B E"
      by (metis InAngle_def P1 assms(1) assms(2) bet_in_angle_bet)
  }
  {
    assume "B Out CC C ∧ DD = B"
    hence "C InAngle A B E"
      by (metis Out_def P2 assms(2) in_angle_line inangle_distincts)
  }
  {
    assume P3: "B Out CC C ∧ B Out DD D"
    hence P3A: "B Out CC C" by simp
    have P3B: "B Out DD D" using P3 by simp
    have "C InAngle A B DD"
      using P3 assms(1) inangle_distincts l11_25 out_trivial by blast
    then obtain CC' where T1: "Bet A CC' DD ∧ (CC' = B ∨ B Out CC' C)"
      using InAngle_def by auto
    {
      assume "CC' = B"
      hence "C InAngle A B E"
        by (metis P2 P3 T1 assms(2) between_exchange4 in_angle_line inangle_distincts 
            out_diff2)
    }
    {
      assume "B Out CC' C"
      hence "C InAngle A B E"
        by (metis InAngle_def P2 T1 assms(1) assms(2) between_exchange4)
    }
    hence "C InAngle A B E"
      using T1 ‹CC' = B ⟹ C InAngle A B E› by blast
  }
  thus ?thesis
    using P1 P2 ‹B Out CC C ∧ DD = B ⟹ C InAngle A B E› 
      ‹CC = B ∧ B Out DD D ⟹ C InAngle A B E› 
      ‹CC = B ∧ DD = B ⟹ C InAngle A B E› by blast
qed

lemma lea_trans:
  assumes "A B C LeA A1 B1 C1" and
    "A1 B1 C1 LeA A2 B2 C2"
  shows "A B C LeA A2 B2 C2"
proof -
  obtain P1 where T1: "P1 InAngle A1 B1 C1 ∧ A B C CongA A1 B1 P1"
    using LeA_def assms(1) by auto
  obtain P2 where T2: "P2 InAngle A2 B2 C2 ∧ A1 B1 C1 CongA A2 B2 P2"
    using LeA_def assms(2) by blast
  have T3: "A ≠ B"
    using CongA_def T1 by auto
  have T4: "C ≠ B"
    using CongA_def T1 by blast
  have T5: "A1 ≠ B1"
    using T1 inangle_distincts by blast
  have T6: "C1 ≠ B1"
    using T1 inangle_distincts by blast
  have T7: "A2 ≠ B2"
    using T2 inangle_distincts by blast
  have T8: "C2 ≠ B2"
    using T2 inangle_distincts by blast
  have T9: "Bet A B C  ∨ B Out A C ∨ ¬ Col A B C"
    using not_out_bet by auto
  {
    assume "Bet A B C"
    hence "A B C LeA A2 B2 C2"
      by (metis T1 T2 T3 T4 T7 T8 bet_conga__bet bet_in_angle_bet l11_31_2)
  }
  {
    assume "B Out A C"
    hence "A B C LeA A2 B2 C2"
      by (simp add: T7 T8 l11_31_1)
  }
  {
    assume H1: "¬ Col A B C"
    have T10: "Bet A2 B2 C2 ∨ B2 Out A2 C2 ∨ ¬ Col A2 B2 C2"
      using not_out_bet by auto
    {
      assume "Bet A2 B2 C2"
      hence "A B C LeA A2 B2 C2"
        by (simp add: T3 T4 T7 T8 l11_31_2)
    }
    {
      assume T10A: "B2 Out A2 C2"
      have "B Out A C"
      proof -
        have "B1 Out A1 P1"
        proof -
          have "B1 Out A1 C1" using T2 conga_sym T2 T10A in_angle_out out_conga_out by blast
          thus ?thesis using T1 in_angle_out by blast
        qed
        thus ?thesis using T1 conga_sym l11_21_a by blast
      qed
      hence "A B C LeA A2 B2 C2"
        using ‹B Out A C ⟹ A B C LeA A2 B2 C2› by blast
    }
    {
      assume T12: "¬ Col A2 B2 C2"
      obtain P where T13: "A B C CongA A2 B2 P ∧ A2 B2 OS P C2"
        using T12 H1 angle_construction_1 by blast
      have T14: "A2 B2 OS P2 C2"
      proof -
        have "¬ Col B2 A2 P2"
        proof -
          have "B2 ≠ A2"
            using T7 by auto
          {
            assume H2: "P2 = A2"
            have "A2 B2 A2 CongA A1 B1 C1"
              using T2 H2 conga_sym by blast
            hence "B1 Out A1 C1"
              using eq_conga_out by blast
            hence "B1 Out A1 P1"
              using T1 in_angle_out by blast
            hence "B Out A C"
              using T1 conga_sym out_conga_out by blast
            hence False
              using Col_cases H1 out_col by blast
          }
          hence "P2 ≠ A2" by blast
          have "Bet A2 B2 P2 ∨ B2 Out A2 P2 ∨ ¬ Col A2 B2 P2"
            using not_out_bet by auto
          {
            assume H4: "Bet A2 B2 P2"
            hence "Bet A2 B2 C2"
              using T2 bet_in_angle_bet by blast
            hence "Col B2 A2 P2 ⟶ False"
              using Col_def T12 by blast
            hence "¬ Col B2 A2 P2"
              using H4 bet_col not_col_permutation_4 by blast
          }
          {
            assume H5: "B2 Out A2 P2"
            hence "B1 Out A1 C1"
              using T2 conga_sym out_conga_out by blast
            hence "B1 Out A1 P1"
              using T1 in_angle_out by blast
            hence "B Out A C"
              using H1 T1 ncol_conga_ncol not_col_permutation_4 out_col by blast
            hence "¬ Col B2 A2 P2"
              using Col_perm H1 out_col by blast
          }
          {
            assume "¬ Col A2 B2 P2"
            hence "¬ Col B2 A2 P2"
              using Col_perm by blast
          }
          thus ?thesis
            using ‹B2 Out A2 P2 ⟹ ¬ Col B2 A2 P2› ‹Bet A2 B2 P2 ⟹ ¬ Col B2 A2 P2› 
              ‹Bet A2 B2 P2 ∨ B2 Out A2 P2 ∨ ¬ Col A2 B2 P2› by blast
        qed
        thus ?thesis
          by (simp add: T2 T12 in_angle_one_side)
      qed
      have S1: "A2 B2 OS P P2"
        using T13 T14 one_side_symmetry one_side_transitivity by blast
      have "A1 B1 P1 CongA A2 B2 P"
        using conga_trans conga_sym T1 T13 by blast
      hence "P InAngle A2 B2 P2"
        using conga_preserves_in_angle T2 T1 S1 by blast
      hence "P InAngle A2 B2 C2"
        using T2 in_angle_trans by blast
      hence "A B C LeA A2 B2 C2"
        using T13 LeA_def by blast
    }
    hence "A B C LeA A2 B2 C2"
      using T10 ‹B2 Out A2 C2 ⟹ A B C LeA A2 B2 C2› 
        ‹Bet A2 B2 C2 ⟹ A B C LeA A2 B2 C2› by blast
  }
  thus ?thesis
    using T9 ‹B Out A C ⟹ A B C LeA A2 B2 C2› 
      ‹Bet A B C ⟹ A B C LeA A2 B2 C2› by blast
qed

lemma in_angle_asym:
  assumes "D InAngle A B C" and
    "C InAngle A B D"
  shows "A B C CongA A B D"
proof -
  obtain CC where P1: "Bet A CC D ∧ (CC = B ∨ B Out CC C)"
    using InAngle_def assms(2) by auto
  obtain DD where P2: "Bet A DD C ∧ (DD = B ∨ B Out DD D)"
    using InAngle_def assms(1) by auto
  {
    assume "(CC = B) ∧ (DD = B)"
    hence "A B C CongA A B D"
      by (metis P1 P2 assms(2) conga_line inangle_distincts)
  }
  {
    assume "(CC = B) ∧ (B Out DD D)"
    hence "A B C CongA A B D"
      by (metis P1 assms(1) bet_in_angle_bet conga_line inangle_distincts)
  }
  {
    assume "(B Out CC C) ∧ (DD = B)"
    hence "A B C CongA A B D"
      by (metis P2 assms(2) bet_in_angle_bet conga_line inangle_distincts)
  }
  {
    assume V1: "(B Out CC C) ∧ (B Out DD D)"
    obtain X where P3: "Bet CC X C ∧ Bet DD X D"
      using P1 P2 between_symmetry inner_pasch by blast
    hence "B Out X D"
      using V1 out_bet_out_2 by blast
    hence "B Out C D"
      using P3 V1 out2_bet_out by blast
    hence "A B C CongA A B D"
      using assms(2) inangle_distincts l6_6 out2__conga out_trivial by blast
  }
  thus ?thesis using P1 P2
    using ‹B Out CC C ∧ DD = B ⟹ A B C CongA A B D› 
      ‹CC = B ∧ B Out DD D ⟹ A B C CongA A B D› 
      ‹CC = B ∧ DD = B ⟹ A B C CongA A B D› by blast
qed

lemma lea_asym:
  assumes "A B C LeA D E F" and
    "D E F LeA A B C"
  shows "A B C CongA D E F"
proof cases
  assume P1: "Col A B C"
  {
    assume P1A: "Bet A B C"
    have P2: "D ≠ E"
      using assms(1) lea_distincts by blast
    have P3: "F ≠ E"
      using assms(2) lea_distincts by auto
    have P4: "A ≠ B"
      using assms(1) lea_distincts by auto
    have P5: "C ≠ B"
      using assms(2) lea_distincts by blast
    obtain P where P6: "P InAngle D E F ∧ A B C CongA D E P"
      using LeA_def assms(1) by blast
    hence "A B C CongA D E P" by simp
    hence "Bet D E P" using P1 P1A bet_conga__bet
      by blast
    hence "Bet D E F"
      using P6 bet_in_angle_bet by blast
    hence "A B C CongA D E F"
      by (metis bet_conga__bet conga_line l11_29_a P2 P3 P4 P5 assms(2) bet_in_angle_bet)
  }
  {
    assume T1: "¬ Bet A B C"
    hence T2: "B Out A C"
      using P1 not_out_bet by auto
    obtain P where T3: "P InAngle A B C ∧ D E F CongA A B P"
      using LeA_def assms(2) by blast
    hence T3A: "P InAngle A B C" by simp
    have T3B: "D E F CongA A B P" using T3 by simp
    have T4: "E Out D F"
    proof -
      have T4A: "B Out A P"
        using T2 T3 in_angle_out by blast
      have "A B P CongA D E F"
        by (simp add: T3 conga_sym)
      thus ?thesis
        using T4A l11_21_a by blast
    qed
    hence "A B C CongA D E F"
      by (simp add: T2 l11_21_b)
  }
  thus ?thesis
    using ‹Bet A B C ⟹ A B C CongA D E F› by blast
next
  assume T5: "¬ Col A B C"
  obtain Q where T6: "C InAngle A B Q ∧ A B Q CongA D E F"
    using assms(1) l11_29_a by blast
  hence T6A: "C InAngle A B Q" by simp
  have T6B: "A B Q CongA D E F" by (simp add: T6)
  obtain P where T7: "P InAngle A B C ∧ D E F CongA A B P"
    using LeA_def assms(2) by blast
  hence T7A: "P InAngle A B C" by simp
  have T7B: "D E F CongA A B P" by (simp add: T7)
  have T13: "A B Q CongA  A B P"
    using T6 T7 conga_trans by blast
  have T14: "Bet A B Q ∨ B Out A Q ∨ ¬ Col A B Q"
    using not_out_bet by auto
  {
    assume R1: "Bet A B Q"
    hence "A B C CongA D E F"
      using T13 T5 T7 bet_col bet_conga__bet bet_in_angle_bet by blast
  }
  {
    assume R2: "B Out A Q"
    hence "A B C CongA D E F"
      using T6 in_angle_out l11_21_a l11_21_b by blast
  }
  {
    assume R3: "¬ Col A B Q"
    have R3A: "Bet A B P ∨ B Out A P ∨ ¬ Col A B P"
      using not_out_bet by blast
    {
      assume R3AA: "Bet A B P"
      hence "A B C CongA D E F"
        using T5 T7 bet_col bet_in_angle_bet by blast
    }
    {
      assume R3AB: "B Out A P"
      hence "A B C CongA D E F"
        by (meson Col_cases R3 T13 ncol_conga_ncol out_col)
    }
    {
      assume R3AC: "¬ Col A B P"
      have R3AD: "B Out P Q ∨ A B TS P Q"
      proof -
        have "Coplanar A B P Q"
          using T6A T7A coplanar_perm_8 in_angle_trans inangle__coplanar by blast
        thus ?thesis
          by (simp add: T13 conga_sym conga_cop__or_out_ts)
      qed
      {
        assume "B Out P Q"
        hence "C InAngle A B P"
          by (meson R3 T6A bet_col between_symmetry l11_24 l11_25_aux)
        hence "A B C CongA A B P"
          by (simp add: T7A in_angle_asym)
        hence "A B C CongA D E F"
          by (meson T7B conga_sym conga_trans Tarski_neutral_dimensionless_axioms)
      }
      {
        assume W1: "A B TS P Q"
        have "A B OS P Q"
          using Col_perm R3 R3AC T6A T7A in_angle_one_side in_angle_trans by blast
        hence "A B C CongA D E F"
          using W1 l9_9 by blast
      }
      hence "A B C CongA D E F"
        using R3AD ‹B Out P Q ⟹ A B C CongA D E F› by blast
    }
    hence "A B C CongA D E F"
      using R3A ‹B Out A P ⟹ A B C CongA D E F› 
        ‹Bet A B P ⟹ A B C CongA D E F› by blast
  }
  thus ?thesis
    using T14 ‹B Out A Q ⟹ A B C CongA D E F› 
      ‹Bet A B Q ⟹ A B C CongA D E F› by blast
qed

lemma col_lta__bet:
  assumes "Col X Y Z" and
    "A B C LtA X Y Z"
  shows "Bet X Y Z"
proof -
  have "A B C LeA X Y Z ∧ ¬ A B C CongA X Y Z"
    using LtA_def assms(2) by auto
  hence "Y Out X Z ⟶ False"
    using lea_asym lea_distincts Tarski_neutral_dimensionless_axioms l11_31_1
    by fastforce
  thus ?thesis using not_out_bet assms(1)
    by blast
qed

lemma col_lta__out:
  assumes "Col A B C" and
    "A B C LtA X Y Z"
  shows "B Out A C"
proof -
  have "A B C LeA X Y Z ∧ ¬ A B C CongA X Y Z"
    using LtA_def assms(2) by auto
  thus ?thesis
    by (metis assms(1) l11_31_2 lea_asym lea_distincts or_bet_out)
qed

lemma lta_distincts:
  assumes "A B C LtA D E F"
  shows "A≠B ∧ C≠B ∧ D≠E ∧ F≠E ∧ D ≠ F"
  by (metis LtA_def assms bet_neq12__neq col_lta__bet lea_distincts not_col_distincts)

lemma gta_distincts:
  assumes "A B C GtA D E F"
  shows "A≠B ∧ C≠B ∧ D≠E ∧ F≠E ∧ A ≠ C"
  using GtA_def assms lta_distincts by presburger

lemma acute_distincts:
  assumes "Acute A B C"
  shows "A≠B ∧ C≠B"
  using Acute_def assms lta_distincts by blast

lemma obtuse_distincts:
  assumes "Obtuse A B C"
  shows "A≠B ∧ C≠B ∧ A ≠ C"
  using Obtuse_def assms lta_distincts by blast

lemma two_sides_in_angle:
  assumes "B ≠ P'" and
    "B P TS A C" and
    "Bet P B P'"
  shows "P InAngle A B C ∨ P' InAngle A B C"
proof -
  obtain T where P1: "Col T B P ∧ Bet A T C"
    using TS_def assms(2) by auto
  have P2: "A ≠ B"
    using assms(2) ts_distincts by blast
  have P3: "C ≠ B"
    using assms(2) ts_distincts by blast
  show ?thesis
  proof cases
    assume "B = T"
    thus ?thesis
      using P1 P2 P3 assms(1) in_angle_line by auto
  next
    assume "B ≠ T"
    thus ?thesis
      by (metis InAngle_def P1 assms(1) assms(2) assms(3) between_symmetry l6_3_2 
          or_bet_out ts_distincts)
  qed
qed

lemma in_angle_reverse:
  assumes "A' ≠ B" and
    "Bet A B A'" and
    "C InAngle A B D"
  shows "D InAngle A' B C"
proof -
  have P1: "A ≠ B"
    using assms(3) inangle_distincts by auto
  have P2: "D ≠ B"
    using assms(3) inangle_distincts by blast
  have P3: "C ≠ B"
    using assms(3) inangle_distincts by auto
  show ?thesis
  proof cases
    assume "Col B A C"
    {
      assume "Bet C B A"
      hence "Bet A B D" 
        using Bet_cases assms(3) bet_in_angle_bet by blast
      hence "D InAngle A' B C" 
        by (metis P1 P2 P3 ‹Bet C B A› assms(1) between_symmetry l6_2 out341__inangle)
    }
    moreover
    {
      assume "B Out C A"
      hence "D InAngle A' B C" 
        by (meson InAngle_def Out_cases P2 P3 assms(1) assms(2) bet_out__bet l11_24)
    }
    moreover
    {
      assume "¬ Col C B A"
      hence "D InAngle A' B C" 
        using ‹Col B A C› not_col_permutation_1 by blast
    }
    ultimately show ?thesis
      using l6_4_2 by blast
  next
    assume P4: "¬ Col B A C"
    thus ?thesis
    proof cases
      assume "Col B D C"
      {
        assume "Bet C B D"
        hence "D InAngle A' B C" 
          by (meson Col_def P2 P4 assms(3) bet_in_angle_bet between_symmetry 
              col_transitivity_2 l11_24)
      }
      moreover
      {
        assume "B Out C D"
        hence "D InAngle A' B C" 
          using assms(1) out341__inangle by blast
      }
      moreover
      {
        assume "¬ Col C B D"
        hence "D InAngle A' B C" 
          using ‹Col B D C› col_permutation_2 by blast
      }
      ultimately show ?thesis 
        using not_out_bet by blast
    next
      assume P5: "¬ Col B D C"
      have P6: "C B TS A D"
        using P4 P5 assms(3) in_angle_two_sides by auto
      obtain X where P7: "Bet A X D ∧ (X = B ∨ B Out X C)"
        using InAngle_def assms(3) by auto
      have P8: "X = B ⟹ D InAngle A' B C"
        using Out_def P1 P2 P3 P7 assms(1) assms(2) l5_2 out321__inangle by auto
      {
        assume P9: "B Out X C"
        have P10: "C ≠ B"
          by (simp add: P3)
        have P10A: "¬ Col B A C"
          by (simp add: P4)
        have P10B: "¬ Col B D C"
          by (simp add: P5)
        have P10C: "C InAngle D B A"
          by (simp add: assms(3) l11_24)
        {
          assume "Col D B A"
          have "Col B A C"
          proof -
            have "B ≠ X"
              using P9 out_distinct by blast
            have "Col B X A"
              by (meson Bet_perm P10C P5 P7 ‹Col D B A› bet_col1 col_permutation_3 
                  in_angle_out or_bet_out out_col)
            have "Col B X C"
              by (simp add: P9 out_col)
            thus ?thesis
              using ‹B ≠ X› ‹Col B X A› col_transitivity_1 by blast
          qed
          hence False
            by (simp add: P4)
        }
        hence P10E: "¬ Col D B A" by auto
        have P11: "D B OS C A"
          by (simp add: P10C P10E P5 in_angle_one_side)
        have P12: "¬ Col A D B"
          using Col_cases P10E by auto
        have P13: "¬ Col A' D B"
          by (metis Col_def ‹Col D B A ⟹ False› assms(1) assms(2) col_transitivity_1)
        have P14: "D B TS A A'"
          using P12 P13 TS_def assms(2) col_trivial_3 by blast
        have P15: "D B TS C A'"
          using P11 P14 l9_8_2 one_side_symmetry by blast
        have P16: "¬ Col C D B"
          by (simp add: P5 not_col_permutation_3)
        obtain Y where P17: "Col Y D B ∧ Bet C Y A'"
          using P15 TS_def by auto
        have P18: "Bet A' Y C"
          using Bet_perm P17 by blast
        {
          assume S1: "Y ≠ B"
          have S2: "Col D B Y"
            using P17 not_col_permutation_2 by blast
          hence S3: "Bet D B Y ∨ Bet B Y D ∨ Bet Y D B"
            using Col_def S2 by auto
          {
            assume S4: "Bet D B Y"
            have S5: "C B OS A' Y"
              by (metis P17 P18 P5 S1 bet_out_1 col_transitivity_2 l6_6 
                  not_col_permutation_3 not_col_permutation_5 out_one_side)
            have S6: "C B TS Y D"
              by (metis Bet_perm P16 P17 S1 S4 bet__ts col3 col_trivial_3 
                  invert_two_sides not_col_permutation_1)
            have "C B TS A A'"
              by (metis P4 assms(1) assms(2) bet__ts invert_two_sides 
                  not_col_permutation_5)
            hence "C B TS Y A"
              using S5 l9_2 l9_8_2 by blast
            hence S9: "C B OS A D"
              using P6 S6 l9_8_1 l9_9 by blast
            hence "B Out Y D"
              using P6 S9 l9_9 by auto
          }
          {
            assume "Bet B Y D"
            hence "B Out Y D"
              by (simp add: S1 bet_out)
          }
          {
            assume "Bet Y D B"
            hence "B Out Y D"
              by (simp add: P2 bet_out_1 l6_6)
          }
          have "B Out Y D"
            using S3 ‹Bet B Y D ⟹ B Out Y D› ‹Bet D B Y ⟹ B Out Y D› 
              ‹Bet Y D B ⟹ B Out Y D› by blast
        }
        hence P19: "(Y = B ∨ B Out Y D)" by auto
        have "D InAngle A' B C"
          using InAngle_def P18 P19 P2 P3 assms(1) by auto
      }
      thus ?thesis using P7 P8 by blast
    qed
  qed
qed

lemma in_angle_trans2:
  assumes "C InAngle A B D" and
    "D InAngle A B E"
  shows "D InAngle C B E"
  by (smt (verit, ccfv_threshold) Bet_cases assms(1,2) in_angle_reverse in_angle_trans
      inangle_distincts l11_24 point_construction_different)

lemma l11_36_aux1:
  assumes "A ≠ B" and
    "A' ≠ B" and
    "D ≠ E" and
    "D' ≠ E" and
    "Bet A B A'" and
    "Bet D E D'" and
    "A B C LeA D E F"
  shows "D' E F LeA A' B C"
proof -
  obtain P where P1: "C InAngle A B P ∧
A B P CongA D E F"
    using assms(7) l11_29_a by blast
  thus ?thesis
    by (metis LeA_def l11_13 assms(2) assms(4) assms(5) assms(6) conga_sym in_angle_reverse)
qed

lemma l11_36_aux2:
  assumes "A ≠ B" and
    "A' ≠ B" and
    "D ≠ E" and
    "D' ≠ E" and
    "Bet A B A'" and
    "Bet D E D'" and
    "D' E F LeA A' B C"
  shows "A B C LeA D E F"
  by (metis Bet_cases assms(1) assms(3) assms(5) assms(6) assms(7) l11_36_aux1 lea_distincts)

lemma l11_36:
  assumes "A ≠ B" and
    "A' ≠ B" and
    "D ≠ E" and
    "D' ≠ E" and
    "Bet A B A'" and
    "Bet D E D'"
  shows "A B C LeA D E F ⟷ D' E F LeA A' B C"
  using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l11_36_aux1 l11_36_aux2 by auto

lemma l11_41_aux:
  assumes "¬ Col A B C" and
    "Bet B A D" and
    "A ≠ D"
  shows "A C B LtA C A D"
proof -
  obtain M where P1: "M Midpoint A C"
    using midpoint_existence by auto
  obtain P where P2: "M Midpoint B P"
    using symmetric_point_construction by auto
  have P3: "A C B Cong3 C A P"
    using Cong3_def P1 P2 assms(1) l7_13_R1 l7_2 midpoint_distinct_1 not_col_distincts 
    by meson
  have P4: "A ≠ C"
    using assms(1) col_trivial_3 by blast
  have P5: "B ≠ C"
    using assms(1) col_trivial_2 by blast
  have P7: "A ≠ M"
    using P1 P4 is_midpoint_id by blast
  have P8: "A C B CongA C A P"
    by (simp add: P3 P4 P5 cong3_conga)
  have P8A: "Bet D A B"
    using Bet_perm assms(2) by blast
  have P8B: "Bet P M B"
    by (simp add: P2 between_symmetry midpoint_bet)
  then obtain X where P9: "Bet A X P ∧ Bet M X D" using P8A inner_pasch by blast
  have P9A: "Bet A X P" by (simp add: P9)
  have P9B: "Bet M X D" by (simp add: P9)
  have P10A: "P InAngle C A D"
  proof -
    have K1: "P InAngle M A D"
      by (metis InAngle_def P3 P5 P7 P9 assms(3) bet_out cong3_diff2)
    have K2: "A Out C M"
      using Out_def P1 P4 P7 midpoint_bet by auto
    have K3: "A Out D D"
      using assms(3) out_trivial by auto
    have "A Out P P"
      using K1 inangle_distincts out_trivial by auto
    thus ?thesis
      using K1 K2 K3 l11_25 by blast
  qed
  hence P10: "A C B LeA C A D"
    using LeA_def P8 by auto
  {
    assume K5: "A C B CongA C A D"
    hence K6: "C A D CongA C A P"
      using P8 conga_sym conga_trans by blast
    have K7: "Coplanar C A D P"
      using P10A inangle__coplanar ncoplanar_perm_18 by blast
    hence K8: "A Out D P ∨ C A TS D P"
      by (simp add: K6 conga_cop__or_out_ts)
    {
      assume "A Out D P"
      hence "Col M B A"
        by (meson P8A P8B bet_col1 bet_out__bet between_symmetry not_col_permutation_4)
      hence K8F: "Col A M B"
        using not_col_permutation_1 by blast
      have "Col A M C"
        by (simp add: P1 bet_col midpoint_bet)
      hence "False"
        using K8F P7 assms(1) col_transitivity_1 by blast
    }
    hence K9: "¬ A Out D P" by auto
    {
      assume V1: "C A TS D P"
      hence V3: "A C TS B P"
        by (metis P10A P8A assms(1) col_trivial_1 col_trivial_2 in_angle_reverse 
            in_angle_two_sides invert_two_sides l11_24 l9_18 not_col_permutation_5)
      have "A C TS B D"
        by (simp add: assms(1) assms(2) assms(3) bet__ts not_col_permutation_5)
      hence "A C OS D P"
        using V1 V3 invert_two_sides l9_8_1 l9_9 by blast
      hence "False"
        using V1 invert_one_side l9_9 by blast
    }
    hence "¬ C A TS D P" by auto
    hence "False" using K8 K9 by auto
  }
  hence "¬ A C B CongA C A D" by auto
  thus ?thesis
    by (simp add: LtA_def P10)
qed

lemma l11_41:
  assumes "¬ Col A B C" and
    "Bet B A D" and
    "A ≠ D"
  shows "A C B LtA C A D ∧ A B C LtA C A D"
proof -
  have P1: "A C B LtA C A D"
    using assms(1) assms(2) assms(3) l11_41_aux by auto
  have "A B C LtA C A D"
  proof -
    obtain E where T1: "Bet C A E ∧ Cong A E C A"
      using segment_construction by blast
    have T1A: "Bet C A E" using T1 by simp
    have T1B: "Cong A E C A" using T1 by simp
    have T2: "A B C LtA B A E"
      using T1 assms(1) cong_reverse_identity l11_41_aux not_col_distincts 
        not_col_permutation_5 by blast
    have T3: "B A C CongA C A B"
      by (metis assms(1) conga_pseudo_refl not_col_distincts)
    have T3A: "D A C CongA E A B"
      by (metis CongA_def T1 T3 assms(2) assms(3) cong_reverse_identity l11_13)
    hence T4: "B A E CongA C A D"
      using conga_comm conga_sym by blast
    have "A B C CongA A B C"
      using T2 conga_refl lta_distincts by blast
    hence T5: "A B C LeA C A D"
      by (meson T2 T4 LtA_def l11_30)
    have "¬ A B C CongA C A D"
      by (meson T2 LtA_def conga_right_comm conga_trans T3A)
    thus ?thesis
      by (simp add: LtA_def T5)
  qed
  thus ?thesis by (simp add: P1)
qed

lemma not_conga:
  assumes "A B C CongA A' B' C'" and
    "¬ A B C CongA D E F"
  shows "¬ A' B' C' CongA D E F"
  by (meson assms(1) assms(2) conga_trans)

lemma not_conga_sym:
  assumes "¬ A B C CongA D E F"
  shows "¬ D E F CongA A B C"
  using assms conga_sym by blast

lemma not_and_lta:
  shows "¬ (A B C LtA D E F ∧ D E F LtA A B C)"
proof -
  {
    assume "A B C LtA D E F" and "D E F LtA A B C"
    hence "A B C CongA D E F"
      using LtA_def lea_asym by blast
    hence "False" 
      using LtA_def ‹D E F LtA A B C› not_conga_sym by blast
  }
  thus ?thesis by auto
qed

lemma conga_preserves_lta:
  assumes "A B C CongA A' B' C'" and
    "D E F CongA D' E' F'" and
    "A B C LtA D E F"
  shows "A' B' C' LtA D' E' F'"
  by (meson LtA_def conga_trans l11_30 not_conga_sym assms(1) assms(2) assms(3))

lemma lta_trans:
  assumes "A B C LtA A1 B1 C1" and
    "A1 B1 C1 LtA A2 B2 C2"
  shows "A B C LtA A2 B2 C2"
proof -
  have P1: "A B C LeA A2 B2 C2"
    by (meson LtA_def assms(1) assms(2) lea_trans)
  {
    assume "A B C CongA A2 B2 C2"
    hence "False"
      by (meson LtA_def lea_asym lea_trans assms(1) assms(2) conga__lea456123)
  }
  thus ?thesis
    using LtA_def P1 by blast
qed

lemma obtuse_sym:
  assumes "Obtuse A B C"
  shows "Obtuse C B A"
  by (meson Obtuse_def lta_right_comm assms)

lemma acute_sym:
  assumes "Acute A B C"
  shows "Acute C B A"
  by (meson Acute_def lta_left_comm assms)

lemma acute_col__out:
  assumes "Col A B C" and
    "Acute A B C"
  shows "B Out A C"
  by (meson Acute_def assms(1) assms(2) col_lta__out)

lemma col_obtuse__bet:
  assumes "Col A B C" and
    "Obtuse A B C"
  shows "Bet A B C"
  using Obtuse_def assms(1) assms(2) col_lta__bet by blast

lemma out__acute:
  assumes "B Out A C"
  shows "Acute A B C"
proof -
  have P1: "A ≠ B"
    using assms out_diff1 by auto
  then obtain D where P3: "B D Perp A B"
    using perp_exists by blast
  hence P4: "B ≠ D"
    using perp_distinct by auto
  have P5: "Per A B D"
    by (simp add: P3 l8_2 perp_per_1)
  have P6: "A B C LeA A B D"
    using P1 P4 assms l11_31_1 by auto
  {
    assume "A B C CongA A B D"
    hence "False"
      by (metis Col_cases P1 P4 P5 assms col_conga_col l8_9 out_col)
  }
  hence "A B C LtA A B D"
    using LtA_def P6 by auto
  thus ?thesis
    using P5 Acute_def by auto
qed

lemma bet__obtuse:
  assumes "Bet A B C" and
    "A ≠ B" and "B ≠ C"
  shows "Obtuse A B C"
proof -
  obtain D where P1: "B D Perp A B"
    using assms(2) perp_exists by blast
  have P5: "B ≠ D"
    using P1 perp_not_eq_1 by auto
  have P6: "Per A B D"
    using P1 Perp_cases perp_per_1 by blast
  have P7: "A B D LeA A B C"
    using assms(2) assms(3) P5 assms(1) l11_31_2 by auto
  {
    assume "A B D CongA A B C"
    hence "False"
      using assms(2) P5 P6 assms(1) bet_col ncol_conga_ncol per_not_col by blast
  }
  hence "A B D LtA A B C"
    using LtA_def P7 by blast
  thus ?thesis
    using Obtuse_def P6 by blast
qed

lemma l11_43_aux:
  assumes "A ≠ B" and
    "A ≠ C" and
    "Per B A C ∨ Obtuse B A C"
  shows "Acute A B C"
proof cases
  assume P1: "Col A B C"
  {
    assume "Per B A C"
    hence "Acute A B C"
      using Col_cases P1 assms(1) assms(2) per_col_eq by blast
  }
  {
    assume "Obtuse B A C"
    hence "Bet B A C"
      using P1 col_obtuse__bet col_permutation_4 by blast
    hence "Acute A B C"
      by (simp add: assms(1) bet_out out__acute)
  }
  thus ?thesis
    using ‹Per B A C ⟹ Acute A B C› assms(3) by blast
next
  assume P2: "¬ Col A B C"
  hence P3: "B ≠ C"
    using col_trivial_2 by auto
  obtain B' where P4: "Bet B A B' ∧ Cong A B' B A"
    using segment_construction by blast
  have P5: "¬ Col B' A C"
    by (metis Col_def P2 P4 col_transitivity_2 cong_reverse_identity)
  hence P6: "B' ≠ A ∧ B' ≠ C"
    using not_col_distincts by blast
  hence P7: "A C B LtA C A B' ∧ A B C LtA C A B'"
    using P2 P4 l11_41 by auto
  hence P7A: "A C B LtA C A B'" by simp
  have P7B: "A B C LtA C A B'" by (simp add: P7)
  {
    assume "Per B A C"
    have "Acute A B C"
      by (metis Acute_def P4 P7B ‹Per B A C› assms(1) bet_col col_per2__per 
          col_trivial_3 l8_3 lta_right_comm)
  }
  {
    assume T1: "Obtuse B A C"
    then obtain a b c where T2: "Per a b c ∧ a b c LtA B A C"
      using Obtuse_def by blast
    hence T2A: "Per a b c" by simp
    have T2B: "a b c LtA B A C" by (simp add: T2)
    hence T3: "a b c LeA B A C ∧ ¬ a b c CongA B A C"
      by (simp add: LtA_def)
    hence T3A: "a b c LeA B A C" by simp
    have T3B: "¬ a b c CongA B A C" by (simp add: T3)
    obtain P where T4: "P InAngle B A C ∧ a b c CongA B A P"
      using LeA_def T3 by blast
    hence T5: "Per B A P" using T4 T2 l11_17 by blast
    hence T6: "Per P A B"
      using l8_2 by blast
    have "Col A B B'"
      by (simp add: P4 bet_col col_permutation_4)
    hence "Per P A B'"
      using T6 assms(1) per_col by blast
    hence S3: "B A P CongA B' A P"
      using l8_2 P6 T5 T4 CongA_def assms(1) l11_16 by auto
    have "C A B' LtA P A B"
    proof -
      have S4: "B A P LeA B A C ⟷ B' A C LeA B' A P"
        using P4 P6 assms(1) l11_36 by auto
      have S5: "C A B' LeA P A B"
      proof -
        have S6: "B A P LeA B A C"
          using T4 inangle__lea by auto
        have "B' A P CongA P A B"
          using S3 conga_left_comm not_conga_sym by blast
        thus ?thesis
          using P6 S4 S6 assms(2) conga_pseudo_refl l11_30 by auto
      qed
      {
        assume T10: "C A B' CongA P A B"
        have "Per B' A C"
        proof -
          have "B A P CongA B' A C"
            using T10 conga_comm conga_sym by blast
          thus ?thesis
            using T5 l11_17 by blast
        qed
        hence "Per C A B"
          using Col_cases P6 ‹Col A B B'› l8_2 l8_3 by blast
        have "a b c CongA B A C"
        proof -
          have "a ≠ b"
            using T3A lea_distincts by auto
          have "c ≠ b"
            using T2B lta_distincts by blast
          have "Per B A C"
            using Per_cases ‹Per C A B› by blast
          thus ?thesis
            using T2 ‹a ≠ b› ‹c ≠ b› assms(1) assms(2) l11_16 by auto
        qed
        hence "False"
          using T3B by blast
      }
      hence "¬ C A B' CongA P A B" by blast
      thus ?thesis
        by (simp add: LtA_def S5)
    qed
    hence "A B C LtA B A P"
      by (meson P7 lta_right_comm lta_trans)
    hence "Acute A B C"  using T5
      using Acute_def by blast
  }
  thus ?thesis
    using ‹Per B A C ⟹ Acute A B C› assms(3) by blast
qed

lemma l11_43:
  assumes "A ≠ B" and
    "A ≠ C" and
    "Per B A C ∨ Obtuse B A C"
  shows "Acute A B C ∧ Acute A C B"
  using Per_perm assms(1) assms(2) assms(3) l11_43_aux obtuse_sym by blast

lemma acute_lea_acute:
  assumes "Acute D E F" and
    "A B C LeA D E F"
  shows "Acute A B C"
proof -
  obtain A' B' C' where P1: "Per A' B' C' ∧ D E F LtA A' B' C'"
    using Acute_def assms(1) by auto
  have P2: "A B C LeA A' B' C'"
    using LtA_def P1 assms(2) lea_trans by blast
  have "¬ A B C CongA A' B' C'"
    by (meson LtA_def P1 assms(2) conga__lea456123 lea_asym lea_trans)
  hence "A B C LtA A' B' C'"
    by (simp add: LtA_def P2)
  thus ?thesis
    using Acute_def P1 by auto
qed

lemma lea_obtuse_obtuse:
  assumes "Obtuse D E F" and
    "D E F LeA A B C"
  shows "Obtuse A B C"
proof -
  obtain A' B' C' where P1: "Per A' B' C' ∧ A' B' C' LtA D E F"
    using Obtuse_def assms(1) by auto
  hence P2: "A' B' C' LeA A B C"
    using LtA_def assms(2) lea_trans by blast
  have "¬ A' B' C' CongA A B C"
    by (meson LtA_def P1 assms(2) conga__lea456123 lea_asym lea_trans)
  hence "A' B' C' LtA A B C"
    by (simp add: LtA_def P2)
  thus ?thesis
    using Obtuse_def P1 by auto
qed

lemma l11_44_1_a:
  assumes "A ≠ B" and
    "A ≠ C" and
    "Cong B A B C"
  shows "B A C CongA B C A"
  using Cong3_def assms(1) assms(2) assms(3) cong3_conga cong_inner_transitivity 
    cong_pseudo_reflexivity by metis

lemma l11_44_2_a:
  assumes "¬ Col A B C" and
    "B A Lt B C"
  shows "B C A LtA B A C"
proof -
  have T1: "A ≠ B"
    using assms(1) col_trivial_1 by auto
  have T3: "A ≠ C"
    using assms(1) col_trivial_3 by auto
  have "B A Le B C"
    by (simp add: assms(2) lt__le)
  then obtain C' where P1: "Bet B C' C ∧ Cong B A B C'"
    using assms(2) Le_def by blast
  have T5: "C ≠ C'"
    using P1 assms(2) cong__nlt by blast
  have T5A: "C' ≠ A"
    using Col_def Col_perm P1 assms(1) by blast
  hence T6: "C' InAngle B A C"
    using InAngle_def P1 T1 T3 out_trivial by auto
  have T7: "C' A C LtA A C' B ∧ C' C A LtA A C' B"
  proof -
    have W1: "¬ Col C' C A"
      by (metis Col_def P1 T5 assms(1) col_transitivity_2)
    have W2: "Bet C C' B"
      using Bet_perm P1 by blast
    have "C' ≠ B"
      using P1 T1 cong_identity by blast
    thus ?thesis
      using l11_41 W1 W2 by simp
  qed
  have T90: "B A C' LtA B A C"
  proof -
    have T90A: "B A C' LeA B A C"
      by (simp add: T6 inangle__lea)
    have "B A C' CongA B A C'"
      using T1 T5A conga_refl by auto
    {
      assume "B A C' CongA B A C"
      hence R1: "A Out C' C"
        by (metis P1 T7 assms(1) bet_out conga_os__out lta_distincts not_col_permutation_4 
            out_one_side)
      have "B A OS C' C"
        by (metis Col_perm P1 T1 assms(1) bet_out cong_diff_2 out_one_side)
      hence "False"
        using Col_perm P1 T5 R1 bet_col col2__eq one_side_not_col123 out_col by blast
    }
    hence "¬ B A C' CongA B A C" by blast
    thus ?thesis
      by (simp add: LtA_def T90A)
  qed
  have "B A C' CongA B C' A"
    using P1 T1 T5A l11_44_1_a by auto
  hence K2: "A C' B CongA B A C'"
    using conga_left_comm not_conga_sym by blast
  have "B C A LtA B A C'"
  proof -
    have K1: "B C A CongA B C A"
      using assms(1) conga_refl not_col_distincts by blast
    have "B C A LtA A C' B"
    proof -
      have "C' C A CongA B C A"
      proof -
        have K2: "C Out B C'"
          using P1 T5 bet_out_1 l6_6 by auto
        have "C Out A A"
          by (simp add: T3 out_trivial)
        thus ?thesis
          by (simp add: K2 out2__conga)
      qed
      have "A C' B CongA A C' B"
        using CongA_def K2 conga_refl by auto
      thus ?thesis
        using T7 ‹C' C A CongA B C A› conga_preserves_lta by auto
    qed
    thus ?thesis
      using K1 K2 conga_preserves_lta by auto
  qed
  thus ?thesis
    using T90 lta_trans by blast
qed

lemma not_lta_and_conga:
  "¬ ( A B C LtA D E F ∧ A B C CongA D E F)"
  by (simp add: LtA_def)

lemma conga_sym_equiv:
  "A B C CongA A' B' C' ⟷ A' B' C' CongA A B C"
  using not_conga_sym by blast

lemma conga_dec:
  "A B C CongA D E F ∨ ¬ A B C CongA D E F"
  by auto

lemma lta_not_conga:
  assumes "A B C LtA D E F"
  shows "¬ A B C CongA D E F"
  using assms not_lta_and_conga by auto

lemma lta__lea:
  assumes "A B C LtA D E F"
  shows "A B C LeA D E F"
  using LtA_def assms by auto

lemma nlta:
  "¬ A B C LtA A B C"
  using not_and_lta by blast

lemma lea__nlta:
  assumes "A B C LeA D E F"
  shows "¬ D E F LtA A B C"
  by (meson lea_asym not_lta_and_conga assms lta__lea)

lemma lta__nlea:
  assumes "A B C LtA D E F"
  shows "¬ D E F LeA A B C"
  using assms lea__nlta by blast

lemma l11_44_1_b:
  assumes "¬ Col A B C" and
    "B A C CongA B C A"
  shows "Cong B A B C"
proof -
  have "B A Lt B C ∨ B A Gt B C ∨ Cong B A B C"
    by (simp add: or_lt_cong_gt)
  thus ?thesis
    by (meson Gt_def assms(1) assms(2) conga_sym l11_44_2_a not_col_permutation_3 
        not_lta_and_conga)
qed

lemma l11_44_2_b:
  assumes "B A C LtA B C A"
  shows "B C Lt B A"
proof cases
  assume "Col A B C"
  thus ?thesis
    using Col_perm assms bet__lt1213 col_lta__bet lta_distincts by blast
next
  assume P1: "¬ Col A B C"
  hence P2: "A ≠ B"
    using col_trivial_1 by blast
  have P3: "A ≠ C"
    using P1 col_trivial_3 by auto
  have "B A Lt B C ∨ B A Gt B C ∨ Cong B A B C"
    by (simp add: or_lt_cong_gt)
  {
    assume "B A Lt B C"
    hence "B C Lt B A"
      using P1 assms l11_44_2_a not_and_lta by blast
  }
  {
    assume "B A Gt B C"
    hence "B C Lt B A"
      using Gt_def P1 assms l11_44_2_a not_and_lta by blast
  }
  {
    assume "Cong B A B C"
    hence "B A C CongA B C A"
      by (simp add: P2 P3 l11_44_1_a)
    hence "B C Lt B A"
      using assms not_lta_and_conga by blast
  }
  thus ?thesis
    by (meson P1 not_and_lta 
        ‹B A Gt B C ⟹ B C Lt B A› ‹B A Lt B C ∨ B A Gt B C ∨ Cong B A B C› assms l11_44_2_a)
qed

lemma l11_44_1:
  assumes "¬ Col A B C"
  shows "B A C CongA B C A ⟷ Cong B A B C"
  using assms l11_44_1_a l11_44_1_b not_col_distincts by blast

lemma l11_44_2:
  assumes "¬ Col A B C"
  shows "B A C LtA B C A ⟷ B C Lt B A"
  using assms l11_44_2_a l11_44_2_b not_col_permutation_3 by blast

lemma l11_44_2bis:
  assumes "¬ Col A B C"
  shows "B A C LeA B C A ⟷ B C Le B A"
proof -
  {
    assume P1: "B A C LeA B C A"
    {
      assume "B A Lt B C"
      hence "B C A LtA B A C"
        by (simp add: assms l11_44_2_a)
      hence "False"
        using P1 lta__nlea by auto
    }
    hence "¬ B A Lt B C" by blast
    have "B C Le B A"
      using ‹¬ B A Lt B C› nle__lt by blast
  }
  {
    assume P2: "B C Le B A"
    have "B A C LeA B C A"
    proof cases
      assume "Cong B C B A"
      hence "B A C CongA B C A"
        by (metis assms conga_sym l11_44_1_a not_col_distincts)
      thus ?thesis
        by (simp add: conga__lea)
    next
      assume "¬ Cong B C B A"
      hence "B A C LtA B C A"
        by (simp add: l11_44_2 assms Lt_def P2)
      thus ?thesis
        by (simp add: lta__lea)
    qed
  }
  thus ?thesis
    using ‹B A C LeA B C A ⟹ B C Le B A› by blast
qed

lemma l11_46:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C ∨ Obtuse A B C"
  shows "B A Lt A C ∧ B C Lt A C"
proof cases
  assume "Col A B C"
  thus ?thesis
    by (meson assms(1) assms(2) assms(3) bet__lt1213 bet__lt2313 col_obtuse__bet 
        lt_left_comm per_not_col)
next
  assume P1: "¬ Col A B C"
  have P2: "A ≠ C"
    using P1 col_trivial_3 by auto
  have P3: "Acute B A C ∧ Acute B C A"
    using assms(1) assms(2) assms(3) l11_43 by auto
  then obtain A' B' C' where P4: "Per A' B' C' ∧ B C A LtA A' B' C'"
    using Acute_def P3 by auto
  {
    assume P5: "Per A B C"
    have P5A: "A C B CongA A C B"
      by (simp add: P2 assms(2) conga_refl)
    have S1: "A ≠ B"
      by (simp add: assms(1))
    have S2: "B ≠ C"
      by (simp add: assms(2))
    have S3: "A' ≠ B'"
      using P4 lta_distincts by blast
    have S4: "B' ≠ C'"
      using P4 lta_distincts by blast
    hence "A' B' C' CongA A B C" using l11_16
      using S1 S2 S3 S4 P4 P5 by blast
    hence "A C B LtA A B C"
      using P5A P4 conga_preserves_lta lta_left_comm by blast
  }
  {
    assume "Obtuse A B C"
    obtain A'' B'' C'' where P6: "Per A'' B'' C'' ∧ A'' B'' C'' LtA A B C"
      using Obtuse_def ‹Obtuse A B C› by auto
    have "B C A LtA A' B' C'"
      by (simp add: P4)
    hence P7: "A C B LtA A' B' C'"
      by (simp add: lta_left_comm)
    have "A' B' C' LtA A B C"
    proof -
      have U1: "A'' B'' C'' CongA A' B' C'"
      proof -
        have V2: "A'' ≠ B''"
          using P6 lta_distincts by blast
        have V3: "C'' ≠ B''"
          using P6 lta_distincts by blast
        have V5: "A' ≠ B'"
          using P7 lta_distincts by blast
        have "C' ≠ B'"
          using P4 lta_distincts by blast
        thus ?thesis using P6 V2 V3 P4 V5
          by (simp add: l11_16)
      qed
      have U2: "A B C CongA A B C"
        using assms(1) assms(2) conga_refl by auto
      have U3: "A'' B'' C'' LtA A B C"
        by (simp add: P6)
      thus ?thesis
        using U1 U2 conga_preserves_lta by auto
    qed
    hence "A C B LtA A B C"
      using P7 lta_trans by blast
  }
  hence "A C B LtA A B C"
    using ‹Per A B C ⟹ A C B LtA A B C› assms(3) by blast
  hence "A B Lt A C"
    by (simp add: l11_44_2_b)
  hence "B A Lt A C"
    using Lt_cases by blast
  have "C A B LtA C B A"
  proof -
    obtain A' B' C' where U4: "Per A' B' C' ∧ B A C LtA A' B' C'"
      using Acute_def P3 by blast
    {
      assume "Per A B C"
      hence W3: "A' B' C' CongA C B A"
        using U4 assms(2) l11_16 l8_2 lta_distincts by blast
      have W2: "C A B CongA C A B"
        using P2 assms(1) conga_refl by auto
      have "C A B LtA A' B' C'"
        by (simp add: U4 lta_left_comm)
      hence "C A B LtA C B A"
        using W2 W3 conga_preserves_lta by blast
    }
    {
      assume "Obtuse A B C"
      then obtain A'' B'' C'' where W4: "Per A'' B'' C'' ∧ A'' B'' C'' LtA A B C"
        using Obtuse_def by auto
      have W5: "C A B LtA A' B' C'"
        by (simp add: U4 lta_left_comm)
      have "A' B' C' LtA C B A"
      proof -
        have W6: "A'' B'' C'' CongA A' B' C'" using l11_16 W4 U4
          using lta_distincts by blast
        have "C B A CongA C B A"
          using assms(1) assms(2) conga_refl by auto
        thus ?thesis
          using W4 W6 conga_left_comm conga_preserves_lta by blast
      qed
      hence "C A B LtA C B A"
        using W5 lta_trans by blast
    }
    thus ?thesis
      using ‹Per A B C ⟹ C A B LtA C B A› assms(3) by blast
  qed
  hence "C B Lt C A"
    by (simp add: l11_44_2_b)
  hence "C B Lt A C"
    using Lt_cases by auto
  hence "B C Lt A C"
    using Lt_cases by blast
  thus ?thesis
    by (simp add: ‹B A Lt A C›)
qed

lemma l11_47:
  assumes "Per A C B" and
    "H PerpAt C H A B"       
  shows "Bet A H B ∧ A ≠ H ∧ B ≠ H"
proof -
  have P1: "Per C H A"
    using assms(2) perp_in_per_1 by auto
  have P2: "C H Perp A B"
    using assms(2) perp_in_perp by auto
  thus ?thesis
  proof cases
    assume "Col A C B"
    thus ?thesis
      by (metis P1 assms(1) assms(2) per_distinct_1 per_not_col perp_in_distinct perp_in_id)
  next
    assume P3: "¬ Col A C B"
    have P4: "A ≠ H"
      by (metis P2 Per_perm l8_7 assms(1) assms(2) col_trivial_1 perp_in_per_2 perp_not_col2)
    have P5: "Per C H B"
      using assms(2) perp_in_per_2 by auto
    have P6: "B ≠ H"
      using P1 P2 assms(1) l8_2 l8_7 perp_not_eq_1 by blast
    have P7: "H A Lt A C ∧ H C Lt A C"
      by (metis P1 P2 P4 l11_46 l8_2 perp_distinct)
    have P8: "C A Lt A B ∧ C B Lt A B"
      using P3 assms(1) l11_46 not_col_distincts by blast
    have P9: "H B Lt B C ∧ H C Lt B C"
      by (metis P2 P5 P6 Per_cases l11_46 perp_not_eq_1)
    have P10: "Bet A H B"
    proof -
      have T1: "Col A H B"
        using assms(2) col_permutation_5 perp_in_col by blast
      have T2: "A H Le A B" using P7 P8
        by (meson lt_comm lt_transitivity nlt__le not_and_lt)
      have "H B Le A B"
        by (meson Lt_cases P8 P9 le_transitivity le_cases lt__nle)
      thus ?thesis
        using T1 T2 l5_12_b by blast
    qed
    thus ?thesis
      by (simp add: P4 P6)
  qed
qed

lemma l11_49:
  assumes "A B C CongA A' B' C'" and
    "Cong B A B' A'" and
    "Cong B C B' C'"
  shows "Cong A C A' C' ∧ (A ≠ C ⟶ (B A C CongA B' A' C' ∧ B C A CongA B' C' A'))"
proof -
  have " Cong A C A' C'"
    using assms(1) assms(2) assms(3) cong2_conga_cong not_cong_2143 by blast
  {
    assume "A ≠ C"
    have "A ≠ B"
      using CongA_def assms(1) by blast
    have "C ≠ B"
      using CongA_def assms(1) by blast
    have "B A C Cong3 B' A' C'" 
      using Cong3_def ‹Cong A C A' C'› assms(2) assms(3) by blast
    hence "B A C CongA B' A' C'" 
      using ‹A ≠ B› ‹A ≠ C› cong3_conga by auto
    moreover have "B C A Cong3 B' C' A'" 
      using ‹B A C Cong3 B' A' C'› cong_3_swap_2 by blast
    hence "B C A CongA B' C' A'" 
      using ‹A ≠ C› ‹C ≠ B› cong3_conga by auto
    ultimately have "B A C CongA B' A' C' ∧ B C A CongA B' C' A'" 
      by blast
  }
  thus ?thesis 
    using ‹Cong A C A' C'› by blast
qed

lemma l11_50_1:
  assumes "¬ Col A B C" and
    "B A C CongA B' A' C'" and
    "A B C CongA A' B' C'" and
    "Cong A B A' B'"
  shows "Cong A C A' C' ∧ Cong B C B' C' ∧ A C B CongA A' C' B'"
proof -
  obtain C'' where P1: "B' Out C'' C' ∧ Cong B' C'' B C"
    by (metis Col_perm assms(1) assms(3) col_trivial_3 conga_diff56 l6_11_existence)
  have P2: "B' ≠ C''"
    using P1 out_diff1 by auto
  have P3: "¬ Col A' B' C'"
    using assms(1) assms(3) ncol_conga_ncol by blast
  have P4: "¬ Col A' B' C''"
    by (meson P1 P2 P3 col_transitivity_1 not_col_permutation_2 out_col)
  have P5: "Cong A C A' C''"
  proof -
    have Q1: "B Out A A"
      using assms(1) not_col_distincts out_trivial by auto
    have Q2: "B Out C C"
      using assms(1) col_trivial_2 out_trivial by force
    have Q3: "B' Out A' A'"
      using P3 not_col_distincts out_trivial by auto
    have Q5: "Cong B A B' A'"
      using assms(4) not_cong_2143 by blast
    have "Cong B C B' C''"
      using P1 not_cong_3412 by blast
    thus ?thesis
      using l11_4_1 P1 Q1 Q2 Q3 Q5 assms(3) by blast
  qed
  have P6: "B A C Cong3 B' A' C''"
    using Cong3_def Cong_perm P1 P5 assms(4) by blast
  have P7: "B A C CongA B' A' C''"
    by (metis P6 assms(1) cong3_conga not_col_distincts)
  have P8: "B' A' C' CongA B' A' C''"
    by (meson P7 assms(2) conga_sym conga_trans)
  have "B' A' OS C' C''"
    using Col_perm Out_cases P1 P3 out_one_side by blast
  hence "A' Out C' C''"
    using P8 conga_os__out by auto
  hence "Col A' C' C''"
    using out_col by auto
  hence P9: "C' = C''"
    using Col_perm P1 out_col P3 col_transitivity_1 by blast
  have T1: "Cong A C A' C'"
    by (simp add: P5 P9)
  have T2: "Cong B C B' C'"
    using Cong_perm P1 P9 by blast
  hence "A C B CongA A' C' B'"
    using T1 assms(1) assms(2) assms(4) col_trivial_2 l11_49 by blast
  thus ?thesis using T1 T2 by blast
qed

lemma l11_50_2:
  assumes "¬ Col A B C" and
    "B C A CongA B' C' A'" and
    "A B C CongA A' B' C'" and
    "Cong A B A' B'"
  shows "Cong A C A' C' ∧ Cong B C B' C' ∧ C A B CongA C' A' B'"
proof -
  have P1: "A ≠ B"
    using assms(1) col_trivial_1 by auto
  have P2: "B ≠ C"
    using assms(1) col_trivial_2 by auto
  have P3: "A' ≠ B'"
    using P1 assms(4) cong_diff by blast
  have P4: "B' ≠ C'"
    using assms(2) conga_diff45 by auto
  then obtain C'' where P5: "B' Out C'' C' ∧ Cong B' C'' B C"
    using P2 l6_11_existence by presburger
  have P5BIS: "B' ≠ C''"
    using P5 out_diff1 by auto
  have P5A: "Col B' C'' C'"
    using P5 out_col by auto
  have P6: "¬ Col A' B' C'"
    using assms(1) assms(3) ncol_conga_ncol by blast
  {
    assume "Col A' B' C''"
    hence "Col B' C'' A'"
      using not_col_permutation_2 by blast
    hence "Col B' C' A'" using col_transitivity_1 P5BIS P5A by blast
    hence "Col A' B' C'"
      using Col_perm by blast
    hence False
      using P6 by auto
  }
  hence P7: "¬ Col A' B' C''" by blast
  have P8: "Cong A C A' C''"
  proof -
    have "B Out A A"
      by (simp add: P1 out_trivial)
    have K1: "B Out C C"
      using P2 out_trivial by auto
    have K2: "B' Out A' A'"
      using P3 out_trivial by auto
    have "Cong B A B' A'"
      by (simp add: Cong_perm assms(4))
    have "Cong B C B' C''"
      using Cong_perm P5 by blast
    thus ?thesis
      using P5 ‹Cong B A B' A'› P1 out_trivial K1 K2 assms(3) l11_4_1 by blast
  qed
  have P9: "B C A Cong3 B' C'' A'"
    using Cong3_def Cong_perm P5 P8 assms(4) by blast
  hence P10: "B C A CongA B' C'' A'"
    using assms(1) cong3_conga not_col_distincts by auto
  have P11: "B' C' A' CongA B' C'' A'"
    using P9 assms(2) cong3_conga2 conga_sym by blast
  show ?thesis
  proof cases
    assume L1: "C' = C''"
    hence L2: "Cong A C A' C'"
      by (simp add: P8)
    have L3: "Cong B C B' C'"
      using Cong_perm L1 P5 by blast
    have "C A B Cong3 C' A' B'"
      by (simp add: L1 P9 cong_3_swap cong_3_swap_2)
    hence "C A B CongA C' A' B'"
      by (metis CongA_def P1 assms(2) cong3_conga)
    thus ?thesis using L2 L3 by auto
  next
    assume R1: "C' ≠ C''"
    have R1A: "¬ Col C'' C' A'"
      by (metis P5A P7 R1 col_permutation_2 col_trivial_2 colx)
    have R1B: "Bet B' C'' C' ∨ Bet B' C' C''"
      using Out_def P5 by auto
    {
      assume S1: "Bet B' C'' C'"
      hence S2: "C'' A' C' LtA A' C'' B' ∧ C'' C' A' LtA A' C'' B'"
        using P5BIS R1A between_symmetry l11_41 by blast
      have "B' C' A' CongA C'' C' A'"
        by (metis P11 R1 conga_comm S1 bet_out_1 conga_diff45 not_conga_sym 
            out2__conga out_trivial)
      hence "B' C' A' LtA A' C'' B'"
        by (meson P11 conga_right_comm not_conga not_conga_sym S2 not_lta_and_conga)
      hence "Cong A C A' C' ∧ Cong B C B' C'"
        by (meson P11 conga_right_comm not_lta_and_conga)
    }
    {
      assume Z1: "Bet B' C' C''"
      have Z2: "¬ Col C' C'' A'"
        by (simp add: R1A not_col_permutation_4)
      have Z3: "C'' Out C' B'"
        by (simp add: R1 Z1 bet_out_1)
      have Z4: "C'' Out A' A'"
        using P7 not_col_distincts out_trivial by blast
      hence Z4A: "B' C'' A' CongA C' C'' A'"
        by (simp add: Z3 out2__conga)
      have Z4B: "B' C'' A' LtA A' C' B'"
      proof -
        have Z5: "C' C'' A' CongA B' C'' A'"
          using Z4A not_conga_sym by blast
        have Z6: "A' C' B' CongA A' C' B'"
          using P11 P4 conga_diff2 conga_refl by blast
        have "C' C'' A' LtA A' C' B'"
          using P4 Z1 Z2 between_symmetry l11_41 by blast
        thus ?thesis
          using Z5 Z6 conga_preserves_lta by auto
      qed
      have "B' C'' A' CongA B' C' A'"
        using P11 not_conga_sym by blast
      hence "Cong A C A' C' ∧ Cong B C B' C'"
        by (meson conga_right_comm Z4B not_lta_and_conga)
    }
    hence R2: "Cong A C A' C' ∧ Cong B C B' C'"
      using R1B ‹Bet B' C'' C' ⟹ Cong A C A' C' ∧ Cong B C B' C'› by blast
    hence "C A B CongA C' A' B'"
      using P1 assms(2) l11_49 not_cong_2143 by blast
    thus ?thesis using R2 by auto
  qed
qed

lemma l11_51:
  assumes "A ≠ B" and
    "A ≠ C" and
    "B ≠ C" and
    "Cong A B A' B'" and
    "Cong A C A' C'" and
    "Cong B C B' C'"
  shows
    "B A C CongA B' A' C' ∧ A B C CongA A' B' C' ∧ B C A CongA B' C' A'"
proof -
  have "B A C Cong3 B' A' C' ∧ A B C Cong3 A' B' C' ∧ B C A Cong3 B' C' A'"
    using Cong3_def Cong_perm assms(4) assms(5) assms(6) by blast
  thus ?thesis
    using assms(1) assms(2) assms(3) cong3_conga by auto
qed

lemma conga_distinct:
  assumes "A B C CongA D E F"
  shows "A ≠ B ∧ C ≠ B ∧ D ≠ E ∧ F ≠ E"
  using CongA_def assms by auto

lemma l11_52:
  assumes "A B C CongA A' B' C'" and
    "Cong A C A' C'" and
    "Cong B C B' C'" and
    "B C Le A C"
  shows "Cong B A B' A' ∧ B A C CongA B' A' C' ∧ B C A CongA B' C' A'"
proof -
  have P1: "A ≠ B"
    using CongA_def assms(1) by blast
  have P2: "C ≠ B"
    using CongA_def assms(1) by blast
  have P3: "A' ≠ B'"
    using CongA_def assms(1) by blast
  have P4: "C' ≠ B'"
    using assms(1) conga_diff56 by auto
  have P5: "Cong B A B' A'"
  proof cases
    assume P6: "Col A B C"
    hence P7: "Bet A B C ∨ Bet B C A ∨ Bet C A B"
      using Col_def by blast
    {
      assume P8: "Bet A B C"
      hence "Bet A' B' C'"
        using assms(1) bet_conga__bet by blast
      hence "Cong B A B' A'"
        using P8 assms(2) assms(3) l4_3 not_cong_2143 by blast
    }
    {
      assume P9: "Bet B C A"
      hence P10: "B' Out A' C'"
        using Out_cases P2 assms(1) bet_out l11_21_a by blast
      hence P11: "Bet B' A' C' ∨ Bet B' C' A'"
        by (simp add: Out_def)
      {
        assume "Bet B' A' C'"
        hence "Cong B A B' A'"
          using P3 assms(2) assms(3) assms(4) bet_le_eq l5_6 by blast
      }
      {
        assume "Bet B' C' A'"
        hence "Cong B A B' A'"
          using Cong_perm P9 assms(2) assms(3) l2_11_b by blast
      }
      hence "Cong B A B' A'"
        using P11 ‹Bet B' A' C' ⟹ Cong B A B' A'› by blast
    }
    {
      assume "Bet C A B"
      hence "Cong B A B' A'"
        using P1 assms(4) bet_le_eq between_symmetry by blast
    }
    thus ?thesis
      using P7 ‹Bet A B C ⟹ Cong B A B' A'› ‹Bet B C A ⟹ Cong B A B' A'› by blast
  next
    assume Z1: "¬ Col A B C"
    obtain A'' where Z2: "B' Out A'' A' ∧ Cong B' A'' B A"
      using P1 P3 l6_11_existence by force
    hence Z3: "A' B' C' CongA A'' B' C'"
      by (simp add: P4 out2__conga out_trivial)
    have Z4: "A B C CongA A'' B' C'"
      using Z3 assms(1) not_conga by blast
    have Z5: "Cong A'' C' A C"
      using Z2 Z4 assms(3) cong2_conga_cong cong_4321 cong_symmetry by blast
    have Z6: "A'' B' C' Cong3 A B C"
      using Cong3_def Cong_perm Z2 Z5 assms(3) by blast
    have Z7: "Cong A'' C' A' C'"
      using Z5 assms(2) cong_transitivity by blast
    have Z8: "¬ Col A' B' C'"
      by (metis Z1 assms(1) ncol_conga_ncol)
    hence Z9: "¬ Col A'' B' C'"
      by (metis Z2 col_transitivity_1 not_col_permutation_4 out_col out_diff1)
    {
      assume Z9A: "A'' ≠ A'"
      have Z10: "Bet B' A'' A' ∨ Bet B' A' A''"
        using Out_def Z2 by auto
      {
        assume Z11: "Bet B' A'' A'"
        have Z12: "A'' C' B' LtA C' A'' A' ∧ A'' B' C' LtA C' A'' A'"
          by (simp add: Z11 Z9 Z9A l11_41)
        have Z13: "Cong A' C' A'' C'"
          using Cong_perm Z7 by blast
        have Z14: "¬ Col A'' C' A'"
          by (metis Col_def Z11 Z9 Z9A col_transitivity_1)
        have Z15: "C' A'' A' CongA C' A' A'' ⟷ Cong C' A'' C' A'"
          by (simp add: Z14 l11_44_1)
        have Z16: "Cong C' A' C' A''"
          using Cong_perm Z7 by blast
        hence Z17: "Cong C' A'' C' A'"
          using Cong_perm by blast
        hence Z18: "C' A'' A' CongA C' A' A''"
          by (simp add: Z15)
        have Z19: "¬ Col B' C' A''"
          using Col_perm Z9 by blast
        have Z20: "B' A' C' CongA A'' A' C'"
          by (metis col_conga_col Z11 Z3 Z9 Z9A bet_out_1 col_trivial_3 out2__conga out_trivial)
        have Z21: "¬ Col B' C' A'"
          using Col_perm Z8 by blast
        hence Z22: "C' B' A' LtA C' A' B' ⟷ C' A' Lt C' B'"
          by (simp add: l11_44_2)
        have "A'' B' C' CongA C' B' A'"
          using Z3 conga_right_comm not_conga_sym by blast
        hence U1: "C' B' A' LtA C' A' B'" 
        proof -
          have "C' A'' A' CongA C' A' A''"
            by (metis Z15 Z17)
          hence "¬ C' B' A' LtA C' A'' A' ∨ A'' B' C' LtA C' A' A''" 
            by (meson Z3 conga_preserves_lta lta_left_comm)
          hence "C' B' A' LtA C' A' B' ∨ A'' B' C' LtA A'' A' C' ∨ A'' = B'" 
            using Z12 ‹A'' B' C' CongA C' B' A'› conga_preserves_lta conga_refl 
            by (metis Z15 Z17 lta_right_comm)
          thus ?thesis 
            by (metis conga_diff1 conga_sym Z20 ‹A'' B' C' CongA C' B' A'› 
                conga_preserves_lta conga_right_comm)
        qed
        hence Z23: "C' A' Lt C' B'"
          using Z22 by auto
        have Z24: "C' A'' Lt C' B'"
          using Z16 Z23 cong2_lt__lt cong_reflexivity by blast
        have Z25: "C A Le C B"
        proof -
          have Z26: "Cong C' A'' C A"
            using Z5 not_cong_2143 by blast
          have "Cong C' B' C B"
            using assms(3) not_cong_4321 by blast
          thus ?thesis
            using l5_6 Z24 Z26 lt__le by blast
        qed
        hence Z27: "Cong C A C B"
          by (simp add: assms(4) le_anti_symmetry le_comm)
        have "Cong C' A'' C' B'"
          by (metis Cong_perm Z13 Z27 assms(2) assms(3) cong_transitivity)
        hence "False"
          using Z24 cong__nlt by blast
        hence "Cong B A B' A'" by simp
      }
      {
        assume W1: "Bet B' A' A''"
        have W2: "A' ≠ A''"
          using Z9A by auto
        have W3: "A' C' B' LtA C' A' A'' ∧ A' B' C' LtA C' A' A''"
          using W1 Z8 Z9A l11_41 by blast
        have W4: "Cong A' C' A'' C'"
          using Z7 not_cong_3412 by blast
        have "¬ Col A'' C' A'"
          by (metis Col_def W1 Z8 Z9A col_transitivity_1)
        hence W6: "C' A'' A' CongA C' A' A'' ⟷ Cong C' A'' C' A'"
          using l11_44_1 by auto
        have W7: "Cong C' A' C' A''"
          using Z7 not_cong_4321 by blast
        hence W8: "Cong C' A'' C' A'"
          using W4 not_cong_4321 by blast
        have W9: "¬ Col B' C' A''"
          by (simp add: Z9 not_col_permutation_1)
        have W10: "B' A'' C' CongA A' A'' C'"
          by (metis Out_def W1 Z9 Z9A bet_out_1 between_trivial not_col_distincts out2__conga)
        have W12: "C' B' A'' LtA C' A'' B' ⟷ C' A'' Lt C' B'"
          by (simp add: W9 l11_44_2)
        have W12A: "C' B' A'' LtA C' A'' B'"
        proof -
          have V1: "A' B' C' CongA C' B' A''"
            by (simp add: Z3 conga_right_comm)
          have "A' A'' C' CongA B' A'' C'"
            by (metis Out_def W1 ‹¬ Col A'' C' A'› between_equality_2 not_col_distincts 
                or_bet_out out2__conga out_col)
          hence "C' A' A'' CongA C' A'' B'"
            by (meson W6 W8 conga_left_comm not_conga not_conga_sym)
          thus ?thesis
            using W3 V1 conga_preserves_lta by auto
        qed
        hence "C' A'' Lt C' B'" using W12 by auto
        hence W14: "C' A' Lt C' B'"
          using W8 cong2_lt__lt cong_reflexivity by blast
        have W15: "C A Le C B"
        proof -
          have Q1: "C' A'' Le C' B'"
            using W12 W12A lt__le by blast
          have Q2: "Cong C' A'' C A"
            using Z5 not_cong_2143 by blast
          have "Cong C' B' C B"
            using assms(3) not_cong_4321 by blast
          thus ?thesis using Q1 Q2 l5_6 by blast
        qed
        have "C B Le C A"
          by (simp add: assms(4) le_comm)
        hence "Cong C A C B"
          by (simp add: W15 le_anti_symmetry)
        hence "Cong C' A' C' B'"
          by (metis Cong_perm assms(2) assms(3) cong_inner_transitivity)
        hence "False"
          using W14 cong__nlt by blast
        hence "Cong B A B' A'" by simp
      }
      then  have "Cong B A B' A'"
        using Z10 ‹Bet B' A'' A' ⟹ Cong B A B' A'› by blast
    }
    {
      assume "A'' = A'"
      hence "Cong B A B' A'"
        using Z2 not_cong_3412 by blast
    }
    thus ?thesis
      using ‹A'' ≠ A' ⟹ Cong B A B' A'› by blast
  qed
  have P6: "A B C Cong3 A' B' C'"
    using Cong3_def Cong_perm P5 assms(2) assms(3) by blast
  thus ?thesis
    using P2 P5 assms(1) assms(3) assms(4) l11_49 le_zero by blast
qed

lemma l11_53:
  assumes "Per D C B" and
    "C ≠ D" and
    "A ≠ B" and
    "B ≠ C" and
    "Bet A B C"
  shows "C A D LtA C B D ∧ B D Lt A D"
proof -
  have P1: "C ≠ A"
    using assms(3) assms(5) between_identity by blast
  have P2: "¬ Col B A D"
    using assms(1) assms(2) assms(3) assms(4) assms(5) bet_col bet_col1 col3 
      col_permutation_4 l8_9 by metis
  have P3: "A ≠ D"
    using P2 col_trivial_2 by blast
  have P4: "C A D LtA C B D"
  proof -
    have P4A: "B D A LtA D B C ∧ B A D LtA D B C"
      by (simp add: P2 assms(4) assms(5) l11_41)
    have P4AA:"A Out B C"
      using assms(3) assms(5) bet_out by auto
    have "A Out D D"
      using P3 out_trivial by auto
    hence P4B: "C A D CongA B A D" using P4AA
      by (simp add: out2__conga)
    hence P4C: "B A D CongA C A D"
      by (simp add: P4B conga_sym)
    have "D B C CongA C B D"
      using assms(1) assms(4) conga_pseudo_refl per_distinct_1 by auto
    thus ?thesis
      using P4A P4C conga_preserves_lta by blast
  qed
  obtain B' where P5: "C Midpoint B B' ∧ Cong D B D B'"
    using Per_def assms(1) by auto
  have K2: "A ≠ B'"
    using Bet_cases P5 assms(4) assms(5) between_equality_2 midpoint_bet by blast
  {
    assume "Col B D B'"
    hence "Col B A D"
      by (metis Col_cases P5 assms(1) assms(2) assms(4) col2__eq midpoint_col 
          midpoint_distinct_2 per_not_col)
    hence "False"
      by (simp add: P2)
  }
  hence P6: "¬ Col B D B'" by blast
  hence "D B B' CongA D B' B ⟷ Cong D B D B'"
    by (simp add: l11_44_1)
  hence "D B B' CongA D B' B" using P5 by simp
  {
    assume K1: "Col A D B'"
    have "Col B' A B"
      using Col_def P5 assms(4) assms(5) midpoint_bet outer_transitivity_between by blast
    hence "Col B' B D"
      using K1 K2 Col_perm col_transitivity_2 by blast
    hence "Col B D B'"
      using Col_perm by blast
    hence "False"
      by (simp add: P6)
  }
  hence K3B: "¬ Col A D B'" by blast
  hence K4: "D A B' LtA D B' A ⟷ D B' Lt D A"
    by (simp add: l11_44_2)
  have K4A: "C A D LtA C B' D"
    by (metis Midpoint_def P1 P3 P4 P5 P5 P6 assms(2) assms(4) col_trivial_1 
        cong_reflexivity conga_preserves_lta conga_refl l11_51 not_cong_2134)
  have "D B' Lt D A"
  proof -
    have "D A B' LtA D B' A"
    proof -
      have K5A: "A Out D D"
        using P3 out_trivial by auto
      have K5AA: "A Out B' C"
        using K2 Out_def P1 P5 assms(4) assms(5) midpoint_bet outer_transitivity_between2 
        by fast
      hence K5: "D A C CongA D A B'"
        by (simp add: K5A out2__conga)
      have K6A: "B' Out D D"
        using K3B not_col_distincts out_trivial by blast
      have "B' Out A C"
        using P5 K5AA assms(4) assms(5) between_equality_2 l6_4_2 midpoint_bet 
          midpoint_distinct_2 out_col outer_transitivity_between2 by metis
      hence K6: "D B' C CongA D B' A"
        by (simp add: K6A out2__conga)
      have "D A C LtA D B' C"
        by (simp add: K4A lta_comm)
      thus ?thesis
        using K5 K6 conga_preserves_lta by auto
    qed
    thus ?thesis
      by (simp add: K4)
  qed
  thus ?thesis
    using P4 P5 cong2_lt__lt cong_pseudo_reflexivity not_cong_4312 by blast
qed

lemma cong2_conga_obtuse__cong_conga2:
  assumes "Obtuse A B C" and
    "A B C CongA A' B' C'" and
    "Cong A C A' C'" and
    "Cong B C B' C'"
  shows "Cong B A B' A' ∧ B A C CongA B' A' C' ∧ B C A CongA B' C' A'"
proof -
  have "B C Le A C"
  proof cases
    assume "Col A B C"
    thus ?thesis
      by (simp add: assms(1) col_obtuse__bet l5_12_a)
  next
    assume "¬ Col A B C"
    thus ?thesis
      using l11_46 assms(1) lt__le not_col_distincts by auto
  qed
  thus ?thesis
    using l11_52 assms(2) assms(3) assms(4) by blast
qed

lemma cong2_per2__cong_conga2:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C" and
    "Per A' B' C'" and
    "Cong A C A' C'" and
    "Cong B C B' C'"
  shows "Cong B A B' A' ∧ B A C CongA B' A' C' ∧ B C A CongA B' C' A'"
proof -
  have "B C Le A C ∧ ¬ Cong B C A C"
    using assms(1) assms(2) assms(3) cong__nlt l11_46 lt__le by blast
  hence "A B C CongA A' B' C'"
    using assms(2) assms(3) assms(4) assms(5) assms(6) cong_diff 
      cong_inner_transitivity cong_symmetry l11_16 by metis
  thus ?thesis 
    using ‹B C Le A C ∧ ¬ Cong B C A C› assms(5) assms(6) l11_52 by blast
qed

lemma cong2_per2__cong:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "Cong A C A' C'" and
    "Cong B C B' C'"
  shows "Cong B A B' A'"
proof cases
  assume "B = C"
  thus ?thesis
    using assms(3) assms(4) cong_reverse_identity not_cong_2143 by blast
next
  assume "B ≠ C"
  show ?thesis
  proof cases
    assume "A = B"
    thus ?thesis
    proof -
      have "Cong A C B' C'"
        using ‹A = B› assms(4) by blast
      hence "B' = A'"
        by (meson Cong3_def Per_perm assms(2) assms(3) cong_inner_transitivity 
            cong_pseudo_reflexivity l8_10 l8_7)
      thus ?thesis
        using ‹A = B› cong_trivial_identity by blast
    qed
  next
    assume "A ≠ B"
    show ?thesis
    proof cases
      assume "A' = B'"
      thus ?thesis
        by (metis Cong3_def Per_perm ‹A ≠ B› assms(1) assms(3) assms(4) 
            cong_inner_transitivity cong_pseudo_reflexivity l8_10 l8_7)
    next
      assume "A' ≠ B'"
      thus ?thesis
        using cong2_per2__cong_conga2 ‹A ≠ B› ‹B ≠ C› assms(1) assms(2) assms(3) assms(4) 
        by blast
    qed
  qed
qed

lemma cong2_per2__cong_3:
  assumes "Per A B C"
    "Per A' B' C'" and
    "Cong A C A' C'" and
    "Cong B C B' C'"
  shows "A B C Cong3 A' B' C'"
  by (metis Cong3_def assms(1) assms(2) assms(3) assms(4) cong2_per2__cong cong_3_swap)

lemma cong_lt_per2__lt:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "Cong A B A' B'" and
    "B C Lt B' C'"
  shows "A C Lt A' C'"
proof cases
  assume "A = B"
  thus ?thesis
    using assms(3) assms(4) cong_reverse_identity by blast
next
  assume "A ≠ B"
  show ?thesis
  proof cases
    assume "B = C"
    have "B' A' Lt C' A'" 
      by (metis cong_diff_2 l11_46 ‹A ≠ B› assms(2) assms(3) assms(4) lt_diff lt_right_comm)
    thus ?thesis 
      by (metis cong2_lt__lt cong_reflexivity cong_symmetry lt_comm ‹B = C› assms(3))
  next
    assume P0: "B ≠ C"
    have "B C Lt B' C'"
      by (simp add: assms(4))
    hence R1: "B C Le B' C' ∧ ¬ Cong B C B' C'"
      by (simp add: Lt_def)
    then obtain C0 where P1: "Bet B' C0 C' ∧ Cong B C B' C0"
      using Le_def by auto
    hence P2: "Per A' B' C0"
      by (metis Col_def Per_cases assms(2) bet_out_1 col_col_per_per col_trivial_1 
          l8_5 out_diff2)
    have "C0 A' Lt C' A'" using l11_53
      by (metis P1 P2 R1 P0 bet__lt2313 between_symmetry cong_diff)
    hence P3: "A' C0 Lt A' C'"
      using Lt_cases by blast
    have P4: "Cong A' C0 A C"
      using P1 P2 assms(1) assms(3) l10_12 not_cong_3412 by blast
    have "Cong A' C' A' C'"
      by (simp add: cong_reflexivity)
    thus ?thesis
      using cong2_lt__lt P3 P4 by blast
  qed
qed

lemma cong_le_per2__le:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "Cong A B A' B'" and
    "B C Le B' C'"
  shows "A C Le A' C'"
proof cases
  assume "Cong B C B' C'"
  thus ?thesis
    using assms(1) assms(2) assms(3) cong__le l10_12 by blast
next
  assume "¬ Cong B C B' C'"
  hence "B C Lt B' C'"
    using Lt_def assms(4) by blast
  thus ?thesis
    using assms(1) assms(2) assms(3) cong_lt_per2__lt lt__le by auto
qed

lemma lt2_per2__lt:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "A B Lt A' B'" and
    "B C Lt B' C'"
  shows "A C Lt A' C'"
proof -
  have P2: "B A Lt B' A'"
    by (simp add: assms(3) lt_comm)
  have P3: "B C Le B' C' ∧ ¬ Cong B C B' C'"
    using assms(4) cong__nlt lt__le by auto
  then obtain C0 where P4: "Bet B' C0 C' ∧ Cong B C B' C0"
    using Le_def by auto
  have P4A: "B' ≠ C'"
    using assms(4) lt_diff by auto
  have "Col B' C' C0"
    using P4 bet_col not_col_permutation_5 by blast
  hence P5: "Per A' B' C0"
    using assms(2) P4A per_col by blast
  have P6: "A C Lt A' C0"
    by (meson P2 P4 P5 assms(1) cong_lt_per2__lt l8_2 lt_comm not_cong_2143)
  have "B' C0 Lt B' C'"
    by (metis P4 assms(4) bet__lt1213 cong__nlt)
  hence "A' C0 Lt A' C'"
    using P5 assms(2) cong_lt_per2__lt cong_reflexivity by blast
  thus ?thesis
    using P6 lt_transitivity by blast
qed

lemma le_lt_per2__lt:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "A B Le A' B'" and
    "B C Lt B' C'"
  shows "A C Lt A' C'"
  using Lt_def assms(1) assms(2) assms(3) assms(4) cong_lt_per2__lt lt2_per2__lt by blast

lemma le2_per2__le:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "A B Le A' B'" and
    "B C Le B' C'"
  shows "A C Le A' C'"
proof cases
  assume "Cong B C B' C'"
  thus ?thesis
    by (meson Per_cases cong_le_per2__le assms(1) assms(2) assms(3) le_comm not_cong_2143)
next
  assume "¬ Cong B C B' C'"
  hence "B C Lt B' C'"
    by (simp add: Lt_def assms(4))
  thus ?thesis
    using assms(1) assms(2) assms(3) le_lt_per2__lt lt__le by blast
qed

lemma cong_lt_per2__lt_1:
  assumes "Per A B C" and
    "Per A' B' C'" and
    "A B Lt A' B'" and
    "Cong A C A' C'"
  shows "B' C' Lt B C"
  by (meson Gt_def assms(1) assms(2) assms(3) assms(4) cong2_per2__cong cong_4321 
      cong__nlt cong_symmetry lt2_per2__lt or_lt_cong_gt)

lemma symmetry_preserves_conga:
  assumes "A ≠ B" and "C ≠ B" and
    "M Midpoint A A'" and
    "M Midpoint B B'" and
    "M Midpoint C C'"
  shows "A B C CongA A' B' C'"
  by (metis Mid_perm assms(1) assms(2) assms(3) assms(4) assms(5) conga_trivial_1 
      l11_51 l7_13 symmetric_point_uniqueness)

lemma l11_57:
  assumes "A A' OS B B'" and
    "Per B A A'" and
    "Per B' A' A" and
    "A A' OS C C'" and
    "Per C A A'" and
    "Per C' A' A"
  shows "B A C CongA B' A' C'"
proof -
  obtain M where P1: "M Midpoint A A'"
    using midpoint_existence by auto
  obtain B'' where P2: "M Midpoint B B''"
    using symmetric_point_construction by auto
  obtain C'' where P3: "M Midpoint C C''"
    using symmetric_point_construction by auto
  have P4: "¬ Col A A' B"
    using assms(1) col123__nos by auto
  have P5: "¬ Col A A' C"
    using assms(4) col123__nos by auto
  have P6: "B A C CongA B'' A' C''"
    by (metis P1 P2 P3 assms(1) assms(4) os_distincts symmetry_preserves_conga)
  have "B'' A' C'' CongA B' A' C'"
  proof -
    have "B ≠ M"
      using P1 P4 midpoint_col not_col_permutation_2 by blast
    hence P7: "¬ Col B'' A A'"
      using Mid_cases P1 P2 P4 mid_preserves_col not_col_permutation_3 by blast
    have K3: "Bet B'' A' B'"
    proof -
      have "Per B'' A' A"
        using P1 P2 assms(2) per_mid_per by blast
      have "Col B B'' M ∧ Col A A' M"
        using P1 P2 midpoint_col not_col_permutation_2 by blast
      hence "Coplanar B A A' B''"
        using Coplanar_def by auto
      hence "Coplanar A B' B'' A'"
        by (meson assms(1) between_trivial2 coplanar_trans_1 ncoplanar_perm_4 
            ncoplanar_perm_8 one_side_chara os__coplanar)
      hence P8: "Col B' B'' A'"
        using cop_per2__col P1 P2 P7 assms(2) assms(3) not_col_distincts per_mid_per 
        by blast
      have "A A' TS B B''"
        using P1 P2 P4 mid_two_sides by auto
      hence "A' A TS B'' B'"
        using assms(1) invert_two_sides l9_2 l9_8_2 by blast
      thus ?thesis
        using Col_cases P8 col_two_sides_bet by blast
    qed
    have "¬ Col C'' A A'"
      using Col_def P1 P3 P5 l7_15 l7_2 not_col_permutation_5 by meson
    have "Bet C'' A' C'"
    proof -
      have Z2: "Col C' C'' A'"
      proof -
        have "Col C C'' M ∧ Col A A' M"
          using P1 P3 col_permutation_1 midpoint_col by blast
        hence "Coplanar C A A' C''"
          using Coplanar_def by blast
        hence Z1: "Coplanar A C' C'' A'"
          by (meson assms(4) between_trivial2 coplanar_trans_1 ncoplanar_perm_4 
              ncoplanar_perm_8 one_side_chara os__coplanar)
        have "Per C'' A' A"
          using P1 P3 assms(5) per_mid_per by blast
        thus ?thesis
          using Z1 P5 assms(6) col_trivial_1 cop_per2__col by blast
      qed
      have "A A' TS C C''"
        using P1 P3 P5 mid_two_sides by auto
      hence "A' A TS C'' C'"
        using assms(4) invert_two_sides l9_2 l9_8_2 by blast
      thus ?thesis
        using Col_cases Z2 col_two_sides_bet by blast
    qed
    thus ?thesis
      by (metis P6 K3 assms(1) assms(4) conga_diff45 conga_diff56 l11_14 os_distincts)
  qed
  thus ?thesis
    using P6 conga_trans by blast
qed

lemma cop3_orth_at__orth_at:
  assumes "¬ Col D E F" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar A B C F" and
    "X OrthAt A B C U V"
  shows "X OrthAt D E F U V"
proof -
  have P1: "¬ Col A B C ∧ Coplanar A B C X"
    using OrthAt_def assms(5) by blast
  hence P2: "Coplanar D E F X"
    using assms(2) assms(3) assms(4) coplanar_pseudo_trans by blast
  {
    fix M
    assume "Coplanar A B C M"
    hence "Coplanar D E F M"
      using P1 assms(2) assms(3) assms(4) coplanar_pseudo_trans by blast
  }
  have T1: "U ≠ V"
    using OrthAt_def assms(5) by blast
  have T2: "Col U V X"
    using OrthAt_def assms(5) by auto
  {
    fix P Q
    assume P7: "Coplanar D E F P ∧ Col U V Q"
    hence "Coplanar A B C P"
      by (meson ‹⋀M. Coplanar A B C M ⟹ Coplanar D E F M› assms(1) assms(2) 
          assms(3) assms(4) l9_30)
    hence "Per P X Q" using P7 OrthAt_def assms(5) by blast
  }
  thus ?thesis using assms(1)
    by (simp add: OrthAt_def P2 T1 T2)
qed

lemma col2_orth_at__orth_at:
  assumes "U ≠ V" and
    "Col P Q U" and
    "Col P Q V" and
    "X OrthAt A B C P Q"
  shows "X OrthAt A B C U V"
proof -
  have "Col P Q X"
    using OrthAt_def assms(4) by auto
  hence "Col U V X"
    by (metis OrthAt_def assms(2) assms(3) assms(4) col3)
  thus ?thesis
    using OrthAt_def assms(1) assms(2) assms(3) assms(4) colx by presburger
qed

lemma col_orth_at__orth_at:
  assumes "U ≠ W" and
    "Col U V W" and
    "X OrthAt A B C U V"
  shows "X OrthAt A B C U W"
  using assms(1) assms(2) assms(3) col2_orth_at__orth_at col_trivial_3 by blast

lemma orth_at_symmetry:
  assumes "X OrthAt A B C U V"
  shows "X OrthAt A B C V U"
  by (metis assms col2_orth_at__orth_at col_trivial_2 col_trivial_3)

lemma orth_at_distincts:
  assumes "X OrthAt A B C U V"
  shows "A ≠ B ∧ B ≠ C ∧ A ≠ C ∧ U ≠ V"
  using OrthAt_def assms not_col_distincts by fastforce

lemma orth_at_chara:
  "X OrthAt A B C X P ⟷
(¬ Col A B C ∧ X ≠ P ∧ Coplanar A B C X ∧ (∀ D.(Coplanar A B C D ⟶ Per D X P)))"
proof -
  {
    assume "X OrthAt A B C X P"
    hence "¬ Col A B C ∧ X ≠ P ∧ Coplanar A B C X ∧ (∀ D.(Coplanar A B C D ⟶ Per D X P))"
      using OrthAt_def col_trivial_2 by auto
  }
  {
    assume T1: "¬ Col A B C ∧ X ≠ P ∧ 
  Coplanar A B C X ∧ (∀ D.(Coplanar A B C D ⟶ Per D X P))"
    {
      fix P0 Q
      assume "Coplanar A B C P0 ∧ Col X P Q"
      hence "Per P0 X Q" using T1 OrthAt_def per_col by auto
    }
    hence "X OrthAt A B C X P"
      by (simp add: T1 ‹⋀Q P0. Coplanar A B C P0 ∧ Col X P Q ⟹ Per P0 X Q› 
          OrthAt_def col_trivial_3)
  }
  thus ?thesis
    using ‹X OrthAt A B C X P ⟹ ¬ Col A B C ∧ X ≠ P ∧ 
  Coplanar A B C X ∧ (∀D. Coplanar A B C D ⟶ Per D X P)› 
    by blast
qed

lemma cop3_orth__orth:
  assumes "¬ Col D E F" and
    "Coplanar A B C D" and
    "Coplanar A B C E" and
    "Coplanar A B C F" and
    "A B C Orth U V"
  shows "D E F Orth U V"
  using Orth_def assms(1) assms(2) assms(3) assms(4) assms(5) cop3_orth_at__orth_at by blast

lemma col2_orth__orth:
  assumes "U ≠ V" and
    "Col P Q U" and
    "Col P Q V" and
    "A B C Orth P Q"
  shows "A B C Orth U V"
  by (meson Orth_def col2_orth_at__orth_at Tarski_neutral_dimensionless_axioms 
      assms(1) assms(2) assms(3) assms(4))

lemma col_orth__orth:
  assumes "U ≠ W" and
    "Col U V W" and
    "A B C Orth U V"
  shows "A B C Orth U W"
  by (meson assms(1) assms(2) assms(3) col2_orth__orth col_trivial_3)

lemma orth_symmetry:
  assumes "A B C Orth U V"
  shows "A B C Orth V U"
  by (meson Orth_def assms orth_at_symmetry)

lemma orth_distincts:
  assumes "A B C Orth U V"
  shows "A ≠ B ∧ B ≠ C ∧ A ≠ C ∧ U ≠ V"
  using Orth_def assms orth_at_distincts by blast

lemma col_cop_orth__orth_at:
  assumes "A B C Orth U V" and
    "Coplanar A B C X" and
    "Col U V X"
  shows "X OrthAt A B C U V"
proof -
  obtain Y where P1:
    "¬ Col A B C ∧ U ≠ V ∧ Coplanar A B C Y ∧ Col U V Y ∧
(∀ P Q. (Coplanar A B C P ∧ Col U V Q) ⟶ Per P Y Q)"
    by (metis OrthAt_def Orth_def assms(1))
  hence P2: "X = Y"
    using assms(2) assms(3) per_distinct_1 by blast
  {
    fix P Q
    assume "Coplanar A B C P ∧ Col U V Q"
    hence "Per P X Q" using P1 P2 by auto
  }
  thus ?thesis
    using OrthAt_def Orth_def assms(1) assms(2) assms(3) by auto
qed

lemma l11_60_aux:
  assumes "¬ Col A B C" and
    "Cong A P A Q" and
    "Cong B P B Q" and
    "Cong C P C Q" and
    "Coplanar A B C D"
  shows "Cong D P D Q"
proof -
  obtain M where P1: "Bet P M Q ∧ Cong P M M Q"
    by (meson Midpoint_def midpoint_existence Tarski_neutral_dimensionless_axioms)
  obtain X where P2: " (Col A B X ∧ Col C D X) ∨
(Col A C X ∧ Col B D X) ∨
(Col A D X ∧ Col B C X)"
    using assms(5) Coplanar_def by auto
  {
    assume "Col A B X ∧ Col C D X"
    have "C ≠ X" 
      using ‹Col A B X ∧ Col C D X› assms(1) by auto
    have "Cong X P X Q" 
      by (metis l4_17 not_col_distincts ‹Col A B X ∧ Col C D X› assms(1) assms(2) assms(3))
    hence "Cong D P D Q"
      by (metis l4_17 ‹C ≠ X› ‹Col A B X ∧ Col C D X› assms(4) not_col_permutation_5)
  }
  {
    assume "Col A C X ∧ Col B D X"
    have "B ≠ X" 
      using Col_cases ‹Col A C X ∧ Col B D X› assms(1) by blast
    have "Cong X P X Q" 
      by (metis l4_17 ‹Col A C X ∧ Col B D X› assms(1) assms(2) assms(4) not_col_distincts)
    hence "Cong D P D Q"
      by (metis l4_17 ‹B ≠ X› ‹Col A C X ∧ Col B D X› assms(3) not_col_permutation_5)
  }
  {
    assume "Col A D X ∧ Col B C X"
    have "A ≠ X" 
      by (metis not_col_permutation_1 ‹Col A D X ∧ Col B C X› assms(1))
    have "Cong X P X Q" 
      by (metis l4_17 not_col_distincts ‹Col A D X ∧ Col B C X› assms(1) assms(3) assms(4))
    hence "Cong D P D Q"
      by (metis col_permutation_5 l4_17 ‹A ≠ X› ‹Col A D X ∧ Col B C X› assms(2))
  }
  thus ?thesis
    using P2 ‹Col A B X ∧ Col C D X ⟹ Cong D P D Q› 
      ‹Col A C X ∧ Col B D X ⟹ Cong D P D Q› by blast
qed

lemma l11_60:
  assumes "¬ Col A B C" and
    "Per A D P" and
    "Per B D P" and
    "Per C D P" and
    "Coplanar A B C E"
  shows "Per E D P"
  by (meson Per_def assms(1) assms(2) assms(3) assms(4) assms(5) l11_60_aux per_double_cong)

lemma l11_60_bis:
  assumes "¬ Col A B C" and
    "D ≠ P" and
    "Coplanar A B C D" and
    "Per A D P" and
    "Per B D P" and
    "Per C D P"
  shows "D OrthAt A B C D P"
  using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l11_60 orth_at_chara by auto

lemma l11_61:
  assumes "A ≠ A'" and
    "A ≠ B" and
    "A ≠ C" and
    "Coplanar A A' B B'" and
    "Per B A A'" and
    "Per B' A' A" and
    "Coplanar A A' C C'" and
    "Per C A A'" and
    "Per B A C"
  shows "Per B' A' C'"
proof -
  have P1: "¬ Col C A A'"
    using assms(1) assms(3) assms(8) per_col_eq by blast
  obtain C'' where P2: "A A' Perp C'' A' ∧ A A' OS C C''" using l10_15
    using Col_perm P1 col_trivial_2 by blast
  have P6: "B' ≠ A"
    using assms(1) assms(6) per_distinct by blast
  have P8: "¬ Col A' A C''"
    using P2 not_col_permutation_4 one_side_not_col124 by blast
  have P9: "Per A' A' B'"
    by (simp add: l8_2 l8_5)
  have P10: "Per A A' B'"
    by (simp add: assms(6) l8_2)
  {
    fix B'
    assume "A A' OS B B' ∧ Per B' A' A"
    hence "B A C CongA B' A' C''" using l11_17
      by (meson P2 Perp_cases l11_57 Tarski_neutral_dimensionless_axioms assms(5) assms(8) perp_per_1)
    hence "Per B' A' C''"
      using assms(9) l11_17 by blast
  }
  hence Q1: "∀ B'. (A A' OS B B' ∧ Per B' A' A) ⟶ Per B' A' C''" by simp
  {
    fix B'
    assume P12: "Coplanar A A' B B' ∧ Per B' A' A ∧ B' ≠ A"
    have "Per B' A' C''"
    proof cases
      assume "B' = A'"
      thus ?thesis
        by (simp add: Per_perm l8_5)
    next
      assume P13: "B' ≠ A'"
      have P14: "¬ Col B' A' A"
        using P12 P13 assms(1) l8_9 by auto
      have P15: "¬ Col B A A'"
        using assms(1) assms(2) assms(5) per_not_col by auto
      hence Z1: "A A' TS B B' ∨ A A' OS B B'"
        using P12 P14 cop__one_or_two_sides not_col_permutation_5 by blast
      {
        assume "A A' OS B B'"
        hence "Per B' A' C''"
          by (simp add: P12 ‹⋀B'a. A A' OS B B'a ∧ Per B'a A' A ⟹ Per B'a A' C''›)
      }
      {
        assume Q2: "A A' TS B B'"
        obtain B'' where Z2: "Bet B' A' B'' ∧ Cong A' B'' A' B'"
          using segment_construction by blast
        have "B' ≠ B''"
          using P13 Z2 bet_neq12__neq by blast
        hence Z4: "A' ≠ B''"
          using Z2 cong_diff_4 by blast
        hence "A A' TS B'' B'"
          by (meson TS_def Z2 Q2 bet__ts invert_two_sides l9_2 not_col_permutation_1)
        hence Z5: "A A' OS B B''"
          using Q2 l9_8_1 by auto
        have "Per B'' A' A"
          using P12 P13 Z2 bet_col col_per2__per l8_2 l8_5 by blast
        hence "Per C'' A' B''"
          using l8_2 Q1 Z5 by blast
        hence "Per B' A' C''"
          by (metis Col_def Per_perm l8_3 Z2 Z4)
      }
      thus ?thesis using Z1
        using ‹A A' OS B B' ⟹ Per B' A' C''› by blast
    qed
  }
  hence "∀ B'. (Coplanar A A' B B' ∧ Per B' A' A ∧ B' ≠ A) ⟶ Per B' A' C''"
    by simp
  hence "Per B' A' C''"
    using P6 assms(4) assms(6) by blast
  hence P11: "Per C'' A' B'"
    using Per_cases by auto
  have "Coplanar A' A C'' C'"
    by (meson P1 P2 assms(7) coplanar_trans_1 ncoplanar_perm_6 ncoplanar_perm_8 os__coplanar)
  thus ?thesis
    using P8 P9 P10 P11 l8_2 l11_60 by blast
qed

lemma l11_61_bis:
  assumes "D OrthAt A B C D P" and
    "D E Perp E Q" and
    "Coplanar A B C E" and
    "Coplanar D E P Q"
  shows "E OrthAt A B C E Q"
proof -
  have P4: "D ≠ E"
    using assms(2) perp_not_eq_1 by auto
  have P5: "E ≠ Q"
    using assms(2) perp_not_eq_2 by auto
  have "∃ D'. (D E Perp D' D ∧ Coplanar A B C D')"
  proof -
    obtain F where T1: "Coplanar A B C F ∧ ¬ Col D E F"
      using P4 ex_ncol_cop by blast
    obtain D' where T2: "D E Perp D' D ∧ Coplanar D E F D'"
      using P4 ex_perp_cop by blast
    have "Coplanar A B C D'"
    proof -
      have T3A: "¬ Col A B C"
        using OrthAt_def assms(1) by auto
      have T3B: "Coplanar A B C D"
        using OrthAt_def assms(1) by blast
      hence T4: "Coplanar D E F A"
        by (meson T1 T3A assms(3) coplanar_pseudo_trans ncop_distincts)
      have T5: "Coplanar D E F B"
        using T1 T3A T3B assms(3) coplanar_pseudo_trans ncop_distincts by blast
      have "Coplanar D E F C"
        using T1 T3A T3B assms(3) coplanar_pseudo_trans ncop_distincts by blast
      thus ?thesis
        using T1 T2 T4 T5 coplanar_pseudo_trans by blast
    qed
    thus ?thesis
      using T2 by auto
  qed
  then obtain D' where R1: "D E Perp D' D ∧ Coplanar A B C D'" by auto
  hence R2: "D ≠ D'"
    using perp_not_eq_2 by blast
  {
    fix M
    assume R3: "Coplanar A B C M"
    have "Col D P P"
      by (simp add: col_trivial_2)
    hence "Per E D P"
      using assms(1) assms(3) orth_at_chara by auto
    hence R4: "Per P D E" using l8_2 by auto
    have R5: "Per Q E D"
      using Perp_cases assms(2) perp_per_2 by blast
    have R6: "Coplanar D E D' M"
    proof -
      have S1: "¬ Col A B C"
        using OrthAt_def assms(1) by auto
      have "Coplanar A B C D"
        using OrthAt_def assms(1) by auto
      thus ?thesis
        using S1 assms(3) R1 R3 coplanar_pseudo_trans by blast
    qed
    have R7: "Per D' D E"
      using Perp_cases R1 perp_per_1 by blast
    have "Per D' D P"
      using R1 assms(1) orth_at_chara by blast
    hence "Per P D D'"
      using Per_cases by blast
    hence "Per Q E M"
      using l11_61 R4 R5 R6 R7 OrthAt_def P4 R2 assms(1) assms(4) by blast
    hence "Per M E Q" using l8_2 by auto
  }
  {
    fix P0 Q0
    assume "Coplanar A B C P0 ∧ Col E Q Q0"
    hence "Per P0 E Q0"
      using P5 ‹⋀M. Coplanar A B C M ⟹ Per M E Q› per_col by blast
  }
  thus ?thesis
    using OrthAt_def P5 assms(1) assms(3) col_trivial_3 by auto
qed

lemma l11_62_unicity:
  assumes "Coplanar A B C D" and
    "Coplanar A B C D'" and
    "∀ E. Coplanar A B C E ⟶ Per E D P" and
    "∀ E. Coplanar A B C E ⟶ Per E D' P"
  shows "D = D'"
  by (metis assms(1) assms(2) assms(3) assms(4) l8_8 not_col_distincts per_not_colp)

lemma l11_62_unicity_bis:
  assumes "X OrthAt A B C X U" and
    "Y OrthAt A B C Y U"
  shows "X = Y"
proof -
  have P1: "Coplanar A B C X"
    using assms(1) orth_at_chara by blast
  have P2: "Coplanar A B C Y"
    using assms(2) orth_at_chara by blast
  {
    fix E
    assume "Coplanar A B C E"
    hence "Per E X U"
      using OrthAt_def assms(1) col_trivial_2 by auto
  }
  {
    fix E
    assume "Coplanar A B C E"
    hence "Per E Y U"
      using assms(2) orth_at_chara by auto
  }
  thus ?thesis
    by (meson P1 P2 ‹⋀E. Coplanar A B C E ⟹ Per E X U› l8_2 l8_7)
qed

lemma orth_at2__eq:
  assumes "X OrthAt A B C U V" and
    "Y OrthAt A B C U V"
  shows "X = Y"
proof -
  have P1: "Coplanar A B C X"
    using assms(1)
    by (simp add: OrthAt_def)
  have P2: "Coplanar A B C Y"
    using OrthAt_def assms(2) by auto
  {
    fix E
    assume "Coplanar A B C E"
    hence "Per E X U"
      using OrthAt_def assms(1) col_trivial_3 by auto
  }
  {
    fix E
    assume "Coplanar A B C E"
    hence "Per E Y U"
      using OrthAt_def assms(2) col_trivial_3 by auto
  }
  thus ?thesis
    by (meson P1 P2 Per_perm ‹⋀E. Coplanar A B C E ⟹ Per E X U› l8_7)
qed

lemma col_cop_orth_at__eq:
  assumes "X OrthAt A B C U V" and
    "Coplanar A B C Y" and
    "Col U V Y"
  shows "X = Y"
proof -
  have "Y OrthAt A B C U V"
    using Orth_def assms(1) assms(2) assms(3) col_cop_orth__orth_at by blast
  thus ?thesis
    using assms(1) orth_at2__eq by auto
qed

lemma orth_at__ncop1:
  assumes "U ≠ X" and
    "X OrthAt A B C U V"
  shows "¬ Coplanar A B C U"
  using assms(1) assms(2) col_cop_orth_at__eq not_col_distincts by blast

lemma orth_at__ncop2:
  assumes "V ≠ X" and
    "X OrthAt A B C U V"
  shows "¬ Coplanar A B C V"
  using assms(1) assms(2) col_cop_orth_at__eq not_col_distincts by blast

lemma orth_at__ncop:
  assumes "X OrthAt A B C X P"
  shows "¬ Coplanar A B C P"
  by (metis assms orth_at__ncop2 orth_at_distincts)

lemma l11_62_existence:
  "∃ D. (Coplanar A B C D ∧ (∀ E. (Coplanar A B C E ⟶ Per E D P)))"
proof cases
  assume "Coplanar A B C P"
  thus ?thesis
    using l8_5 by auto
next
  assume P1: "¬ Coplanar A B C P"
  hence P2: "¬ Col A B C"
    using ncop__ncol by auto
  have "¬ Col A B P"
    using P1 ncop__ncols by auto
  then obtain D0 where P4: "Col A B D0 ∧ A B Perp P D0" using l8_18_existence by blast
  have P5: "Coplanar A B C D0"
    using P4 ncop__ncols by auto
  have "A ≠ B"
    using P2 not_col_distincts by auto
  then obtain D1 where P10: "A B Perp D1 D0 ∧ Coplanar A B C D1"
    using ex_perp_cop by blast
  have P11: "¬ Col A B D1"
    using P10 P4 perp_not_col2 by blast
  {
    fix D
    assume "Col D0 D1 D"
    hence "Coplanar A B C D"
      by (metis P10 P5 col_cop2__cop perp_not_eq_2)
  }
  obtain A0 where P11: "A ≠ A0 ∧ B ≠ A0 ∧ D0 ≠ A0 ∧ Col A B A0"
    using P4 diff_col_ex3 by blast
  have P12: "Coplanar A B C A0"
    using P11 ncop__ncols by blast
  have P13: "Per P D0 A0"
    using l8_16_1 P11 P4 by blast
  show ?thesis
  proof cases
    assume Z1: "Per P D0 D1"
    {
      fix E
      assume R1: "Coplanar A B C E"
      have R2: "¬ Col A0 D1 D0"
        by (metis P10 P11 P4 col_permutation_5 colx perp_not_col2)
      have R3: "Per A0 D0 P"
        by (simp add: P13 l8_2)
      have R4: "Per D1 D0 P"
        by (simp add: Z1 l8_2)
      have R5: "Per D0 D0 P"
        by (simp add: l8_2 l8_5)
      have "Coplanar A0 D1 D0 E"
        using R1 P2 P12 P10 P5 coplanar_pseudo_trans by blast
      hence "Per E D0 P"
        using l11_60 R2 R3 R4 R5 by blast
    }
    thus ?thesis using P5 by auto
  next
    assume S1: "¬ Per P D0 D1"
    {
      assume S2: "Col D0 D1 P"
      have "∀ D. Col D0 D1 D ⟶ Coplanar A B C D"
        by (simp add: ‹⋀Da. Col D0 D1 Da ⟹ Coplanar A B C Da›)
      hence "False"
        using P1 S2 by blast
    }
    hence S2A: "¬ Col D0 D1 P" by blast
    then obtain D where S3: "Col D0 D1 D ∧ D0 D1 Perp P D"
      using l8_18_existence by blast
    have S4: "Coplanar A B C D"
      by (simp add: S3 ‹⋀Da. Col D0 D1 Da ⟹ Coplanar A B C Da›)
    {
      fix E
      assume S5: "Coplanar A B C E"
      have S6: "D ≠ D0"
        using S1 S3 l8_2 perp_per_1 by blast
      have S7: "Per D0 D P"
        by (metis Perp_cases S3 S6 perp_col perp_per_1)
      have S8: "Per D D0 A0"
      proof -
        have V4: "D0 ≠ D1"
          using P10 perp_not_eq_2 by blast
        have V6: "Per A0 D0 D1"
          using P10 P11 P4 l8_16_1 l8_2 by blast
        thus ?thesis
          using S3 V4 V6 l8_2 per_col by blast
      qed
      have S9: "Per A0 D P"
      proof -
        obtain A0' where W1: "D Midpoint A0 A0'"
          using symmetric_point_construction by auto
        obtain D0' where W2: "D Midpoint D0 D0'"
          using symmetric_point_construction by auto
        have "Cong P A0 P A0'"
        proof -
          have V3: "Cong P D0 P D0'"
            using S7 W2 l8_2 per_double_cong by blast
          have V4: "Cong D0 A0 D0' A0'"
            using W1 W2 cong_4321 l7_13 by blast
          have "Per P D0' A0'"
          proof -
            obtain P' where V5: "D Midpoint P P'"
              using symmetric_point_construction by blast
            have "Per P' D0 A0"
            proof -
              have "¬ Col P D D0"
                by (metis S2A S3 S6 col2__eq col_permutation_1)
              thus ?thesis
                by (metis (full_types) P13 S3 S8 V5 S2A col_per2__per midpoint_col)
            qed
            thus ?thesis
              using midpoint_preserves_per V5 Mid_cases W1 W2 by blast
          qed
          thus ?thesis using l10_12 P13 V3 V4 by blast
        qed
        thus ?thesis
          using Per_def Per_perm W1 by blast
      qed
      have S13: "Per D D P"
        using Per_perm l8_5 by blast
      have S14: "¬ Col D0 A0 D" 
        using P11 S7 S9 per_not_col Col_perm S6 S8 by blast
      have "Coplanar A B C D" 
        using S4 by auto
      hence "Coplanar D0 A0 D E"
        using P12 P2 P5 S5 coplanar_pseudo_trans by blast
      hence "Per E D P"
        using S13 S14 S7 S9 l11_60 by blast
    }
    thus ?thesis using S4 by blast
  qed
qed

lemma l11_62_existence_bis:
  assumes "¬ Coplanar A B C P"
  shows "∃ X. X OrthAt A B C X P"
proof -
  obtain X where P1: "Coplanar A B C X ∧ (∀ E. Coplanar A B C E ⟶ Per E X P)"
    using l11_62_existence by blast
  hence P2: "X ≠ P"
    using assms by auto
  have P3: "¬ Col A B C"
    using assms ncop__ncol by auto
  thus ?thesis
    using P1 P2 P3 orth_at_chara by auto
qed

lemma l11_63_aux:
  assumes "Coplanar A B C D" and
    "D ≠ E" and
    "E OrthAt A B C E P"
  shows "∃ Q. (D E OS P Q ∧ A B C Orth D Q)"
proof -
  have P1: "¬ Col A B C"
    using OrthAt_def assms(3) by blast
  have P2: "E ≠ P"
    using OrthAt_def assms(3) by blast
  have P3: "Coplanar A B C E"
    using OrthAt_def assms(3) by blast
  have P4: "∀ P0 Q. (Coplanar A B C P0 ∧ Col E P Q) ⟶ Per P0 E Q"
    using OrthAt_def assms(3) by blast
  have P5: "¬ Coplanar A B C P"
    using assms(3) orth_at__ncop by auto
  have P6: "Col D E D"
    by (simp add: col_trivial_3)
  have "¬ Col D E P"
    using P3 P5 assms(1) assms(2) col_cop2__cop by blast
  then obtain Q where P6: "D E Perp Q D ∧ D E OS P Q"
    using P6 l10_15 by blast
  have "A B C Orth D Q"
  proof -
    obtain F where P7: "Coplanar A B C F ∧ ¬ Col D E F"
      using assms(2) ex_ncol_cop by blast
    obtain D' where P8: "D E Perp D' D ∧ Coplanar D E F D'"
      using assms(2) ex_perp_cop by presburger
    have P9: "¬ Col D' D E"
      using P8 col_permutation_1 perp_not_col by blast
    have P10: "Coplanar D E F A"
      by (meson P1 P3 P7 assms(1) coplanar_pseudo_trans ncop_distincts)
    have P11: "Coplanar D E F B"
      by (meson P1 P3 P7 assms(1) coplanar_pseudo_trans ncop_distincts)
    have P12: "Coplanar D E F C"
      by (meson P1 P3 P7 assms(1) coplanar_pseudo_trans ncop_distincts)
    hence "D OrthAt A B C D Q"
    proof -
      have "Per D' D Q"
      proof -
        obtain E' where Y1: "D E Perp E' E ∧ Coplanar D E F E'"
          using assms(2) ex_perp_cop by blast
        have Y2: "E ≠ E'"
          using Y1 perp_distinct by auto
        have Y5: "Coplanar E D E' D'"
          by (meson P7 P8 Y1 coplanar_perm_12 coplanar_perm_7 coplanar_trans_1 
              not_col_permutation_2)
        have Y6: "Per E' E D"
          by (simp add: Perp_perm perp_per_2 Y1)
        have Y7: "Per D' D E"
          using P8 col_trivial_2 col_trivial_3 l8_16_1 by blast
        have Y8: "Coplanar E D P Q"
          using P6 ncoplanar_perm_6 os__coplanar by blast
        have Y9: "Per P E D" using P4
          using assms(1) assms(3) l8_2 orth_at_chara by blast
        have Y10: "Coplanar A B C E'"
          using P10 P11 P12 P7 Y1 coplanar_pseudo_trans by blast
        hence Y11: "Per E' E P"
          using P4 Y10 col_trivial_2 by auto
        have "E ≠ D" using assms(2) by blast
        thus ?thesis
          using l11_61 Y2 assms(2) P2 Y5 Y6 Y7 Y8 Y9 Y10 Y11 by blast
      qed
      hence X1: "D OrthAt D' D E D Q" using l11_60_bis
        by (metis OS_def P6 P9 Per_perm TS_def l8_5 col_trivial_3 invert_one_side 
            ncop_distincts perp_per_1)
      have X3: "Coplanar D' D E A"
        using P10 P7 P8 coplanar_perm_14 coplanar_trans_1 not_col_permutation_3 by blast
      have X4: "Coplanar D' D E B"
        using P11 P7 P8 coplanar_perm_14 coplanar_trans_1 not_col_permutation_3 by blast
      have "Coplanar D' D E C"
        using P12 P7 P8 coplanar_perm_14 coplanar_trans_1 not_col_permutation_3 by blast
      thus ?thesis
        using X1 P1 X3 X4 cop3_orth_at__orth_at by blast
    qed
    thus ?thesis
      using Orth_def by blast
  qed
  thus ?thesis using P6 by blast
qed

lemma l11_63_existence:
  assumes "Coplanar A B C D" and
    "¬ Coplanar A B C P"
  shows "∃ Q. A B C Orth D Q"
  using Orth_def assms(1) assms(2) l11_62_existence_bis l11_63_aux by fastforce

lemma l8_21_3:
  assumes "Coplanar A B C D" and
    "¬ Coplanar A B C X"
  shows
    "∃ P T. (A B C Orth D P ∧ Coplanar A B C T ∧ Bet X T P)"
proof -
  obtain E where P1: "E OrthAt A B C E X"
    using assms(2) l11_62_existence_bis by blast
  thus ?thesis
  proof cases
    assume P2: "D = E"
    obtain Y where P3: "Bet X D Y ∧ Cong D Y D X"
      using segment_construction by blast
    have P4: "D ≠ X"
      using assms(1) assms(2) by auto
    have P5: "A B C Orth D X"
      using Orth_def P1 P2 by auto
    have P6: "D ≠ Y"
      using P3 P4 cong_reverse_identity by blast
    have "Col D X Y"
      using Col_def Col_perm P3 by blast
    hence "A B C Orth D Y"
      using P5 P6 col_orth__orth by auto
    thus ?thesis
      using P3 assms(1) by blast
  next
    assume K1: "D ≠ E"
    then obtain P' where P7: "D E OS X P' ∧ A B C Orth D P'"
      using P1 assms(1) l11_63_aux by blast
    have P8: "¬ Col A B C"
      using assms(2) ncop__ncol by auto
    have P9: "E ≠ X"
      using P7 os_distincts by auto
    have P10: "∀ P Q. (Coplanar A B C P ∧ Col E X Q) ⟶ Per P E Q"
      using OrthAt_def P1 by auto
    have P11: "D OrthAt A B C D P'"
      by (simp add: P7 assms(1) col_cop_orth__orth_at col_trivial_3)
    have P12: "D ≠ P'"
      using P7 os_distincts by auto
    have P13: "¬ Coplanar A B C P'"
      using P11 orth_at__ncop by auto
    have P14: "∀ P Q. (Coplanar A B C P ∧ Col D P' Q) ⟶ Per P D Q"
      using OrthAt_def P11 by auto
    obtain P where P15: "Bet P' D P ∧ Cong D P D P'"
      using segment_construction by blast
    have P16: "D E TS X P"
    proof -
      have P16A: "D E OS P' X" using P7 one_side_symmetry by blast
      hence "D E TS P' P"
        by (metis P12 P15 bet__ts cong_diff_3 one_side_not_col123)
      thus ?thesis using l9_8_2 P16A by blast
    qed
    obtain T where P17: "Col T D E ∧ Bet X T P"
      using P16 TS_def by blast
    have P18: "D ≠ P"
      using P16 ts_distincts by blast
    have "Col D P' P"
      using Col_def Col_perm P15 by blast
    hence "A B C Orth D P"
      using P18 P7 col_orth__orth by blast
    thus ?thesis using col_cop2__cop
      by (meson P1 P17 orth_at_chara K1 assms(1) col_permutation_1)
  qed
qed

lemma mid2_orth_at2__cong:
  assumes "X OrthAt A B C X P" and
    "Y OrthAt A B C Y Q" and
    "X Midpoint P P'" and
    "Y Midpoint Q Q'"
  shows "Cong P Q P' Q'"
proof -
  have Q1: "¬ Col A B C"
    using assms(1) col__coplanar orth_at__ncop by blast
  have Q2: "X ≠ P"
    using assms(1) orth_at_distincts by auto
  have Q3: "Coplanar A B C X"
    using OrthAt_def assms(1) by auto
  have Q4: "∀ P0 Q. (Coplanar A B C P0 ∧ Col X P Q) ⟶ Per P0 X Q"
    using OrthAt_def assms(1) by blast
  have Q5: "Y ≠ P"
    by (metis assms(1) assms(2) orth_at__ncop2 orth_at_chara)
  have Q6: "Coplanar A B C Y"
    using OrthAt_def assms(2) by blast
  have Q7: "∀ P Q0. (Coplanar A B C P ∧ Col Y Q Q0) ⟶ Per P Y Q0"
    using OrthAt_def assms(2) by blast
  obtain Z where P1: "Z Midpoint X Y"
    using midpoint_existence by auto
  obtain R where P2: "Z Midpoint P R"
    using symmetric_point_construction by auto
  obtain R' where P3: "Z Midpoint P' R'"
    using symmetric_point_construction by auto
  have T1: "Coplanar A B C Z"
    using P1 Q3 Q6 bet_cop2__cop midpoint_bet by blast
  hence "Per Z X P"
    using Q4 assms(1) orth_at_chara by auto
  hence T2: "Cong Z P Z P'"
    using assms(3) per_double_cong by blast
  have T3: "Cong R Z R' Z"
    by (metis Cong_perm Midpoint_def P2 P3 T2 cong_transitivity)
  have T4: "Cong R Q R' Q'"
    by (meson P1 P2 P3 assms(3) assms(4) l7_13 not_cong_4321 symmetry_preserves_midpoint)
  have "Per Z Y Q"
    using Q7 T1 assms(2) orth_at_chara by auto
  hence T5: "Cong Z Q Z Q'"
    using assms(4) per_double_cong by auto
  have "R ≠ Z"
    by (metis P2 P3 Q2 T3 assms(3) cong_diff_3 l7_17_bis midpoint_not_midpoint)
  thus ?thesis
    using P2 P3 T2 T3 T4 T5 five_segment l7_2 midpoint_bet by blast
qed

lemma orth_at2_tsp__ts:
  assumes "P ≠ Q" and
    "P OrthAt A B C P X" and
    "Q OrthAt A B C Q Y" and
    "A B C TSP X Y"
  shows "P Q TS X Y"
proof -
  obtain T where P0: "Coplanar A B C T ∧ Bet X T Y"
    using TSP_def assms(4) by auto
  have P1: "¬ Col A B C"
    using assms(4) ncop__ncol tsp__ncop1 by blast
  have P2: "P ≠ X "
    using assms(2) orth_at_distincts by auto
  have P3: "Coplanar A B C P"
    using OrthAt_def assms(2) by blast
  have P4: "∀ D. Coplanar A B C D ⟶ Per D P X"
    using assms(2) orth_at_chara by blast
  have P5: "Q ≠ Y"
    using assms(3) orth_at_distincts by auto
  have P6: "Coplanar A B C Q"
    using OrthAt_def assms(3) by blast
  have P7: "∀ D. Coplanar A B C D ⟶ Per D Q Y"
    using assms(3) orth_at_chara by blast
  have P8: "¬ Col X P Q"
    using P3 P6 assms(1) assms(4) col_cop2__cop not_col_permutation_2 tsp__ncop1 by blast
  have P9: "¬ Col Y P Q"
    using P3 P6 assms(1) assms(4) col_cop2__cop not_col_permutation_2 tsp__ncop2 by blast
  have "Col T P Q"
  proof -
    obtain X' where Q1: "P Midpoint X X'"
      using symmetric_point_construction by auto
    obtain Y' where Q2: "Q Midpoint Y Y'"
      using symmetric_point_construction by auto
    have "Per T P X"
      using P0 P4 by auto
    hence Q3: "Cong T X T X'"
      using Q1 per_double_cong by auto
    have "Per T Q Y"
      using P0 P7 by auto
    hence Q4: "Cong T Y T Y'" using Q2 per_double_cong by auto
    have "Cong X Y X' Y'"
      using P1 Q1 Q2 assms(2) assms(3) mid2_orth_at2__cong by blast
    hence "X T Y Cong3 X' T Y'"
      using Cong3_def Q3 Q4 not_cong_2143 by blast
    hence "Bet X' T Y'"
      using l4_6 P0 by blast
    thus ?thesis
      using Q1 Q2 Q3 Q4 Col_def P0 between_symmetry l7_22 by blast
  qed
  thus ?thesis
    using P0 P8 P9 TS_def by blast
qed

lemma orth_dec:
  shows "A B C Orth U V ∨ ¬ A B C Orth U V" 
  by auto

lemma orth_at_dec:
  shows "X OrthAt A B C U V ∨ ¬ X OrthAt A B C U V" 
  by auto

lemma tsp_dec:
  shows "A B C TSP X Y ∨ ¬ A B C TSP X Y" 
  by auto

lemma osp_dec:
  shows "A B C OSP X Y ∨ ¬ A B C OSP X Y" 
  by auto

lemma ts2__inangle:
  assumes "A C TS B P" and
    "B P TS A C"
  shows "P InAngle A B C"
  by (metis InAngle_def assms(1) assms(2) bet_out ts2__ex_bet2 ts_distincts)

lemma os_ts__inangle:
  assumes "B P TS A C" and
    "B A OS C P"
  shows "P InAngle A B C"
proof -
  have P1: "¬ Col A B P"
    using TS_def assms(1) by auto
  have P2: "¬ Col B A C"
    using assms(2) col123__nos by blast
  obtain P' where P3: "B Midpoint P P'"
    using symmetric_point_construction by blast
  hence P4: "¬ Col B A P'"
    by (metis assms(2) col_one_side col_permutation_5 midpoint_col 
        midpoint_distinct_2 one_side_not_col124)
  have P5: "(B ≠ P' ∧ B P TS A C ∧ Bet P B P') ⟶ (P InAngle A B C ∨ P' InAngle A B C)"
    using two_sides_in_angle by auto
  hence P6: "P InAngle A B C ∨ P' InAngle A B C"
    using P3 P4 assms(1) midpoint_bet not_col_distincts by blast
  {
    assume "P' InAngle A B C"
    hence P7: "A B OS P' C"
      using Col_cases P2 P4 in_angle_one_side by blast
    hence P8: "¬ A B TS P' C"
      using l9_9 by auto
    have "B A TS P P'"
      using P1 P3 P4 bet__ts midpoint_bet not_col_distincts not_col_permutation_4 by auto
    hence "B A TS C P'"
      using P7 assms(2) invert_one_side l9_2 l9_8_2 l9_9 by blast
    hence "B A TS P' C"
      using l9_2 by blast
    hence "A B TS P' C"
      by (simp add: invert_two_sides)
    hence "P InAngle A B C"
      using P8 by auto
  }
  thus ?thesis
    using P6 by blast
qed

lemma os2__inangle:
  assumes "B A OS C P" and
    "B C OS A P"
  shows "P InAngle A B C"
  using assms(1) assms(2) col124__nos l9_9_bis os_ts__inangle two_sides_cases by blast

lemma acute_conga__acute:
  assumes "Acute A B C" and
    "A B C CongA D E F"
  shows "Acute D E F"
proof -
  have "D E F LeA A B C"
    by (simp add: assms(2) conga__lea456123)
  thus ?thesis
    using acute_lea_acute assms(1) by blast
qed

lemma acute_out2__acute:
  assumes "B Out A' A" and
    "B Out C' C" and
    "Acute A B C"
  shows "Acute A' B C'"
  by (meson out2__conga acute_conga__acute assms(1) assms(2) assms(3))

lemma conga_obtuse__obtuse:
  assumes "Obtuse A B C" and
    "A B C CongA D E F"
  shows "Obtuse D E F"
  using assms(1) assms(2) conga__lea lea_obtuse_obtuse by blast

lemma obtuse_out2__obtuse:
  assumes "B Out A' A" and
    "B Out C' C" and
    "Obtuse A B C"
  shows "Obtuse A' B C'"
  by (meson out2__conga assms(1) assms(2) assms(3) conga_obtuse__obtuse)

lemma bet_lea__bet:
  assumes "Bet A B C" and
    "A B C LeA D E F"
  shows "Bet D E F"
proof -
  have "A B C CongA D E F"
    by (metis assms(1) assms(2) l11_31_2 lea_asym lea_distincts)
  thus ?thesis
    using assms(1) bet_conga__bet by blast
qed

lemma out_lea__out:
  assumes "E Out D F" and
    "A B C LeA D E F"
  shows "B Out A C"
proof -
  have "D E F CongA A B C"
    using l11_31_1 lea_asym lea_distincts assms(1) assms(2) by fastforce
  thus ?thesis
    using assms(1) out_conga_out by blast
qed

lemma bet2_lta__lta:
  assumes "A B C LtA D E F" and
    "Bet A B A'" and
    "A' ≠ B" and
    "Bet D E D'" and
    "D' ≠ E"
  shows "D' E F LtA A' B C"
proof -
  have P1: "D' E F LeA A' B C"
    by (metis Bet_cases assms(1) assms(2) assms(3) assms(4) assms(5) l11_36_aux2 
        lea_distincts lta__lea)
  have "¬ D' E F CongA A' B C"
    by (metis assms(1) assms(2) assms(4) between_symmetry conga_sym l11_13 
        lta_distincts not_lta_and_conga)
  thus ?thesis
    by (simp add: LtA_def P1)
qed

lemma lea123456_lta__lta:
  assumes "A B C LeA D E F" and
    "D E F LtA G H I"
  shows "A B C LtA G H I"
proof -
  have "¬ G H I LeA F E D"
    by (metis (no_types) lea__nlta lta_left_comm assms(2))
  hence "¬ A B C CongA G H I"
    by (metis lta_distincts assms(1) assms(2) conga_pseudo_refl l11_30)
  thus ?thesis
    by (meson LtA_def lea_trans assms(1) assms(2))
qed

lemma lea456789_lta__lta:
  assumes "A B C LtA D E F" and
    "D E F LeA G H I"
  shows "A B C LtA G H I"
  by (meson LtA_def assms(1) assms(2) conga__lea456123 lea_trans lta__nlea)

lemma acute_per__lta:
  assumes "Acute A B C" and
    "D ≠ E" and
    "E ≠ F" and
    "Per D E F"
  shows "A B C LtA D E F"
proof -
  obtain G H I where P1: "Per G H I ∧ A B C LtA G H I"
    using Acute_def assms(1) by auto
  hence "G H I CongA D E F"
    using assms(2) assms(3) assms(4) l11_16 lta_distincts by blast
  thus ?thesis
    by (metis P1 conga_preserves_lta conga_refl lta_distincts)
qed

lemma obtuse_per__lta:
  assumes "Obtuse A B C" and
    "D ≠ E" and
    "E ≠ F" and
    "Per D E F"
  shows "D E F LtA A B C"
proof -
  obtain G H I where P1: "Per G H I ∧ G H I LtA A B C"
    using Obtuse_def assms(1) by auto
  hence "G H I CongA D E F"
    using assms(2) assms(3) assms(4) l11_16 lta_distincts by blast
  thus ?thesis
    by (metis P1 l11_51 assms(1) cong_reflexivity conga_preserves_lta obtuse_distincts)
qed

lemma acute_obtuse__lta:
  assumes "Acute A B C" and
    "Obtuse D E F"
  shows "A B C LtA D E F"
  by (metis Acute_def assms(1) assms(2) lta_distincts lta_trans obtuse_per__lta)

lemma lea_in_angle:
  assumes "A B P LeA A B C" and
    "A B OS C P"
  shows "P InAngle A B C"
proof -
  obtain T where P3: "T InAngle A B C ∧ A B P CongA A B T"
    using LeA_def assms(1) by blast
  thus ?thesis
    by (metis assms(2) conga_preserves_in_angle conga_refl not_conga_sym 
        one_side_symmetry os_distincts)
qed

lemma acute_bet__obtuse:
  assumes "Bet A B A'" and
    "A' ≠ B" and
    "Acute A B C"
  shows "Obtuse A' B C"
proof cases
  assume P1: "Col A B C"
  show ?thesis
  proof cases
    assume "Bet A B C"
    thus ?thesis
      using P1 acute_col__out assms(3) not_bet_and_out by blast
  next
    assume "¬ Bet A B C"
    hence "B Out A C" 
      using P1 or_bet_out by blast
    hence "Bet C B A'" 
      using assms(1) bet_out__bet by blast
    hence "Bet A' B C" 
      using between_symmetry by blast
    thus ?thesis 
      using ‹¬ Bet A B C› assms(2) bet__obtuse between_trivial by blast
  qed
next
  assume P2: "¬ Col A B C"
  then obtain D where P3: "A B Perp D B ∧ A B OS C D"
    using col_trivial_2 l10_15 by blast
  {
    assume P4: "Col C B D"
    hence "Per A B C"
    proof -
      have P5: "B ≠ D"
        using P3 perp_not_eq_2 by auto
      have "Per A B D"
        using P3 Perp_perm perp_per_2 by blast
      thus ?thesis
        using P4 P5 not_col_permutation_2 per_col by blast
    qed
    hence "A B C LtA A B C"
      by (metis Acute_def acute_per__lta assms(3) lta_distincts)
    hence "False"
      by (simp add: nlta)
  }
  hence P6: "¬ Col C B D" by auto
  have P7: "B A' OS C D"
    by (metis P3 assms(1) assms(2) bet_col col2_os__os l5_3)
  have T1: "Per A B D"
    by (simp add: P3 perp_left_comm perp_per_1)
  have Q1: "B C TS A' A"
    using P2 assms(1) assms(2) bet__ts l9_2 not_col_permutation_1 by auto
  have "A B C LtA A B D"
    using P2 P6 T1 acute_per__lta assms(3) not_col_distincts by auto
  hence "A B C LeA A B D"
    by (simp add: lta__lea)
  hence "C InAngle A B D"
    by (simp add: P3 lea_in_angle one_side_symmetry)
  hence "C InAngle D B A"
    using l11_24 by blast
  hence "C B TS D A"
    by (simp add: P2 P6 in_angle_two_sides not_col_permutation_1 not_col_permutation_4)
  hence "B C TS D A"
    using invert_two_sides by blast
  hence "B C OS A' D"
    using Q1 l9_8_1 by auto
  hence T1A: "D InAngle A' B C"
    by (simp add: P7 os2__inangle)
  hence "A B D CongA A' B D"
    by (metis Per_cases T1 conga_comm l11_18_1 acute_distincts assms(1) assms(3) inangle_distincts)
  hence T2: "A B D LeA A' B C"
    using LeA_def T1A by auto
  {
    assume "A B D CongA A' B C"
    hence "False"
      by (metis OS_def P7 T1 TS_def out2__conga ‹A B C LtA A B D› ‹A B D CongA A' B D› 
          ‹⋀thesis. (⋀D. A B Perp D B ∧ A B OS C D ⟹ thesis) ⟹ thesis› 
          col_trivial_2 invert_one_side l11_17 l11_19 not_lta_and_conga out_trivial)
  }
  hence "¬ A B D CongA A' B C" by auto
  hence "A B D LtA A' B C"
    using T2 LtA_def by auto
  thus ?thesis
    using T1 Obtuse_def by blast
qed

lemma bet_obtuse__acute:
  assumes "Bet A B A'" and
    "A' ≠ B" and
    "Obtuse A B C"
  shows "Acute A' B C"
proof cases
  assume P1: "Col A B C"
  thus ?thesis
  proof cases
    assume "Bet A B C"
    hence "B Out A' C"
      using Out_def assms(1) assms(2) assms(3) l5_2 obtuse_distincts by meson
    thus ?thesis
      by (simp add: out__acute)
  next
    assume "¬ Bet A B C"
    thus ?thesis
      using P1 assms(3) col_obtuse__bet by blast
  qed
next
  assume P2: "¬ Col A B C"
  then obtain D where P3: "A B Perp D B ∧ A B OS C D"
    using col_trivial_2 l10_15 by blast
  {
    assume P3A: "Col C B D"
    have P3B: "B ≠ D"
      using P3 perp_not_eq_2 by blast
    have P3C: "Per A B D"
      using P3 Perp_perm perp_per_2 by blast
    hence "Per A B C"
      using P3A P3B not_col_permutation_2 per_col by blast
    hence "A B C LtA A B C"
      using P2 assms(3) not_col_distincts obtuse_per__lta by auto
    hence "False"
      by (simp add: nlta)
  }
  hence P4: "¬ Col C B D" by auto
  have "Col B A A'"
    using Col_def Col_perm assms(1) by blast
  hence P5: "B A' OS C D"
    using P3 assms(2) invert_one_side col2_os__os col_trivial_3 by blast
  have P7: "Per A' B D"
    by (meson Col_def P3 Per_perm Tarski_neutral_dimensionless_axioms assms(1) 
        col_trivial_2 l8_16_1)
  have "A' B C LtA A' B D"
  proof -
    have P8: "A' B C LeA A' B D"
    proof -
      have P9: "C InAngle A' B D"
      proof -
        have P10: "B A' OS D C"
          by (simp add: P5 one_side_symmetry)
        have "B D OS A' C"
        proof -
          have P6: "¬ Col A B D"
            using P3 col124__nos by auto
          hence P11: "B D TS A' A"
            using Col_perm P5 assms(1) bet__ts l9_2 os_distincts by blast
          have "A B D LtA A B C"
          proof -
            have P11A: "A ≠ B"
              using P2 col_trivial_1 by auto
            have P11B: "B ≠ D"
              using P4 col_trivial_2 by blast
            have "Per A B D"
              using P3 Perp_cases perp_per_2 by blast
            thus ?thesis
              by (simp add: P11A P11B obtuse_per__lta assms(3))
          qed
          hence "A B D LeA A B C"
            by (simp add: lta__lea)
          hence "D InAngle A B C"
            by (simp add: P3 lea_in_angle)
          hence "D InAngle C B A"
            using l11_24 by blast
          hence "D B TS C A"
            by (simp add: P4 P6 in_angle_two_sides not_col_permutation_4)
          hence "B D TS C A"
            by (simp add: invert_two_sides)
          thus ?thesis
            using OS_def P11 by blast
        qed
        thus ?thesis
          by (simp add: P10 os2__inangle)
      qed
      have "A' B C CongA A' B C"
        using assms(2) assms(3) conga_refl obtuse_distincts by blast
      thus ?thesis
        by (simp add: P9 inangle__lea)
    qed
    {
      assume "A' B C CongA A' B D"
      hence "B Out C D"
        using P5 conga_os__out invert_one_side by blast
      hence "False"
        using P4 not_col_permutation_4 out_col by blast
    }
    hence "¬ A' B C CongA A' B D" by auto
    thus ?thesis
      by (simp add: LtA_def P8)
  qed
  thus ?thesis
    using Acute_def P7 by blast
qed

lemma inangle_dec:
  "P InAngle A B C ∨ ¬ P InAngle A B C" 
  by blast

lemma lea_dec:
  "A B C LeA D E F ∨ ¬ A B C LeA D E F" 
  by blast

lemma lta_dec:
  "A B C LtA D E F ∨ ¬ A B C LtA D E F" 
  by blast

lemma lea_total:
  assumes "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F"
  shows "A B C LeA D E F ∨ D E F LeA A B C"
proof cases
  assume P1: "Col A B C"
  show ?thesis
  proof cases
    assume "B Out A C"
    thus ?thesis
      using assms(3) assms(4) l11_31_1 by auto
  next
    assume "¬ B Out A C"
    thus ?thesis
      by (metis P1 assms(1) assms(2) assms(3) assms(4) l11_31_2 or_bet_out)
  qed
next
  assume P2: "¬ Col A B C"
  show ?thesis
  proof cases
    assume P3: "Col D E F"
    show ?thesis
    proof cases
      assume "E Out D F"
      thus ?thesis
        using assms(1) assms(2) l11_31_1 by auto
    next
      assume "¬ E Out D F"
      thus ?thesis
        by (metis P3 assms(1) assms(2) assms(3) assms(4) l11_31_2 l6_4_2)
    qed
  next
    assume P4: "¬ Col D E F"
    show ?thesis
    proof cases
      assume "A B C LeA D E F"
      thus ?thesis
        by simp
    next
      assume P5: "¬ A B C LeA D E F"
      obtain P where P6: "D E F CongA A B P ∧ A B OS P C"
        using P2 P4 angle_construction_1 by blast
      hence P7: "B A OS C P"
        using invert_one_side one_side_symmetry by blast
      have "B C OS A P"
      proof -
        {
          assume "Col P B C"
          hence P7B: "B Out C P"
            using Col_cases P7 col_one_side_out by blast
          have "A B C CongA D E F"
          proof -
            have P7C: "A B P CongA D E F"
              by (simp add: P6 conga_sym)
            have P7D: "B Out A A"
              by (simp add: assms(1) out_trivial)
            have P7E: "E Out D D"
              by (simp add: assms(3) out_trivial)
            have "E Out F F"
              using assms(4) out_trivial by auto
            thus ?thesis
              using P7B P7C P7D P7E l11_10 by blast
          qed
          hence "A B C LeA D E F"
            by (simp add: conga__lea)
          hence "False"
            by (simp add: P5)
        }
        hence P8: "¬ Col P B C" by auto
        {
          assume T0: "B C TS A P"
          have "A B C CongA D E F"
          proof -
            have T1: "A B C LeA A B P"
            proof -
              have T1A: "C InAngle A B P"
                by (simp add: P7 T0 one_side_symmetry os_ts__inangle)
              have "A B C CongA A B C"
                using assms(1) assms(2) conga_refl by auto
              thus ?thesis
                by (simp add: T1A inangle__lea)
            qed
            have T2: "A B C CongA A B C"
              using assms(1) assms(2) conga_refl by auto
            have "A B P CongA D E F"
              by (simp add: P6 conga_sym)
            thus ?thesis
              using P5 T1 T2 l11_30 by blast
          qed
          hence "A B C LeA D E F"
            by (simp add: conga__lea)
          hence "False"
            by (simp add: P5)
        }
        hence "¬ B C TS A P" by auto
        thus ?thesis
          using Col_perm P7 P8 one_side_symmetry os_ts1324__os two_sides_cases by blast
      qed
      hence "P InAngle A B C"
        using P7 os2__inangle by blast
      hence "D E F LeA A B C"
        using P6 LeA_def by blast
      thus ?thesis
        by simp
    qed
  qed
qed

lemma or_lta2_conga:
  assumes "A ≠ B" and
    "C ≠ B" and
    "D ≠ E" and
    "F ≠ E"
  shows "A B C LtA D E F ∨ D E F LtA A B C ∨ A B C CongA D E F"
proof -
  have P1: "A B C LeA D E F ∨ D E F LeA A B C"
    using assms(1) assms(2) assms(3) assms(4) lea_total by auto
  {
    assume "A B C LeA D E F"
    hence "A B C LtA D E F ∨ D E F LtA A B C ∨ A B C CongA D E F"
      using LtA_def by blast
  }
  {
    assume "D E F LeA A B C"
    hence "A B C LtA D E F ∨ D E F LtA A B C ∨ A B C CongA D E F"
      using LtA_def conga_sym by blast
  }
  thus ?thesis
    using P1 ‹A B C LeA D E F ⟹ A B C LtA D E F ∨ D E F LtA A B C ∨ A B C CongA D E F› 
    by blast
qed

lemma angle_partition:
  assumes "A ≠ B" and
    "B ≠ C"
  shows "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
proof -
  obtain A' B' D' where P1: "¬ (Bet A' B' D' ∨ Bet B' D' A' ∨ Bet D' A' B')"
    using lower_dim by auto
  hence "¬ Col A' B' D'"
    by (simp add: Col_def)
  obtain C' where P3: "A' B' Perp C' B'"
    by (metis P1 Perp_perm between_trivial2 perp_exists)
  hence P4: "A B C LtA A' B' C' ∨ A' B' C' LtA A B C ∨ A B C CongA A' B' C'"
    by (metis P1 assms(1) assms(2) between_trivial2 or_lta2_conga perp_not_eq_2)
  {
    assume "A B C LtA A' B' C'"
    hence "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
      using Acute_def P3 Perp_cases perp_per_2 by blast
  }
  {
    assume "A' B' C' LtA A B C"
    hence "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
      using Obtuse_def P3 Perp_cases perp_per_2 by blast
  }
  {
    assume "A B C CongA A' B' C'"
    hence "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
      by (metis P3 Perp_cases conga_sym l11_17 perp_per_2)
  }
  thus ?thesis
    using P4 ‹A B C LtA A' B' C' ⟹ Acute A B C ∨ Per A B C ∨ Obtuse A B C› 
      ‹A' B' C' LtA A B C ⟹ Acute A B C ∨ Per A B C ∨ Obtuse A B C› by auto
qed

lemma acute_chara_1:
  assumes "Bet A B A'" and
    "B ≠ A'" and
    "Acute A B C"
  shows "A B C LtA A' B C"
proof -
  have "Obtuse A' B C"
    using acute_bet__obtuse assms(1) assms(2) assms(3) by blast
  thus ?thesis
    by (simp add: acute_obtuse__lta assms(3))
qed

lemma acute_chara_2:
  assumes "Bet A B A'" and
    "A B C LtA A' B C"
  shows "Acute A B C"
  by (metis Acute_def acute_chara_1 angle_partition assms(1) assms(2) bet_obtuse__acute 
      between_symmetry lta_distincts not_and_lta)

lemma acute_chara:
  assumes "Bet A B A'" and
    "B ≠ A'"
  shows "Acute A B C ⟷ A B C LtA A' B C"
  using acute_chara_1 acute_chara_2 assms(1) assms(2) by blast

lemma obtuse_chara:
  assumes "Bet A B A'" and
    "B ≠ A'"
  shows "Obtuse A B C ⟷ A' B C LtA A B C"
  by (metis Obtuse_def acute_bet__obtuse acute_chara assms(1) assms(2) 
      bet_obtuse__acute between_symmetry lta_distincts)

lemma conga__acute:
  assumes "A B C CongA A C B"
  shows "Acute A B C"
  by (metis acute_sym angle_partition assms conga_distinct conga_obtuse__obtuse l11_17 l11_43)

lemma cong__acute:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Cong A B A C"
  shows "Acute A B C"
  using angle_partition assms(1) assms(2) assms(3) cong__nlt l11_46 lt_left_comm by blast

lemma nlta__lea:
  assumes "¬ A B C LtA D E F" and
    "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F"
  shows "D E F LeA A B C"
  by (metis LtA_def assms(1) assms(2) assms(3) assms(4) assms(5) conga__lea456123 or_lta2_conga)

lemma nlea__lta:
  assumes "¬ A B C LeA D E F" and
    "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F"
  shows "D E F LtA A B C"
  using assms(1) assms(2) assms(3) assms(4) assms(5) nlta__lea by blast

lemma triangle_strict_inequality:
  assumes "Bet A B D" and
    "Cong B C B D" and
    "¬ Bet A B C"
  shows "A C Lt A D"
proof cases
  assume P1: "Col A B C"
  hence P2: "B Out A C"
    using assms(3) not_out_bet by auto
  {
    assume "Bet B A C"
    hence P3: "A C Le A D"
      by (meson assms(1) assms(2) cong__le l5_12_a le_transitivity)
    have "¬ Cong A C A D"
      by (metis Out_def P1 P2 assms(1) assms(2) assms(3) l4_18)
    hence "A C Lt A D"
      by (simp add: Lt_def P3)
  }
  {
    assume "Bet A C B"
    hence P5: "Bet A C D"
      using assms(1) between_exchange4 by blast
    hence P6: "A C Le A D"
      by (simp add: bet__le1213)
    have "¬ Cong A C A D"
      using P5 assms(1) assms(3) between_cong by blast
    hence "A C Lt A D"
      by (simp add: Lt_def P6)
  }
  thus ?thesis
    using P1 ‹Bet B A C ⟹ A C Lt A D› assms(3) between_symmetry third_point by blast
next
  assume T1: "¬ Col A B C"
  have T2: "A ≠ D"
    using T1 assms(1) between_identity col_trivial_1 by auto
  have T3: "¬ Col A C D"
    by (metis Col_def T1 T2 assms(1) col_transitivity_2)
  have T4: "Bet D B A"
    using Bet_perm assms(1) by blast
  have T5: "C D A CongA D C B"
  proof -
    have T6: "C D B CongA D C B"
      by (metis assms(1) assms(2) assms(3) between_trivial conga_comm l11_44_1_a not_conga_sym)
    have T7: "D Out C C"
      using T3 not_col_distincts out_trivial by blast
    have T8: "D Out A B"
      by (metis assms(1) assms(2) assms(3) bet_out_1 cong_diff l6_6)
    have T9: "C Out D D"
      using T7 out_trivial by force
    have "C Out B B"
      using T1 not_col_distincts out_trivial by auto
    thus ?thesis
      using T6 T7 T8 T9 l11_10 by blast
  qed
  have "A D C LtA A C D"
  proof -
    have "B InAngle D C A"
      by (metis InAngle_def T1 T3 T4 not_col_distincts out_trivial)
    hence "C D A LeA D C A"
      using T5 LeA_def by auto
    hence T10: "A D C LeA A C D"
      by (simp add: lea_comm)
    have "¬ A D C CongA A C D"
      by (metis Col_perm T3 assms(1) assms(2) assms(3) bet_col l11_44_1_b l4_18 
          not_bet_distincts not_cong_3412)
    thus ?thesis
      using LtA_def T10 by blast
  qed
  thus ?thesis
    by (simp add: l11_44_2_b)
qed

lemma triangle_inequality:
  assumes "Bet A B D" and
    "Cong B C B D"
  shows "A C Le A D"
proof cases
  assume "Bet A B C"
  thus ?thesis
    by (metis assms(1) assms(2) between_cong_3 cong__le le_reflexivity)
next
  assume "¬ Bet A B C"
  hence "A C Lt A D"
    using assms(1) assms(2) triangle_strict_inequality by auto
  thus ?thesis
    by (simp add: Lt_def)
qed

lemma triangle_strict_inequality_2:
  assumes "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"  and
    "¬ Bet A B C"
  shows "A C Lt A' C'"
proof -
  obtain D where P1: "Bet A B D ∧ Cong B D B C"
    using segment_construction by blast
  hence P2: "A C Lt A D"
    using P1 assms(4) cong_symmetry triangle_strict_inequality by blast
  have "Cong A D A' C'"
    using P1 assms(1) assms(2) assms(3) cong_transitivity l2_11_b by blast
  thus ?thesis
    using P2 cong2_lt__lt cong_reflexivity by blast
qed

lemma triangle_inequality_2:
  assumes "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "A C Le A' C'"
proof -
  obtain D where P1: "Bet A B D ∧ Cong B D B C"
    using segment_construction by blast
  have P2: "A C Le A D"
    by (meson P1 triangle_inequality not_cong_3412)
  have "Cong A D A' C'"
    using P1 assms(1) assms(2) assms(3) cong_transitivity l2_11_b by blast
  thus ?thesis
    using P2 cong__le le_transitivity by blast
qed

lemma triangle_strict_reverse_inequality:
  assumes "A Out B D" and
    "Cong A C A D" and
    "¬ A Out B C"
  shows "B D Lt B C"
proof cases
  assume "Col A B C"
  thus ?thesis
    using assms(1) assms(2) assms(3) col_permutation_4 cong_symmetry not_bet_and_out 
      or_bet_out triangle_strict_inequality by blast
next
  assume P1: "¬ Col A B C"
  show ?thesis
  proof cases
    assume "B = D"
    thus ?thesis
      using P1 lt1123 not_col_distincts by auto
  next
    assume P2: "B ≠ D"
    hence P3: "¬ Col B C D"
      using P1 assms(1) col_trivial_2 colx not_col_permutation_5 out_col by blast
    have P4: "¬ Col A C D"
      using P1 assms(1) col2__eq col_permutation_4 out_col out_distinct by blast
    have P5: "C ≠ D"
      using assms(1) assms(3) by auto
    hence P6: "A C D CongA A D C"
      by (metis P1 assms(2) col_trivial_3 l11_44_1_a)
    {
      assume T1: "Bet A B D"
      hence T2: "Bet D B A"
        using Bet_perm by blast
      have "B C D LtA B D C"
      proof -
        have T3: "D C B CongA B C D"
          by (metis P3 conga_pseudo_refl not_col_distincts)
        have T3A: "D Out B A"
          by (simp add: P2 T1 bet_out_1)
        have T3B: "C Out D D"
          using P5 out_trivial by auto
        have T3C: "C Out A A"
          using P1 not_col_distincts out_trivial by blast
        have "D Out C C"
          by (simp add: P5 out_trivial)
        hence T4: "D C A CongA B D C" using T3A T3B T3C
          by (meson conga_comm conga_right_comm l11_10 P6)
        have "D C B LtA D C A"
        proof -
          have T4A: "D C B LeA D C A"
          proof -
            have T4AA: "B InAngle D C A"
              using InAngle_def P1 P5 T2 not_col_distincts out_trivial by auto
            have "D C B CongA D C B"
              using T3 conga_right_comm by blast
            thus ?thesis
              by (simp add: T4AA inangle__lea)
          qed
          {
            assume T5: "D C B CongA D C A"
            have "D C OS B A"
              using Col_perm P3 T3A out_one_side by blast
            hence "C Out B A"
              using T5 conga_os__out by blast
            hence "False"
              using Col_cases P1 out_col by blast
          }
          hence "¬ D C B CongA D C A" by auto
          thus ?thesis
            using LtA_def T4A by blast
        qed
        thus ?thesis
          using T3 T4 conga_preserves_lta by auto
      qed
    }
    {
      assume Q1: "Bet B D A"
      obtain E where Q2: "Bet B C E ∧ Cong B C C E"
        using Cong_perm segment_construction by blast
      have "A D C LtA E C D"
      proof -
        have Q3: "D C OS A E"
        proof -
          have Q4: "D C TS A B"
            by (metis Col_perm P2 Q1 P4 bet__ts between_symmetry)
          hence "D C TS E B"
            by (metis Col_def Q1 Q2 TS_def bet__ts cong_identity invert_two_sides l9_2)
          thus ?thesis
            using OS_def Q4 by blast
        qed
        have Q5: "A C D LtA E C D"
        proof -
          have "D C A LeA D C E"
          proof -
            have "B Out D A"
              using P2 Q1 bet_out by auto
            hence "B C OS D A"
              by (simp add: P3 out_one_side)
            hence "C B OS D A"
              using invert_one_side by blast
            hence "C E OS D A"
              by (metis Col_def Q2 Q3 col124__nos col_one_side diff_col_ex 
                  not_col_permutation_5)
            hence Q5A: "A InAngle D C E"
              by (simp add: ‹C E OS D A› Q3 invert_one_side one_side_symmetry os2__inangle)
            have "D C A CongA D C A"
              using CongA_def P6 conga_refl by auto
            thus ?thesis
              by (simp add: Q5A inangle__lea)
          qed
          hence Q6: "A C D LeA E C D"
            using lea_comm by blast
          {
            assume "A C D CongA E C D"
            hence "D C A CongA D C E"
              by (simp add: conga_comm)
            hence "C Out A E"
              using Q3 conga_os__out by auto
            hence "False"
              by (meson Col_def Out_cases P1 Q2 not_col_permutation_3 
                  one_side_not_col123 out_one_side)
          }
          hence "¬ A C D CongA E C D" by auto
          thus ?thesis
            by (simp add: LtA_def Q6)
        qed
        have "E C D CongA E C D"
          by (metis P1 P5 Q2 cong_diff conga_refl not_col_distincts)
        thus ?thesis
          using Q5 P6 conga_preserves_lta by auto
      qed
      hence "B C D LtA B D C"
        using Bet_cases P1 P2 Q1 Q2 bet2_lta__lta not_col_distincts by blast
    }
    hence "B C D LtA B D C"
      by (meson Out_def ‹Bet A B D ⟹ B C D LtA B D C› assms(1) between_symmetry)
    thus ?thesis
      by (simp add: l11_44_2_b)
  qed
qed

lemma triangle_reverse_inequality:
  assumes "A Out B D" and
    "Cong A C A D"
  shows "B D Le B C"
proof cases
  assume "A Out B C"
  thus ?thesis
    by (metis assms(1) assms(2) bet__le1213 cong_pseudo_reflexivity l6_11_uniqueness 
        l6_6 not_bet_distincts not_cong_4312)
next
  assume "¬ A Out B C"
  thus ?thesis
    using triangle_strict_reverse_inequality assms(1) assms(2) lt__le by auto
qed

lemma os3__lta:
  assumes "A B OS C D" and
    "B C OS A D" and
    "A C OS B D"
  shows "B A C LtA B D C"
proof -
  have P1: "D InAngle A B C"
    by (simp add: assms(1) assms(2) invert_one_side os2__inangle)
  then obtain E where P2: "Bet A E C ∧ (E = B ∨ B Out E D)"
    using InAngle_def by auto
  have P3: "¬ Col A B C"
    using assms(1) one_side_not_col123 by auto
  have P4: "¬ Col A C D"
    using assms(3) col124__nos by auto
  have P5: "¬ Col B C D"
    using assms(2) one_side_not_col124 by auto
  have P6: "¬ Col A B D"
    using assms(1) one_side_not_col124 by auto
  {
    assume "E = B"
    hence "B A C LtA B D C"
      using P2 P3 bet_col by blast
  }
  {
    assume P7: "B Out E D"
    have P8: "A ≠ E"
      using P6 P7 not_col_permutation_4 out_col by blast
    have P9: "C ≠ E"
      using P5 P7 out_col by blast
    have P10: "B A C LtA B E C"
    proof -
      have P10A: "¬ Col E A B"
        by (metis Col_def P2 P3 P8 col_transitivity_1)
      hence P10B: "E B A LtA B E C"
        using P2 P9 l11_41_aux Tarski_neutral_dimensionless_axioms by fastforce
      have P10C: "E A B LtA B E C"
        using P2 P9 P10A l11_41 by auto
      have P11: "E A B CongA B A C"
      proof -
        have P11A: "A Out B B"
          using assms(2) os_distincts out_trivial by auto
        have "A Out C E"
          using P2 P8 bet_out l6_6 by auto
        thus ?thesis
          using P11A conga_right_comm out2__conga by blast
      qed
      have P12: "B E C CongA B E C"
        by (metis Col_def P2 P3 P9 conga_refl)
      thus ?thesis
        using P11 P10C conga_preserves_lta by auto
    qed
    have "B E C LtA B D C"
    proof -
      have U1: "E Out D B"
        by (metis Bet_cases P2 P8 assms(3) bet_out_1 col123__nos not_bet_out one_side_chara
            one_side_reflexivity out_col)
      have U2: "D ≠ E"
        using P2 P4 bet_col not_col_permutation_5 by blast
      have U3: "¬ Col D E C"
        by (metis Col_def P2 P4 P9 col_transitivity_1)
      have U4: "Bet E D B"
        by (simp add: P7 U1 out2__bet)
      have "D C E LtA C D B"
        using P5 U3 U4 l11_41_aux not_col_distincts by blast
      have U5: "D E C LtA C D B"
        using P7 U4 U3 l11_41 out_diff2 by auto
      have "D E C CongA B E C"
        by (simp add: P9 U1 l6_6 out2__conga out_trivial)
      thus ?thesis
        by (metis U5 conga_preserves_lta conga_pseudo_refl lta_distincts)
    qed
    hence "B A C LtA B D C"
      using P10 lta_trans by blast
  }
  thus ?thesis
    using P2 ‹E = B ⟹ B A C LtA B D C› by blast
qed

(** GEOCOQ **)
(** This is Theorem 18.17 from Martin *)

lemma bet_le__lt:
  assumes "Bet A D B" and
    "A ≠ D" and
    "D ≠ B" and
    "A C Le B C"
  shows "D C Lt B C"
proof -
  have P1: "A ≠ B"
    using assms(1) assms(2) between_identity by blast
  have "C D Lt C B"
  proof cases
    assume P3: "Col A B C"
    thus ?thesis
    proof cases
      assume "Bet C D B"
      thus ?thesis
        by (simp add: assms(3) bet__lt1213)
    next
      assume "¬ Bet C D B"
      hence "D Out C B"
        by (metis Out_def P1 P3 assms(1) col_transitivity_2 not_col_permutation_3 
            not_out_bet out_col)
      have "¬ Bet A B C" 
        by (meson P1 bet_le_eq assms(4))
      have "B ≠ C" 
        using ‹¬ Bet A B C› assms(1) assms(2) l5_1 by blast
      have "Bet B C A" 
        using Col_def P3 ‹¬ Bet A B C› ‹¬ Bet C D B› assms(1) 
          between_inner_transitivity outer_transitivity_between2 by blast
      obtain C' where "C Midpoint A C'" 
        using symmetric_point_construction by blast
      have "Bet C C' B" 
      proof -
        have "C Out C' B"        
        proof -
          have "C' ≠ C" 
            by (metis ‹C Midpoint A C'› ‹¬ Bet C D B› assms(1) midpoint_not_midpoint)
          moreover have "A ≠ C" 
            using ‹¬ Bet C D B› assms(1) by auto
          moreover have "Bet C' C A" 
            by (metis midpoint_bet ‹C Midpoint A C'› between_symmetry)
          ultimately show ?thesis
            using ‹B ≠ C› ‹Bet B C A› l6_2 by blast
        qed
        moreover have "C C' Le C B" 
          by (metis cong_reflexivity l5_6 le_right_comm midpoint_cong 
              ‹C Midpoint A C'› assms(4))
        ultimately show ?thesis 
          using l6_13_1 by blast
      qed
      thus ?thesis 
        by (metis bet__lt1213 l6_2 l6_6 le3456_lt__lt le_comm not_bet_distincts  
            ‹D Out C B› ‹¬ Bet C D B› assms(1) assms(2) assms(4) between_symmetry)
    qed
  next
    assume Q0A: "¬ Col A B C"
    hence Q0B: "¬ Col B C D"
      by (meson Col_def assms(1) assms(3) col_transitivity_2)
    have "C B D LtA C D B"
    proof -
      have Q1: "B Out C C"
        using Q0A not_col_distincts out_trivial by force
      have Q2: "B Out A D"
        using Out_cases assms(1) assms(3) bet_out_1 by blast
      have Q3: "A Out C C"
        by (metis Q0A col_trivial_3 out_trivial)
      have Q4: "A Out B B"
        using P1 out_trivial by auto
      have "C B A LeA C A B"
        using Col_perm Le_cases Q0A assms(4) l11_44_2bis by blast
      hence T9: "C B D LeA C A B"
        using Q1 Q2 Q3 Q4 lea_out4__lea by blast
      have "C A B LtA C D B"
      proof -
        have U2: "¬ Col D A C"
          using Q0B assms(1) assms(2) bet_col col_transitivity_2 not_col_permutation_3 
            not_col_permutation_4 by blast
        have U3: "D ≠ C"
          using Q0B col_trivial_2 by blast
        have U4: "D C A LtA C D B"
          using U2 assms(1) assms(3) l11_41_aux by auto
        have U5: "D A C LtA C D B"
          by (simp add: U2 assms(1) assms(3) l11_41)
        have "A Out B D"
          using Out_def P1 assms(1) assms(2) by auto
        hence "D A C CongA C A B"
          using Q3 conga_right_comm out2__conga by blast
        thus ?thesis
          by (metis U5 U3 assms(3) conga_preserves_lta conga_refl)
      qed
      thus ?thesis
        using T9 lea123456_lta__lta by blast
    qed
    thus ?thesis
      by (simp add: l11_44_2_b)
  qed
  thus ?thesis
    using Lt_cases by auto
qed

lemma cong2__ncol:
  assumes "A ≠ B" and
    "B ≠ C" and
    "A ≠ C" and
    "Cong A P B P" and
    "Cong A P C P"
  shows "¬ Col A B C"
proof -
  have "Cong B P C P"
    using assms(4) assms(5) cong_inner_transitivity by blast
  thus ?thesis using bet_le__lt
    by (metis assms(1) assms(2) assms(3) assms(4) assms(5) cong__le cong__nlt 
        lt__nle not_col_permutation_5 third_point)
qed

lemma cong4_cop2__eq:
  assumes "A ≠ B" and
    "B ≠ C" and
    "A ≠ C" and
    "Cong A P B P" and
    "Cong A P C P" and
    "Coplanar A B C P" and
    "Cong A Q B Q" and
    "Cong A Q C Q" and
    "Coplanar A B C Q"
  shows "P = Q"
proof -
  have P1: "¬ Col A B C"
    using assms(1) assms(2) assms(3) assms(4) assms(5) cong2__ncol by auto
  {
    assume P2: "P ≠ Q"
    have P3: "∀ R. Col P Q R ⟶ (Cong A R B R ∧ Cong A R C R)"
      using P2 assms(4) assms(5) assms(7) assms(8) l4_17 not_cong_4321 by blast
    obtain D where P4: "D Midpoint A B"
      using midpoint_existence by auto
    have P5: "Coplanar A B C D"
      using P4 coplanar_perm_9 midpoint__coplanar by blast
    have P6: "Col P Q D"
    proof -
      have P6A: "Coplanar P Q D A"
        using P1 P5 assms(6) assms(9) coplanar_pseudo_trans ncop_distincts by blast
      hence P6B: "Coplanar P Q D B"
        by (metis P4 col_cop__cop midpoint_col midpoint_distinct_1)
      have P6D: "Cong P A P B"
        using assms(4) not_cong_2143 by blast
      have P6E: "Cong Q A Q B"
        using assms(7) not_cong_2143 by blast
      have "Cong D A D B"
        using Midpoint_def P4 not_cong_2134 by blast
      thus ?thesis using cong3_cop2__col P6A P6B assms(1) P6D P6E by blast
    qed
    obtain R1 where P7: "P ≠ R1 ∧ Q ≠ R1 ∧ D ≠ R1 ∧ Col P Q R1"
      using P6 diff_col_ex3 by blast
    obtain R2 where P8: "Bet R1 D R2 ∧ Cong D R2 R1 D"
      using segment_construction by blast
    have P9: "Col P Q R2"
      by (metis P6 P7 P8 bet_col colx)
    have P9A: "Cong R1 A R1 B"
      using P3 P7 not_cong_2143 by blast
    hence "Per R1 D A"
      using P4 Per_def by auto
    hence "Per A D R1" using l8_2 by blast
    have P10: "Cong A R1 A R2"
    proof -
      have f1: "Bet R2 D R1 ∨Bet R1 R2 D"
        by (metis Col_def P7 P8 between_equality not_col_permutation_5)
      have f2: "Cong B R1 A R1"
        using Cong_perm ‹Cong R1 A R1 B› by blast
      have "Cong B R1 A R2 ∨ Bet R1 R2 D"
        using f1 Cong_perm Midpoint_def P4 P8 l7_13 by blast
      thus ?thesis
        using f2 P8 bet_cong_eq cong_inner_transitivity by blast
    qed
    have "Col A B C"
    proof -
      have P11: "Cong B R1 B R2"
        by (metis Cong_perm P10 P3 P9 P9A cong_inner_transitivity)
      have P12: "Cong C R1 C R2"
        using P10 P3 P7 P9 cong_inner_transitivity by blast
      have P12A: "Coplanar A B C R1"
        using P2 P7 assms(6) assms(9) col_cop2__cop by blast
      have P12B: "Coplanar A B C R2"
        using P2 P9 assms(6) assms(9) col_cop2__cop by blast
      have "R1 ≠ R2"
        using P7 P8 between_identity by blast
      thus ?thesis
        using P10 P11 P12A P12B P12 cong3_cop2__col by blast
    qed
    hence False
      by (simp add: P1)
  }
  thus ?thesis by auto
qed

lemma t18_18_aux:
  assumes "Cong A B D E" and
    "Cong A C D F" and
    "F D E LtA C A B" and
    "¬ Col A B C" and
    "¬ Col D E F" and
    "D F Le D E"
  shows "E F Lt B C"
proof -
  obtain G0 where P1: "C A B CongA F D G0 ∧ F D OS G0 E"
    using angle_construction_1 assms(4) assms(5) not_col_permutation_2 by blast
  hence P2: "¬ Col F D G0"
    using col123__nos by auto
  then obtain G where P3: "D Out G0 G ∧ Cong D G A B"
    by (metis assms(4) bet_col between_trivial2 col_trivial_2 segment_construction_3)
  have P4: "C A B CongA F D G"
  proof -
    have P4B: "A Out C C"
      by (metis assms(4) col_trivial_3 out_trivial)
    have P4C: "A Out B B"
      by (metis assms(4) col_trivial_1 out_trivial)
    have P4D: "D Out F F"
      using P2 not_col_distincts out_trivial by blast
    have "D Out G G0"
      by (simp add: P3 l6_6)
    thus ?thesis using P1 P4B P4C P4D
      using l11_10 by blast
  qed
  have "D Out G G0"
    by (simp add: P3 l6_6)
  hence "D F OS G G0"
    using P2 not_col_permutation_4 out_one_side by blast
  hence "F D OS G G0"
    by (simp add: invert_one_side)
  hence P5: "F D OS G E"
    using P1 one_side_transitivity by blast
  have P6: "¬ Col F D G"
    by (meson P5 one_side_not_col123)
  have P7: "Cong C B F G"
    using P3 P4 assms(2) cong2_conga_cong cong_commutativity cong_symmetry by blast
  have P8: "F E Lt F G"
  proof -
    have P9: "F D E LtA F D G"
      by (metis P4 assms(3) assms(5) col_trivial_1 col_trivial_3 
          conga_preserves_lta conga_refl)
    have P10: "Cong D G D E"
      using P3 assms(1) cong_transitivity by blast
    {
      assume P11: "Col E F G"
      have P12: "F D E LeA F D G"
        by (simp add: P9 lta__lea)
      have P13: "¬ F D E CongA F D G"
        using P9 not_lta_and_conga by blast
      have "F D E CongA F D G"
      proof -
        have "F Out E G"
          using Col_cases P11 P5 col_one_side_out l6_6 by blast
        hence "E F D CongA G F D"
          by (metis assms(5) conga_os__out conga_refl l6_6 not_col_distincts 
              one_side_reflexivity out2__conga)
        thus ?thesis
          by (meson P10 assms(2) assms(6) cong_4321 cong_inner_transitivity l11_52 le_comm)
      qed
      hence "False"
        using P13 by blast
    }
    hence P15: "¬ Col E F G" by auto
    {
      assume P20: "Col D E G"
      have P21: "F D E LeA F D G"
        by (simp add: P9 lta__lea)
      have P22: "¬ F D E CongA F D G"
        using P9 not_lta_and_conga by blast
      have "F D E CongA F D G"
      proof -
        have "D Out E G"
          by (meson Out_cases P5 P20 col_one_side_out invert_one_side not_col_permutation_5)
        thus ?thesis
          using P10 P15 ‹D Out G G0› cong_inner_transitivity l6_11_uniqueness 
            l6_7 not_col_distincts by blast
      qed
      hence "False"
        by (simp add: P22)
    }
    hence P16: "¬ Col D E G" by auto
    have P17: "E InAngle F D G"
      using lea_in_angle by (simp add: P5 P9 lta__lea)
    then obtain H where P18: "Bet F H G ∧ (H = D ∨ D Out H E)"
      using InAngle_def by auto
    {
      assume "H = D"
      hence "F G E LtA F E G"
        using P18 P6 bet_col by blast
    }
    {
      assume P19: "D Out H E"
      have P20: "H ≠ F"
        using Out_cases P19 assms(5) out_col by blast
      have P21: "H ≠ G"
        using P19 P16 l6_6 out_col by blast
      have "F D Le G D"
        using P10 assms(6) cong_pseudo_reflexivity l5_6 not_cong_4312 by blast
      hence "H D Lt G D"
        using P18 P20 P21 bet_le__lt by blast
      hence P22: "D H Lt D E"
        using Lt_cases P10 cong2_lt__lt cong_reflexivity by blast
      hence P23: "D H Le D E ∧ ¬ Cong D H D E"
        using Lt_def by blast
      have P24: "H ≠ E"
        using P23 cong_reflexivity by blast
      have P25: "Bet D H E"
        by (simp add: P19 P23 l6_13_1)
      have P26: "E G OS F D"
        by (metis InAngle_def P15 P16 P18 P25 bet_out_1 between_symmetry 
            in_angle_one_side not_col_distincts not_col_permutation_1)
      have "F G E LtA F E G"
      proof -
        have P27: "F G E LtA D E G"
        proof -
          have P28: "D G E CongA D E G"
            by (metis P10 P16 l11_44_1_a not_col_distincts)
          have "F G E LtA D G E"
          proof -
            have P29: "F G E LeA D G E"
              by (metis OS_def P17 P26 P5 TS_def in_angle_one_side inangle__lea_1 
                  invert_one_side l11_24 os2__inangle)
            {
              assume "F G E CongA D G E"
              hence "E G F CongA E G D"
                by (simp add: conga_comm)
              hence "G Out F D"
                using P26 conga_os__out by auto
              hence "False"
                using P6 not_col_permutation_2 out_col by blast
            }
            hence "¬ F G E CongA D G E" by auto
            thus ?thesis
              by (simp add: LtA_def P29)
          qed
          thus ?thesis
            by (metis P28 P6 col_trivial_3 conga_preserves_lta conga_refl)
        qed
        have "G E D LtA G E F"
        proof -
          have P30: "G E D LeA G E F"
          proof -
            have P31: "D InAngle G E F"
              by (simp add: P16 P17 P26 assms(5) in_angle_two_sides l11_24 
                  not_col_permutation_5 os_ts__inangle)
            have "G E D CongA G E D"
              by (metis P16 col_trivial_1 col_trivial_2 conga_refl)
            thus ?thesis
              using P31 inangle__lea by auto
          qed
          have "¬ G E D CongA G E F"
            by (metis OS_def P26 P5 TS_def conga_os__out invert_one_side out_col)
          thus ?thesis
            by (simp add: LtA_def P30)
        qed
        hence "D E G LtA F E G"
          using lta_comm by blast
        thus ?thesis
          using P27 lta_trans by blast
      qed
    }
    hence "F G E LtA F E G"
      using P18 ‹H = D ⟹ F G E LtA F E G› by blast
    thus ?thesis
      by (simp add: l11_44_2_b)
  qed
  hence "E F Lt F G"
    using lt_left_comm by blast
  thus ?thesis
    using P7 cong2_lt__lt cong_pseudo_reflexivity not_cong_4312 by blast
qed

lemma t18_18:
  assumes "Cong A B D E" and
    "Cong A C D F" and
    "F D E LtA C A B"
  shows "E F Lt B C"
proof -
  have P1: "F ≠ D"
    using assms(3) lta_distincts by blast
  have P2: "E ≠ D"
    using assms(3) lta_distincts by blast
  have P3: "C ≠ A"
    using assms(3) lta_distincts by auto
  have P4: "B ≠ A"
    using assms(3) lta_distincts by blast
  {
    assume P6: "Col A B C"
    {
      assume P7: "Bet B A C"
      obtain C' where P8:"Bet E D C' ∧ Cong D C' A C"
        using segment_construction by blast
      have P9: "Cong E F E F"
        by (simp add: cong_reflexivity)
      have P10: "Cong E C' B C"
        using P7 P8 assms(1) l2_11_b not_cong_4321 by blast
      have "E F Lt E C'"
      proof -
        have P11: "Cong D F D C'"
          using P8 assms(2) cong_transitivity not_cong_3412 by blast
        have "¬ Bet E D F"
          using Bet_perm Col_def assms(3) col_lta__out not_bet_and_out by blast
        thus ?thesis
          using P11 P8 triangle_strict_inequality by blast
      qed
      hence "E F Lt B C"
        using P9 P10 cong2_lt__lt by blast
    }
    {
      assume "¬ Bet B A C"
      hence "E F Lt B C"
        using P6 assms(3) between_symmetry col_lta__bet col_permutation_2 by blast
    }
    hence "E F Lt B C"
      using ‹Bet B A C ⟹ E F Lt B C› by auto
  }
  {
    assume P12: "¬ Col A B C"
    {
      assume P13: "Col D E F"
      {
        assume P14: "Bet F D E"
        hence "C A B LeA F D E"
          by (simp add: P1 P2 P3 P4 l11_31_2)
        hence "F D E LtA F D E"
          using assms(3) lea__nlta by auto
        hence "False"
          by (simp add: nlta)
        hence "E F Lt B C" by auto
      }
      {
        assume "¬ Bet F D E"
        hence P16: "D Out F E"
          using P13 not_col_permutation_1 not_out_bet by blast
        obtain F' where P17: "A Out B F' ∧ Cong A F' A C"
          using P3 P4 segment_construction_3 by fastforce
        hence P18: "B F' Lt B C"
          by (meson P12 triangle_strict_reverse_inequality not_cong_3412 out_col)
        have "Cong B F' E F"
          by (meson Out_cases P16 P17 assms(1) assms(2) cong_transitivity out_cong_cong)
        hence "E F Lt B C"
          using P18 cong2_lt__lt cong_reflexivity by blast
      }
      hence "E F Lt B C"
        using ‹Bet F D E ⟹ E F Lt B C› by blast
    }
    {
      assume P20: "¬ Col D E F"
      {
        assume "D F Le D E"
        hence "E F Lt B C"
          by (meson P12 t18_18_aux P20 assms(1) assms(2) assms(3))
      }
      {
        assume "D E Le D F"
        hence "E F Lt B C"
          by (meson P12 P20 lta_comm t18_18_aux assms(1) assms(2) assms(3) lt_comm 
              not_col_permutation_5)
      }
      hence "E F Lt B C"
        using ‹D F Le D E ⟹ E F Lt B C› local.le_cases by blast
    }
    hence "E F Lt B C"
      using ‹Col D E F ⟹ E F Lt B C› by blast
  }
  thus ?thesis
    using ‹Col A B C ⟹ E F Lt B C› by auto
qed

lemma t18_19:
  assumes "A ≠ B" and
    "A ≠ C" and
    "Cong A B D E" and
    "Cong A C D F" and
    "E F Lt B C"
  shows "F D E LtA C A B"
proof -
  {
    assume P1: "C A B LeA F D E"
    {
      assume "C A B CongA F D E"
      hence "False"
        using Cong_perm assms(3) assms(4) assms(5) cong__nlt l11_49 by blast
    }
    {
      assume P2: "¬ C A B CongA F D E"
      hence "C A B LtA F E D"
        by (metis P1 assms(3) assms(4) assms(5) cong_symmetry lea_distincts 
            lta__nlea not_and_lt or_lta2_conga t18_18)
      hence "B C Lt E F"
        by (metis P1 P2 assms(3) assms(4) cong_symmetry lta__nlea lta_distincts 
            or_lta2_conga t18_18)
      hence "False"
        using assms(5) not_and_lt by auto
    }
    hence "False"
      using ‹C A B CongA F D E ⟹ False› by auto
  }
  hence "¬ C A B LeA F D E" by auto
  thus ?thesis
    using assms(1) assms(2) assms(3) assms(4) cong_identity nlea__lta by blast
qed

lemma acute_trivial:
  assumes "A ≠ B"
  shows "Acute A B A"
  by (metis acute_distincts angle_partition assms l11_43)

lemma acute_not_per:
  assumes "Acute A B C"
  shows "¬ Per A B C"
proof -
  obtain A' B' C' where "Per A' B' C' ∧ A B C LtA A' B' C'"
    using Acute_def assms by auto
  thus ?thesis
    using acute_distincts acute_per__lta assms nlta by fastforce
qed

lemma angle_bisector:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "∃ P. (P InAngle A B C ∧ P B A CongA P B C)"
proof cases
  assume P1: "Col A B C"
  thus ?thesis
  proof cases
    assume P2: "Bet A B C"
    then obtain Q where P3: "¬ Col A B Q"
      using assms(1) not_col_exists by auto
    then obtain P where P4: "A B Perp P B ∧ A B OS Q P"
      using P1 l10_15 os_distincts by blast
    hence P5: "P InAngle A B C"
      by (metis P2 assms(2) in_angle_line os_distincts)
    have "P B A CongA P B C"
    proof -
      have P9: "P ≠ B"
        using P4 os_distincts by blast
      have "Per P B A"
        by (simp add: P4 Perp_perm perp_per_2)
      thus ?thesis
        using P2 assms(1) assms(2) P9 l11_18_1 by auto
    qed
    thus ?thesis
      using P5 by auto
  next
    assume T1: "¬ Bet A B C"
    hence T2: "B Out A C"
      by (simp add: P1 l6_4_2)
    have T3: "C InAngle A B C"
      by (simp add: assms(1) assms(2) inangle3123)
    have "C B A CongA C B C"
      using T2 between_trivial2 l6_6 out2__conga out2_bet_out by blast
    thus ?thesis
      using T3 by auto
  qed
next
  assume T4: "¬ Col A B C"
  obtain C0 where T5: "B Out C0 C ∧ Cong B C0 B A"
    using assms(1) assms(2) l6_11_existence by fastforce
  obtain P where T6: "P Midpoint A C0"
    using midpoint_existence by auto
  have T6A: "¬ Col A B C0"
    by (metis T4 T5 col3 l6_3_1 not_col_distincts out_col)
  have T6B: "P ≠ B"
    using Col_def Midpoint_def T6 T6A by auto
  have T6D: "P ≠ A"
    using T6 T6A is_midpoint_id not_col_distincts by blast
  have "P InAngle A B C0"
    using InAngle_def T5 T6 T6B assms(1) l6_3_1 midpoint_bet out_trivial by fastforce
  hence T7: "P InAngle A B C"
    using T5 T6B in_angle_trans2 l11_24 out341__inangle by blast
  have T8: "(P = B) ∨ B Out P P"
    using out_trivial by auto
  have T9: "B Out A A"
    by (simp add: assms(1) out_trivial)
  {
    assume T9A: "B Out P P"
    have "P B A CongA P B C0 ∧ B P A CongA B P C0 ∧ P A B CongA P C0 B"
    proof -
      have T9B: "Cong B P B P"
        by (simp add: cong_reflexivity)
      have T9C: "Cong B A B C0"
        using Cong_perm T5 by blast
      have "Cong P A P C0"
        using Midpoint_def T6 not_cong_2134 by blast
      thus ?thesis using l11_51 T6B assms(1) T9B T9C T6D by presburger
    qed
    hence "P B A CongA P B C0" by auto
    hence "P B A CongA P B C" using l11_10 T9A T9
      by (meson T5 l6_6)
    hence  "∃ P. (P InAngle A B C ∧ P B A CongA P B C)"
      using T7 by auto
  }
  thus ?thesis
    using T6B T8 by blast
qed

lemma reflectl__conga:
  assumes "A ≠ B" and
    "B ≠ P" and
    "P P' ReflectL A B"
  shows "A B P CongA A B P'"
proof -
  obtain A' where P1: "A' Midpoint P' P ∧ Col A B A' ∧ (A B Perp P' P ∨ P = P')"
    using ReflectL_def assms(3) by auto
  {
    assume P2: "A B Perp P' P"
    hence P3: "P ≠ P'"
      using perp_not_eq_2 by blast
    hence P4: "A' ≠ P'"
      using P1 is_midpoint_id by blast
    have P5: "A' ≠ P"
      using P1 P3 is_midpoint_id_2 by auto
    have  "A B P CongA A B P'"
    proof cases
      assume P6: "A' = B"
      hence P8: "B ≠ P'"
        using P4 by auto
      have P9: "Per A B P"
        using P1 P3 P6 Perp_cases col_transitivity_2 midpoint_col midpoint_distinct_1
          not_col_permutation_2 perp_col2_bis perp_per_2 by metis
      have "Per A B P'" 
        by (metis P1 P6 P9 midpoint_col assms(2) not_col_permutation_5 per_col)
      thus ?thesis
        using l11_16 P4 P5 P6 P9 assms(1) by auto
    next
      assume T1: "A' ≠ B"
      have T2: "B A' P CongA B A' P'"
      proof -
        have T2A: "Cong B P B P'"
          using assms(3) col_trivial_2 is_image_spec_col_cong l10_4_spec not_cong_4321 
          by blast
        hence T2B: "A' B P CongA A' B P'"
          by (metis Cong_perm Midpoint_def P1 P5 T1 l11_51 assms(2) cong_reflexivity)
        have "A' P B CongA A' P' B"
          by (simp add: P5 T2A T2B cong_reflexivity conga_comm l11_49)
        thus ?thesis
          using P5 T2A T2B cong_reflexivity l11_49 by blast
      qed
      have T3: "Cong A' B A' B"
        by (simp add: cong_reflexivity)
      have "Cong A' P A' P'"
        using Midpoint_def P1 not_cong_4312 by blast
      hence T4: "A' B P CongA A' B P' ∧ A' P B CongA A' P' B" using l11_49
        using assms(2) T2 T3 by blast
      show ?thesis
      proof cases
        assume "Bet A' B A"
        thus ?thesis
          using T4 assms(1) l11_13 by blast
      next
        assume "¬ Bet A' B A"
        hence T5: "B Out A' A"
          using P1 not_col_permutation_3 or_bet_out by blast
        have T6: "B ≠ P'"
          using T4 conga_distinct by blast
        have T8: "B Out A A'"
          by (simp add: T5 l6_6)
        have T9: "B Out P P"
          using assms(2) out_trivial by auto
        have "B Out P' P'"
          using T6 out_trivial by auto
        thus ?thesis
          using l11_10 T4 T8 T9 by blast
      qed
    qed
  }
  {
    assume "P = P'"
    hence "A B P CongA A B P'"
      using assms(1) assms(2) conga_refl by auto
  }
  thus ?thesis
    using P1 ‹A B Perp P' P ⟹ A B P CongA A B P'› by blast
qed

lemma conga_cop_out_reflectl__out:
  assumes "¬ B Out A C" and
    "Coplanar A B C P" and
    "P B A CongA P B C" and
    "B Out A T" and
    "T T' ReflectL B P"
  shows "B Out C T'"
proof -
  have P1: "P B T CongA P B T'"
    by (metis assms(3) assms(4) assms(5) conga_distinct is_image_spec_rev 
        out_distinct reflectl__conga)
  have P2: "T T' Reflect B P"
    by (metis P1 assms(5) conga_distinct is_image_is_image_spec)
  have P3: "B ≠ T'"
    using CongA_def P1 by blast
  have P4: "P B C CongA P B T'"
  proof -
    have P5: "P B C CongA P B A"
      by (simp add: assms(3) conga_sym)
    have "P B A CongA P B T'"
    proof -
      have P7: "B Out P P"
        using assms(3) conga_diff45 out_trivial by blast
      have P8: "B Out A T"
        by (simp add: assms(4))
      have "B Out T' T'"
        using P3 out_trivial by auto
      thus ?thesis
        using P1 P7 P8 l11_10 by blast
    qed
    thus ?thesis
      using P5 not_conga by blast
  qed
  have "P B OS C T'"
  proof -
    have P9: "P B TS A C"
      using assms(1) assms(2) assms(3) conga_cop__or_out_ts coplanar_perm_20 by blast
    hence "T ≠ T'"
      by (metis Col_perm P2 P3 TS_def assms(4) col_transitivity_2 l10_8 out_col)
    hence "P B TS T T'"
      by (metis P2 P4 conga_diff45 invert_two_sides l10_14)
    hence "P B TS A T'"
      using assms(4) col_trivial_2 out_two_sides_two_sides by blast
    thus ?thesis
      using OS_def P9 l9_2 by blast
  qed
  thus ?thesis
    using P4 conga_os__out by auto
qed

lemma col_conga_cop_reflectl__col:
  assumes "¬ B Out A C" and
    "Coplanar A B C P" and
    "P B A CongA P B C" and
    "Col B A T" and
    "T T' ReflectL B P"
  shows "Col B C T'"
proof cases
  assume "B = T"
  thus ?thesis
    using assms(5) col_image_spec__eq not_col_distincts by blast
next
  assume P1: "B ≠ T"
  thus ?thesis
  proof cases
    assume "B Out A T"
    thus ?thesis
      using out_col conga_cop_out_reflectl__out assms(1) assms(2) assms(3) assms(5) by blast
  next
    assume P2: "¬ B Out A T"
    obtain A' where P3: "Bet A B A' ∧ Cong B A' A B"
      using segment_construction by blast
    obtain C' where P4: "Bet C B C' ∧ Cong B C' C B"
      using segment_construction by blast
    have P5: "B Out C' T'"
    proof -
      have P6: "¬ B Out A' C'"
        by (metis P3 P4 assms(1) between_symmetry cong_diff_2 l6_2 out_diff1 out_diff2)
      have P7: "Coplanar A' B C' P"
      proof cases
        assume "Col A B C"
        thus ?thesis
          using P3 P4 assms(1) assms(2) assms(3) bet_col bet_neq32__neq 
            col2_cop__cop col_transitivity_1 colx conga_diff2 conga_diff56 l6_4_2 
            ncoplanar_perm_15 not_col_permutation_5 by meson
      next
        assume P7B: "¬ Col A B C"
        have P7C: "Coplanar A B C A'"
          using P3 bet_col ncop__ncols by blast
        have P7D: "Coplanar A B C B"
          using ncop_distincts by blast
        have "Coplanar A B C C'"
          using P4 bet__coplanar coplanar_perm_20 by blast
        thus ?thesis
          using P7B P7C P7D assms(2) coplanar_pseudo_trans by blast
      qed
      have P8: "P B A' CongA P B C'"
        by (metis CongA_def P3 P4 assms(3) cong_reverse_identity conga_left_comm 
            l11_13 not_conga_sym)
      have "Bet A B T" 
        using Col_cases P2 assms(4) not_out_bet by blast
      hence P9: "B Out A' T" 
        by (metis P1 P3 assms(3) between_symmetry cong_reverse_identity conga_distinct l6_3_2)
      thus ?thesis
        using P6 P7 P8 P9 assms(5) conga_cop_out_reflectl__out by blast
    qed
    thus ?thesis
      by (metis Col_def P4 col_transitivity_1 out_col out_diff1)
  qed
qed

lemma conga2_cop2__col:
  assumes "¬ B Out A C" and
    "P B A CongA P B C" and
    "P' B A CongA P' B C" and
    "Coplanar A B P P'" and
    "Coplanar B C P P'"
  shows "Col B P P'"
proof -
  obtain C' where P1: "B Out C' C ∧ Cong B C' B A"
    by (metis assms(2) conga_distinct l6_11_existence)
  have P1A: "Cong P A P C' ∧ (P ≠ A ⟶ (B P A CongA B P C' ∧ B A P CongA B C' P))"
  proof -
    have P2: "P B A CongA P B C'"
    proof -
      have P2A: "B Out P P"
        using assms(2) conga_diff45 out_trivial by auto
      have "B Out A A"
        using assms(2) conga_distinct out_trivial by auto
      thus ?thesis
        using P1 P2A assms(2) l11_10 by blast
    qed
    have P3: "Cong B P B P"
      by (simp add: cong_reflexivity)
    have "Cong B A B C'"
      using Cong_perm P1 by blast
    thus ?thesis using l11_49 P2 cong_reflexivity by blast
  qed
  have P4: "P' B A CongA P' B C'"
  proof -
    have P4A: "B Out P' P'"
      using assms(3) conga_diff1 out_trivial by auto
    have "B Out A A"
      using assms(2) conga_distinct out_trivial by auto
    thus ?thesis
      using P1 P4A assms(3) l11_10 by blast
  qed
  have P5: "Cong B P' B P'"
    by (simp add: cong_reflexivity)
  have P5A: "Cong B A B C'"
    using Cong_perm P1 by blast
  hence P6: "P' ≠ A ⟶ (B P' A CongA B P' C' ∧ B A P' CongA B C' P')"
    using P4 P5 l11_49 by blast
  have P7: "Coplanar B P P' A"
    using assms(4) ncoplanar_perm_18 by blast
  have P8: "Coplanar B P P' C'"
  proof -
    have "Coplanar P P' B C" 
      using assms(5) ncoplanar_perm_16 by blast
    moreover have "B ≠ C" 
      using P1 out_diff2 by blast
    moreover have "Col B C C'" 
      using P1 not_col_permutation_5 out_col by blast
    ultimately show ?thesis 
      using col_cop__cop coplanar_perm_12 by blast
  qed
  have "A ≠ C'"
    using P1 assms(1) by auto
  thus ?thesis
    using P4 P5 P7 P8 P5A P1A cong3_cop2__col l11_49 by blast
qed

lemma conga2_cop2__col_1:
  assumes "¬ Col A B C" and
    "P B A CongA P B C" and
    "P' B A CongA P' B C" and
    "Coplanar A B C P" and
    "Coplanar A B C P'"
  shows "Col B P P'"
proof -
  have P1: "¬ B Out A C"
    using Col_cases assms(1) out_col by blast
  have P2: "Coplanar A B P P'"
    by (meson assms(1) assms(4) assms(5) coplanar_perm_12 coplanar_trans_1 
        not_col_permutation_2)
  have "Coplanar B C P P'"
    using assms(1) assms(4) assms(5) coplanar_trans_1 by auto
  thus ?thesis using P1 P2 conga2_cop2__col assms(2) assms(3) conga2_cop2__col by auto
qed

lemma col_conga__conga:
  assumes "P B A CongA P B C" and
    "Col B P P'" and
    "B ≠ P'"
  shows "P' B A CongA P' B C"
proof cases
  assume "Bet P B P'"
  thus ?thesis
    using assms(1) assms(3) l11_13 by blast
next
  assume "¬ Bet P B P'"
  hence P1: "B Out P P'"
    using Col_cases assms(2) or_bet_out by blast
  hence P2: "B Out P' P"
    by (simp add: l6_6)
  have P3: "B Out A A"
    using CongA_def assms(1) out_trivial by auto
  have "B Out C C"
    using assms(1) conga_diff56 out_trivial by blast
  thus ?thesis
    using P2 P3 assms(1) l11_10 by blast
qed

lemma cop_inangle__ex_col_inangle:
  assumes "¬ B Out A C" and
    "P InAngle A B C" and
    "Coplanar A B C Q"
  shows "∃ R. (R InAngle A B C ∧ P ≠ R ∧ Col P Q R)"
proof -
  have P1: "A ≠ B"
    using assms(2) inangle_distincts by blast
  hence P4: "A ≠ C"
    using assms(1) out_trivial by blast
  have P2: "C ≠ B"
    using assms(2) inangle_distincts by auto
  have P3: "P ≠ B"
    using InAngle_def assms(2) by auto
  thus ?thesis
  proof cases
    assume "P = Q"
    thus ?thesis
      using P1 P2 P4 col_trivial_1 inangle1123 inangle3123 by blast
  next
    assume P5: "P ≠ Q"
    thus ?thesis
    proof cases
      assume P6: "Col B P Q"
      obtain R where P7: "Bet B P R ∧ Cong P R B P"
        using segment_construction by blast
      have P8: "R InAngle A B C"
        using Out_cases P1 P2 P3 P7 assms(2) bet_out l11_25 out_trivial by blast
      have "P ≠ R"
        using P3 P7 cong_reverse_identity by blast
      thus ?thesis
        by (metis P3 P6 P7 P8 bet_col col_transitivity_2)
    next
      assume T1: "¬ Col B P Q"
      thus ?thesis
      proof cases
        assume T2: "Col A B C"
        have T3: "Q InAngle A B C"
          by (metis P1 P2 T1 T2 assms(1) in_angle_line l6_4_2 not_col_distincts)
        thus ?thesis
          using P5 col_trivial_2 by blast
      next
        assume Q1: "¬ Col A B C"
        thus ?thesis
        proof cases
          assume Q2: "Col B C P"
          have Q3: "¬ Col B A P"
            using Col_perm P3 Q1 Q2 col_transitivity_2 by blast
          have Q4: "Coplanar B P Q A"
            using P2 Q2 assms(3) col2_cop__cop col_trivial_3 ncoplanar_perm_22 
              ncoplanar_perm_3 by blast
          have Q5: "Q ≠ P"
            using P5 by auto
          have Q6: "Col B P P"
            using not_col_distincts by blast
          have Q7: "Col Q P P"
            using not_col_distincts by auto
          have "¬ Col B P A"
            using Col_cases Q3 by auto
          then obtain Q0 where P10: "Col Q P Q0 ∧ B P OS A Q0"
            using cop_not_par_same_side Q4 Q5 Q6 Q7 T1 by blast
          have P13: "P ≠ Q0"
            using P10 os_distincts by auto
          {
            assume "B A OS P Q0"
            hence ?thesis
              using P10 P13 assms(2) in_angle_trans not_col_permutation_4 os2__inangle by blast
          }
          {
            assume V1: "¬ B A OS P Q0"
            have "∃ R. Bet P R Q0 ∧ Col P Q R ∧ Col B A R"
            proof cases
              assume V3: "Col B A Q0"
              have "Col P Q Q0"
                using Col_cases P10 by auto
              thus ?thesis
                using V3 between_trivial by auto
            next
              assume V4: "¬ Col B A Q0"
              hence V5: "¬ Col Q0 B A"
                using Col_perm by blast
              have "¬ Col P B A"
                using Col_cases Q3 by blast
              then obtain R where V8: "Col R B A ∧ Bet P R Q0"
                using cop_nos__ts V1 V5
                by (meson P10 TS_def ncoplanar_perm_2 os__coplanar)
              thus ?thesis
                by (metis Col_def P10 P13 col_transitivity_2)
            qed
            then obtain R where V9: "Bet P R Q0 ∧ Col P Q R ∧ Col B A R" by auto
            have V10: "P ≠ R"
              using Q3 V9 by blast
            have "R InAngle A B C"
            proof -
              have W1: "¬ Col B P Q0"
                using P10 P13 T1 col2__eq by blast
              have "P Out Q0 R"
                using V10 V9 bet_out l6_6 by auto
              hence "B P OS Q0 R"
                using Q6 W1 out_one_side_1 by blast
              hence "B P OS A R"
                using P10 one_side_transitivity by blast
              hence "B Out A R"
                using V9 col_one_side_out by auto
              thus ?thesis
                by (simp add: P2 out321__inangle)
            qed
            hence ?thesis
              using V10 V9 by blast
          }
          thus ?thesis
            using ‹B A OS P Q0 ⟹ ∃R. R InAngle A B C ∧ P ≠ R ∧ Col P Q R› by blast
        next
          assume Z1: "¬ Col B C P"
          hence Z6: "¬ Col B P C"
            by (simp add: not_col_permutation_5)
          have Z3: "Col B P P"
            by (simp add: col_trivial_2)
          have Z4: "Col Q P P"
            by (simp add: col_trivial_2)
          have "Coplanar A B C P"
            using Q1 assms(2) inangle__coplanar ncoplanar_perm_18 by blast
          hence "Coplanar B P Q C"
            using Q1 assms(3) coplanar_trans_1 ncoplanar_perm_5 by blast
          then obtain Q0 where Z5: "Col Q P Q0 ∧ B P OS C Q0"
            using cop_not_par_same_side by (metis Z3 Z4 T1 Z6)
          thus ?thesis
          proof cases
            assume "B C OS P Q0"
            thus ?thesis
            proof -
              have "∀p. p InAngle C B A ∨ ¬ p InAngle C B P"
                using assms(2) in_angle_trans l11_24 by blast
              thus ?thesis
                by (metis Col_perm Z5 ‹B C OS P Q0› l11_24 os2__inangle os_distincts)
            qed
          next
            assume Z6: "¬ B C OS P Q0"
            have Z7: "∃ R. Bet P R Q0 ∧ Col P Q R ∧ Col B C R"
            proof cases
              assume "Col B C Q0"
              thus ?thesis
                using Col_def Col_perm Z5 between_trivial by blast
            next
              assume Z8: "¬ Col B C Q0"
              have "∃ R. Col R B C ∧ Bet P R Q0"
              proof -
                have Z10: "Coplanar B C P Q0"
                  using Z5 ncoplanar_perm_2 os__coplanar by blast
                have Z11: "¬ Col P B C"
                  using Col_cases Z1 by blast
                have "¬ Col Q0 B C"
                  using Col_perm Z8 by blast
                thus ?thesis
                  using cop_nos__ts Z6 Z10 Z11 by (simp add: TS_def)
              qed
              then obtain R where "Col R B C ∧ Bet P R Q0" by blast
              thus ?thesis
                using Z5 bet_col col2__eq col_permutation_1 os_distincts by metis
            qed
            then obtain R where Z12: "Bet P R Q0 ∧ Col P Q R ∧ Col B C R" by blast
            have Z13: "P ≠ R"
              using Z1 Z12 by auto
            have Z14: "¬ Col B P Q0"
              using Z5 one_side_not_col124 by blast
            have "P Out Q0 R"
              using Z12 Z13 bet_out l6_6 by auto
            hence "B P OS Q0 R"
              using Z14 Z3 out_one_side_1 by blast
            hence "B P OS C R"
              using Z5 one_side_transitivity by blast
            hence "B Out C R"
              using Z12 col_one_side_out by blast
            hence "R InAngle A B C"
              using P1 out341__inangle by auto
            thus ?thesis
              using Z12 Z13 by auto
          qed
        qed
      qed
    qed
  qed
qed

lemma col_inangle2__out:
  assumes "¬ Bet A B C" and
    "P InAngle A B C" and
    "Q InAngle A B C" and
    "Col B P Q"
  shows "B Out P Q"
proof cases
  assume "Col A B C"
  thus ?thesis
    by (meson assms(1) assms(2) assms(3) assms(4) bet_in_angle_bet bet_out__bet 
        in_angle_out l6_6 not_col_permutation_4 or_bet_out)
next
  assume P1: "¬ Col A B C"
  thus ?thesis
  proof cases
    assume "Col B A P"
    thus ?thesis
      by (meson assms(1) assms(2) assms(3) assms(4) bet_in_angle_bet bet_out__bet 
          l6_6 not_col_permutation_4 or_bet_out)
  next
    assume P2: "¬ Col B A P"
    have "¬ Col B A Q"
      using P2 assms(3) assms(4) col2__eq col_permutation_4 inangle_distincts by blast
    hence "B A OS P Q"
      using P1 P2 assms(2) assms(3) inangle_one_side invert_one_side 
        not_col_permutation_4 by auto
    thus ?thesis
      using assms(4) col_one_side_out by auto
  qed
qed

lemma inangle2__lea:
  assumes "P InAngle A B C" and
    "Q InAngle A B C"
  shows "P B Q LeA A B C"
proof -
  have P1: "P InAngle C B A"
    by (simp add: assms(1) l11_24)
  have P2: "Q InAngle C B A"
    by (simp add: assms(2) l11_24)
  have P3: "A ≠ B"
    using assms(1) inangle_distincts by auto
  have P4: "C ≠ B"
    using assms(1) inangle_distincts by blast
  have P5: "P ≠ B"
    using assms(1) inangle_distincts by auto
  have P6: "Q ≠ B"
    using assms(2) inangle_distincts by auto
  thus ?thesis
  proof cases
    assume P7: "Col A B C"
    thus ?thesis
    proof cases
      assume "Bet A B C"
      thus ?thesis
        by (simp add: P3 P4 P5 P6 l11_31_2)
    next
      assume "¬ Bet A B C"
      hence "B Out A C"
        using P7 not_out_bet by blast
      hence "B Out P Q"
        using Out_cases assms(1) assms(2) in_angle_out l6_7 by blast
      thus ?thesis
        by (simp add: P3 P4 l11_31_1)
    qed
  next
    assume T1: "¬ Col A B C"
    thus ?thesis
    proof cases
      assume T2: "Col B P Q"
      have "¬ Bet A B C"
        using T1 bet_col by auto
      hence "B Out P Q"
        using T2 assms(1) assms(2) col_inangle2__out by auto
      thus ?thesis
        by (simp add: P3 P4 l11_31_1)
    next
      assume T3: "¬ Col B P Q"
      thus ?thesis
      proof cases
        assume "Col B A P"
        hence "B Out A P"
          using Col_def T1 assms(1) col_in_angle_out by blast
        hence "P B Q CongA A B Q"
          using P6 out2__conga out_trivial by auto
        thus ?thesis
          using LeA_def assms(2) by blast
      next
        assume W0: "¬ Col B A P"
        show ?thesis
        proof cases
          assume "Col B C P"
          hence "B Out C P"
            by (metis P1 P3 T1 bet_out_1 col_in_angle_out out_col)
          thus ?thesis
            using P3 P4 P6 lea_left_comm lea_out4__lea assms(2) 
              inangle__lea_1 out_trivial by meson
        next
          assume W0A: "¬ Col B C P"
          show ?thesis
          proof cases
            assume "Col B A Q"
            hence "B Out A Q"
              using Col_def T1 assms(2) col_in_angle_out by blast
            thus ?thesis
              using P3 P4 P5 lea_left_comm lea_out4__lea assms(1) 
                inangle__lea out_trivial by meson
          next
            assume W0AA: "¬ Col B A Q"
            thus ?thesis
            proof cases
              assume "Col B C Q"
              hence "B Out C Q"
                using Bet_cases P2 T1 bet_col col_in_angle_out by blast
              thus ?thesis
                using P1 P3 P4 P5 lea_comm lea_out4__lea inangle__lea out_trivial by meson
            next
              assume W0B: "¬ Col B C Q"
              have W1: "Coplanar B P A Q"
                by (metis Col_perm T1 assms(1) assms(2) col__coplanar 
                    inangle_one_side ncoplanar_perm_13 os__coplanar)
              have W2: "¬ Col A B P"
                by (simp add: W0 not_col_permutation_4)
              have W3: "¬ Col Q B P"
                using Col_perm T3 by blast
              hence W4: "B P TS A Q ∨ B P OS A Q"
                using cop__one_or_two_sides
                by (simp add: W1 W2)
              {
                assume W4A: "B P TS A Q"
                have "Q InAngle P B C"
                proof -
                  have W5: "P B OS C Q"
                    using OS_def P1 W0 W0A W4A in_angle_two_sides invert_two_sides l9_2 by blast
                  have "C B OS P Q"
                    by (meson P1 P2 T1 W0A W0B inangle_one_side not_col_permutation_3 
                        not_col_permutation_4)
                  thus ?thesis
                    by (simp add: W5 invert_one_side os2__inangle)
                qed
                hence "P B Q LeA A B C"
                  by (meson assms(1) inangle__lea inangle__lea_1 lea_trans)
              }
              {
                assume W6: "B P OS A Q"
                have "B A OS P Q"
                  using Col_perm T1 W2 W0AA assms(1) assms(2) inangle_one_side 
                    invert_one_side by blast
                hence "Q InAngle P B A"
                  by (simp add: W6 os2__inangle)
                hence "P B Q LeA A B C"
                  by (meson P1 inangle__lea inangle__lea_1 lea_right_comm lea_trans)
              }
              thus ?thesis
                using W4 ‹B P TS A Q ⟹ P B Q LeA A B C› by blast
            qed
          qed
        qed
      qed
    qed
  qed
qed

lemma conga_inangle_per__acute:
  assumes "Per A B C" and
    "P InAngle A B C" and
    "P B A CongA P B C"
  shows "Acute A B P"
proof -
  have P1: "¬ Col A B C"
    using assms(1) assms(3) conga_diff2 conga_diff56 l8_9 by blast
  have P2: "A B P LeA A B C"
    by (simp add: assms(2) inangle__lea)
  {
    assume "A B P CongA A B C"
    hence P3: "Per A B P"
      by (meson l11_17 not_conga_sym assms(1))
    have P4: "Coplanar P C A B"
      using assms(2) inangle__coplanar ncoplanar_perm_3 by blast
    have P5: "P ≠ B"
      using assms(2) inangle_distincts by blast
    have "Per C B P"
      using P3 Per_cases assms(3) l11_17 by blast
    hence "False"
      using P1 P3 P4 P5 col_permutation_1 cop_per2__col by blast
  }
  hence "¬ A B P CongA A B C" by auto
  hence "A B P LtA A B C"
    by (simp add: LtA_def P2)
  thus ?thesis
    using Acute_def assms(1) by blast
qed

lemma conga_inangle2_per__acute:
  assumes "Per A B C" and
    "P InAngle A B C" and
    "P B A CongA P B C" and
    "Q InAngle A B C"
  shows "Acute P B Q"
proof -
  have P1: "P InAngle C B A"
    using assms(2) l11_24 by auto
  have P2: "Q InAngle C B A"
    using assms(4) l11_24 by blast
  have P3: "A ≠ B"
    using assms(3) conga_diff2 by auto
  have P5: "P ≠ B"
    using assms(2) inangle_distincts by blast
  have P7: "¬ Col A B C"
    using assms(1) assms(3) conga_distinct l8_9 by blast
  have P8: "Acute A B P"
    using assms(1) assms(2) assms(3) conga_inangle_per__acute by auto
  {
    assume "Col P B A"
    hence "Col P B C"
      using assms(3) col_conga_col by blast
    hence "False"
      using Col_perm P5 P7 ‹Col P B A› col_transitivity_2 by blast
  }
  hence P9: "¬ Col P B A" by auto
  have P10: "¬ Col P B C"
    using ‹Col P B A ⟹ False› assms(3) ncol_conga_ncol by blast
  have P11: "¬ Bet A B C"
    using P7 bet_col by blast
  show ?thesis
  proof cases
    assume "Col B A Q"
    hence "B Out A Q"
      using P11 assms(4) col_in_angle_out by auto
    thus ?thesis
      using Out_cases P5 P8 acute_out2__acute acute_sym out_trivial by blast
  next
    assume S0: "¬ Col B A Q"
    show ?thesis
    proof cases
      assume S1: "Col B C Q"
      hence "B Out C Q"
        using P11 P2 between_symmetry col_in_angle_out by blast
      hence S2: "B Out Q C"
        using l6_6 by blast
      have S3: "B Out P P"
        by (simp add: P5 out_trivial)
      have "B Out A A"
        by (simp add: P3 out_trivial)
      hence "A B P CongA P B Q"
        using S2 conga_left_comm l11_10 S3 assms(3) by blast
      thus ?thesis
        using P8 acute_conga__acute by blast
    next
      assume S4: "¬ Col B C Q"
      show ?thesis
      proof cases
        assume "Col B P Q"
        thus ?thesis
          using out__acute col_inangle2__out P11 assms(2) assms(4) by blast
      next
        assume S5: "¬ Col B P Q"
        have S6: "Coplanar B P A Q"
          by (metis Col_perm P7 assms(2) assms(4) coplanar_trans_1 
              inangle__coplanar ncoplanar_perm_12 ncoplanar_perm_21)
        have S7: "¬ Col A B P"
          using Col_cases P9 by auto
        have "¬ Col Q B P"
          using Col_perm S5 by blast
        hence S8: "B P TS A Q ∨ B P OS A Q"
          using cop__one_or_two_sides S6 S7 by blast
        {
          assume S9: "B P TS A Q"
          have S10: "Acute P B C"
            using P8 acute_conga__acute acute_sym assms(3) by blast
          have "Q InAngle P B C"
          proof -
            have S11: "P B OS C Q"
              by (metis Col_perm OS_def P1 P10 P9 S9 in_angle_two_sides 
                  invert_two_sides l9_2)
            have "C B OS P Q"
              by (meson P1 P10 P2 P7 S4 inangle_one_side not_col_permutation_3 
                  not_col_permutation_4)
            thus ?thesis
              by (simp add: S11 invert_one_side os2__inangle)
          qed
          hence "P B Q LeA P B C"
            by (simp add: inangle__lea)
          hence "Acute P B Q"
            using S10 acute_lea_acute by blast
        }
        {
          assume S12: "B P OS A Q"
          have "B A OS P Q"
            using Col_perm P7 S7 S0 assms(2) assms(4) inangle_one_side 
              invert_one_side by blast
          hence "Q InAngle P B A"
            by (simp add: S12 os2__inangle)
          hence "Q B P LeA P B A"
            by (simp add: P3 P5 inangle1123 inangle2__lea)
          hence "P B Q LeA A B P"
            by (simp add: lea_comm)
          hence "Acute P B Q"
            using P8 acute_lea_acute by blast
        }
        thus ?thesis
          using ‹B P TS A Q ⟹ Acute P B Q› S8 by blast
      qed
    qed
  qed
qed

lemma lta_os__ts:
  assumes (*"¬ Col A O1 P" and*)
    "A O1 P LtA A O1 B" and
    "O1 A OS B P"
  shows "O1 P TS A B"
proof -
  have "A O1 P LeA A O1 B"
    by (simp add: assms(1) lta__lea)
  hence "∃ P0. P0 InAngle A O1 B ∧ A O1 P CongA A O1 P0"
    by (simp add: LeA_def)
  then obtain P' where P1: "P' InAngle A O1 B ∧ A O1 P CongA A O1 P'" by blast
  have P2: "¬ Col A O1 B"
    using assms(2) col123__nos not_col_permutation_4 by blast
  obtain R where P3: "O1 A TS B R ∧ O1 A TS P R"
    using OS_def assms(2) by blast
  {
    assume "Col B O1 P"
    hence "Bet B O1 P"
      by (metis out2__conga assms(1) assms(2) between_trivial col_trivial_2 
          lta_not_conga one_side_chara or_bet_out out_trivial)
    hence "O1 A TS B P"
      using assms(2) col_trivial_1 one_side_chara by blast
    hence P6: "¬ O1 A OS B P"
      using l9_9_bis by auto
    hence "False"
      using P6 assms(2) by auto
  }
  hence P4: "¬ Col B O1 P" by auto
  thus ?thesis
    by (meson P3 assms(1) inangle__lta l9_8_1 not_and_lta not_col_permutation_4 
        os_ts__inangle two_sides_cases)
qed

lemma bet__suppa:
  assumes "A ≠ B" and
    "B ≠ C" and
    "B ≠ A'" and
    "Bet A B A'"
  shows "A B C SuppA C B A'"
proof -
  have "C B A' CongA C B A'"
    using assms(2) assms(3) conga_refl by auto
  thus ?thesis using assms(4) assms(1) SuppA_def by auto
qed

lemma ex_suppa:
  assumes "A ≠ B" and
    "B ≠ C"
  shows "∃ D E F. A B C SuppA D E F"
proof -
  obtain A' where "Bet A B A' ∧ Cong B A' A B"
    using segment_construction by blast
  thus ?thesis
    by (meson assms(1) assms(2) bet__suppa point_construction_different)
qed

lemma suppa_distincts:
  assumes "A B C SuppA D E F"
  shows "A ≠ B ∧ B ≠ C ∧ D ≠ E ∧ E ≠ F"
  using CongA_def SuppA_def assms by auto

lemma suppa_right_comm:
  assumes "A B C SuppA D E F"
  shows "A B C SuppA F E D"
  using SuppA_def assms conga_left_comm by auto

lemma suppa_left_comm:
  assumes "A B C SuppA D E F"
  shows "C B A SuppA D E F"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms by auto
  obtain C' where P2: "Bet C B C' ∧ Cong B C' C B"
    using segment_construction by blast
  hence "C B A' CongA A B C'"
    by (metis Bet_cases P1 SuppA_def assms cong_diff_3 conga_diff45 conga_diff56 
        conga_left_comm l11_14)
  hence "D E F CongA A B C'"
    using P1 conga_trans by blast
  thus ?thesis
    by (metis CongA_def P1 P2 SuppA_def)
qed

lemma suppa_comm:
  assumes "A B C SuppA D E F"
  shows "C B A SuppA F E D"
  using assms suppa_left_comm suppa_right_comm by blast

lemma suppa_sym:
  assumes "A B C SuppA D E F"
  shows "D E F SuppA A B C"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms by auto
  obtain D' where P2: "Bet D E D' ∧ Cong E D' D E"
    using segment_construction by blast
  have "A' B C CongA D E F"
    using P1 conga_right_comm not_conga_sym by blast
  hence "A B C CongA F E D'"
    by (metis P1 P2 conga_right_comm l11_13 suppa_distincts assms between_symmetry 
        cong_diff_3)
  thus ?thesis
    by (metis CongA_def P1 P2 SuppA_def)
qed

lemma conga2_suppa__suppa:
  assumes "A B C CongA A' B' C'" and
    "D E F CongA D' E' F'" and
    "A B C SuppA D E F"
  shows "A' B' C' SuppA D' E' F'"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ D E F CongA C B A0"
    using SuppA_def assms(3) by auto
  hence "A B C SuppA D' E' F'"
    by (metis SuppA_def assms(2) assms(3) conga_sym conga_trans)
  hence P2: "D' E' F' SuppA A B C"
    by (simp add: suppa_sym)
  then obtain D0 where P3: "Bet D' E' D0 ∧ A B C CongA F' E' D0"
    using P2 SuppA_def by auto
  have P5: "A' B' C' CongA F' E' D0"
    using P3 assms(1) not_conga not_conga_sym by blast
  hence "D' E' F' SuppA A' B' C'"
    using P2 P3 SuppA_def by auto
  thus ?thesis
    by (simp add: suppa_sym)
qed

lemma suppa2__conga456:
  assumes "A B C SuppA D E F" and
    "A B C SuppA D' E' F'"
  shows "D E F CongA D' E' F'"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms(1) by auto
  obtain A'' where P2: "Bet A B A'' ∧ D' E' F' CongA C B A''"
    using SuppA_def assms(2) by auto
  have "C B A' CongA C B A''"
  proof -
    have P3: "B Out C C" using P1
      by (simp add: CongA_def out_trivial)
    have "B Out A'' A'" using P1 P2 l6_2
      by (metis assms(1) between_symmetry conga_distinct suppa_distincts)
    thus ?thesis
      by (simp add: P3 out2__conga)
  qed
  hence "C B A' CongA D' E' F'"
    using P2 not_conga not_conga_sym by blast
  thus ?thesis
    using P1 not_conga by blast
qed

lemma suppa2__conga123:
  assumes "A B C SuppA D E F" and
    "A' B' C' SuppA D E F"
  shows "A B C CongA A' B' C'"
  using assms(1) assms(2) suppa2__conga456 suppa_sym by blast

lemma bet_out__suppa:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Bet A B C" and
    "E Out D F"
  shows "A B C SuppA D E F"
proof -
  have "D E F CongA C B C"
    using assms(2) assms(4) l11_21_b out_trivial by auto
  thus ?thesis
    using SuppA_def assms(1) assms(3) by blast
qed

lemma bet_suppa__out:
  assumes "Bet A B C" and
    "A B C SuppA D E F"
  shows "E Out D F"
proof -
  have "A B C SuppA C B C"
    using assms(1) assms(2) bet__suppa suppa_distincts by auto
  hence "C B C CongA D E F"
    using assms(2) suppa2__conga456 by auto
  thus ?thesis
    using eq_conga_out by auto
qed

lemma out_suppa__bet:
  assumes "B Out A C" and
    "A B C SuppA D E F"
  shows "Bet D E F"
proof -
  obtain B' where P1: "Bet A B B' ∧ Cong B B' A B"
    using segment_construction by blast
  have "A B C SuppA A B B'"
    by (metis P1 assms(1) assms(2) bet__suppa bet_cong_eq bet_out__bet 
        suppa_distincts suppa_left_comm)
  hence "A B B' CongA D E F"
    using assms(2) suppa2__conga456 by auto
  thus ?thesis
    using P1 bet_conga__bet by blast
qed

lemma per_suppa__per:
  assumes  "Per A B C" and
    "A B C SuppA D E F"
  shows "Per D E F"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms(2) by auto
  have "Per C B A'"
  proof -
    have P2: "A ≠ B"
      using assms(2) suppa_distincts by auto
    have P3: "Per C B A"
      by (simp add: assms(1) l8_2)
    have "Col B A A'"
      using P1 Col_cases Col_def by blast
    thus ?thesis
      by (metis P2 P3 per_col)
  qed
  thus ?thesis
    using P1 l11_17 not_conga_sym by blast
qed

lemma per2__suppa:
  assumes  "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F" and
    "Per A B C" and
    "Per D E F"
  shows "A B C SuppA D E F"
proof -
  obtain D' E' F' where P1: "A B C SuppA D' E' F'"
    using assms(1) assms(2) ex_suppa by blast
  have "D' E' F' CongA D E F"
    using P1 assms(3) assms(4) assms(5) assms(6) l11_16 per_suppa__per 
      suppa_distincts by blast
  thus ?thesis
    by (meson P1 conga2_suppa__suppa suppa2__conga123)
qed

lemma suppa__per:
  assumes "A B C SuppA A B C"
  shows "Per A B C"
proof -
  obtain A' where P1: "Bet A B A' ∧ A B C CongA C B A'"
    using SuppA_def assms by auto
  hence "C B A CongA C B A'"
    by (simp add: conga_left_comm)
  thus ?thesis
    using P1 Per_perm l11_18_2 by blast
qed

lemma acute_suppa__obtuse:
  assumes "Acute A B C" and
    "A B C SuppA D E F"
  shows "Obtuse D E F"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms(2) by auto
  hence "Obtuse C B A'"
    by (metis obtuse_sym acute_bet__obtuse assms(1) conga_distinct)
  thus ?thesis
    by (meson P1 conga_obtuse__obtuse not_conga_sym)
qed

lemma obtuse_suppa__acute:
  assumes "Obtuse A B C" and
    "A B C SuppA D E F"
  shows "Acute D E F"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms(2) by auto
  hence "Acute C B A'"
    using acute_sym assms(1) bet_obtuse__acute conga_distinct by blast
  thus ?thesis
    using P1 acute_conga__acute not_conga_sym by blast
qed

lemma lea_suppa2__lea:
  assumes "A B C SuppA A' B' C'" and
    "D E F SuppA D' E' F'"
    "A B C LeA D E F"
  shows "D' E' F' LeA A' B' C'"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ A' B' C' CongA C B A0"
    using SuppA_def assms(1) by auto
  obtain D0 where P2: "Bet D E D0 ∧ D' E' F' CongA F E D0"
    using SuppA_def assms(2) by auto
  have "F E D0 LeA C B A0"
  proof -
    have P3: "D0 ≠ E"
      using CongA_def P2 by auto
    have P4: "A0 ≠ B"
      using CongA_def P1 by blast
    have P6: "Bet D0 E D"
      by (simp add: P2 between_symmetry)
    have "Bet A0 B A"
      by (simp add: P1 between_symmetry)
    thus ?thesis
      by (metis P3 P4 P6 assms(3) l11_36_aux2 lea_comm lea_distincts)
  qed
  thus ?thesis
    by (meson P1 P2 l11_30 not_conga_sym)
qed

lemma lta_suppa2__lta:
  assumes "A B C SuppA A' B' C'"
    and "D E F SuppA D' E' F'"
    and "A B C LtA D E F"
  shows "D' E' F' LtA A' B' C'"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ A' B' C' CongA C B A0"
    using SuppA_def assms(1) by auto
  obtain D0 where P2: "Bet D E D0 ∧ D' E' F' CongA F E D0"
    using SuppA_def assms(2) by auto
  have "F E D0 LtA C B A0"
  proof -
    have P5: "A0 ≠ B"
      using CongA_def P1 by blast
    have "D0 ≠ E"
      using CongA_def P2 by auto
    thus ?thesis
      using assms(3) P1 P5 P2 bet2_lta__lta lta_comm by blast
  qed
  thus ?thesis
    using P1 P2 conga_preserves_lta not_conga_sym by blast
qed

lemma suppa_dec:
  "A B C SuppA D E F ∨ ¬ A B C SuppA D E F"
  by simp

lemma acute_one_side_aux:
  assumes "C A OS P B" and
    "Acute A C P" and
    "C A Perp B C"
  shows "C B OS A P"
proof -
  obtain R where T1: "C A TS P R ∧ C A TS B R"
    using OS_def assms(1) by blast
  obtain A' B' C' where P1: "Per A' B' C' ∧ A C P LtA A' B' C'"
    using Acute_def assms(2) by auto
  have P2: "Per A C B"
    by (simp add: assms(3) perp_per_1)
  hence P3: "A' B' C' CongA A C B"
    using P1 assms(1) l11_16 lta_distincts os_distincts by blast
  have P4: "A C P LtA A C B"
    by (metis P2 acute_per__lta assms(1) assms(2) os_distincts)
  {
    assume P4A: "Col P C B"
    have "Per A C P"
    proof -
      have P4B: "C ≠ B"
        using assms(1) os_distincts by blast
      have P4C: "Per A C B"
        by (simp add: P2)
      have "Col C B P"
        using P4A Col_cases by auto
      thus ?thesis using per_col P4B P4C by blast
    qed
    hence "False"
      using acute_not_per assms(2) by auto
  }
  hence P5: "¬ Col P C B" by auto
  have P6: "¬ Col A C P"
    using assms(1) col123__nos not_col_permutation_4 by blast
  have P7: "C B TS A P ∨ C B OS A P"
    using P5 assms(1) not_col_permutation_4 os_ts1324__os two_sides_cases by blast
  {
    assume P8: "C B TS A P"
    then obtain T where P9: "Col T C B ∧ Bet A T P"
      using TS_def by blast
    hence P10: "C ≠ T"
      using Col_def P6 P9 by auto
    have "T InAngle A C P"
      by (meson P4 P5 P8 inangle__lta assms(1) not_and_lta 
          not_col_permutation_3 os_ts__inangle)
    hence "C A OS T P"
      by (metis P10 P9 T1 TS_def col123__nos in_angle_one_side invert_one_side 
          l6_16_1 one_side_reflexivity)
    hence P13: "C A OS T B"
      using assms(1) one_side_transitivity by blast
    have "C B OS A P"
      by (meson P4 lta_os__ts assms(1) one_side_symmetry os_ts1324__os)
  }
  thus ?thesis
    using P7 by blast
qed

lemma acute_one_side_aux0:
  assumes "Col A C P" and
    "Acute A C P" and
    "C A Perp B C"
  shows "C B OS A P"
proof -
  have "Per A C B"
    by (simp add: assms(3) perp_per_1)
  hence P1: "A C P LtA A C B"
    using acute_per__lta acute_distincts assms(2) assms(3) perp_not_eq_2 by fastforce
  have P2: "C Out A P"
    using acute_col__out assms(1) assms(2) by auto
  thus ?thesis
    using Perp_cases assms(3) out_one_side perp_not_col by blast
qed

lemma acute_cop_perp__one_side:
  assumes "Acute A C P" and
    "C A Perp B C" and
    "Coplanar A B C P"
  shows "C B OS A P"
proof cases
  assume "Col A C P"
  thus ?thesis
    by (simp add: acute_one_side_aux0 assms(1) assms(2))
next
  assume P1: "¬ Col A C P"
  have P2: "C A TS P B ∨ C A OS P B"
    using Col_cases P1 assms(2) assms(3) cop_nos__ts coplanar_perm_13 
      perp_not_col by blast
  {
    assume P3: "C A TS P B"
    obtain Bs where P4: "C Midpoint B Bs"
      using symmetric_point_construction by auto
    have "C A TS Bs B"
      by (metis P3 P4 assms(2) bet__ts l9_2 midpoint_bet midpoint_distinct_2 
          perp_not_col ts_distincts)
    hence P6: "C A OS P Bs"
      using P3 l9_8_1 by auto
    have "C Bs Perp A C"
    proof -
      have P6A: "C ≠ Bs"
        using P6 os_distincts by blast
      have "Col C B Bs"
        using Bet_cases Col_def P4 midpoint_bet by blast
      thus ?thesis
        using Perp_cases P6A assms(2) perp_col by blast
    qed
    hence "Bs C Perp C A"
      using Perp_perm by blast
    hence "C A Perp Bs C"
      using Perp_perm by blast
    hence "C B OS A P" using acute_one_side_aux
      by (metis P4 P6 assms(1) assms(2) col_one_side midpoint_col 
          not_col_permutation_5 perp_distinct)
  }
  {
    assume "C A OS P B"
    hence "C B OS A P" using acute_one_side_aux
      using assms(1) assms(2) by blast
  }
  thus ?thesis
    using P2 ‹C A TS P B ⟹ C B OS A P› by auto
qed

lemma acute__not_obtuse:
  assumes "Acute A B C"
  shows "¬ Obtuse A B C"
  using acute_obtuse__lta assms nlta by blast

lemma suma_distincts:
  assumes "A B C D E F SumA G H I"
  shows "A ≠ B ∧ B ≠ C ∧ D ≠ E ∧ E ≠ F ∧ G ≠ H ∧ H ≠ I"
proof -
  obtain J where "C B J CongA D E F ∧ ¬ B C OS A J ∧ Coplanar A B C J ∧ A B J CongA G H I"
    using SumA_def assms by auto
  thus ?thesis
    using CongA_def by blast
qed

lemma trisuma_distincts:
  assumes "A B C TriSumA D E F"
  shows "A ≠ B ∧ B ≠ C ∧ A ≠ C ∧ D ≠ E ∧ E ≠ F"
proof -
  obtain G H I where "A B C B C A SumA G H I ∧ G H I C A B SumA D E F"
    using TriSumA_def assms by auto
  thus ?thesis
    using suma_distincts by blast
qed

lemma ex_suma:
  assumes "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F"
  shows "∃ G H I. A B C D E F SumA G H I"
proof -
  have "∃ I. A B C D E F SumA A B I"
  proof cases
    assume P1: "Col A B C"
    obtain J where P2: "D E F CongA C B J ∧ Coplanar C B J A" 
      using angle_construction_4 assms(2) assms(3) assms(4) by presburger
    have P3: "J ≠ B"
      using CongA_def P2 by blast
    have "¬ B C OS A J"
      by (metis P1 between_trivial2 one_side_chara)
    hence "A B C D E F SumA A B J"
      by (meson P2 P3 SumA_def assms(1) conga_refl ncoplanar_perm_15 not_conga_sym)
    thus ?thesis by blast
  next
    assume T1: "¬ Col A B C"
    show ?thesis
    proof cases
      assume T2: "Col D E F"
      show ?thesis
      proof cases
        assume T3: "Bet D E F"
        obtain J where T4: "B Midpoint C J"
          using symmetric_point_construction by blast
        have "A B C D E F SumA A B J"
        proof -
          have "C B J CongA D E F"
            by (metis T3 T4 assms(2) assms(3) assms(4) conga_line 
                midpoint_bet midpoint_distinct_2)
          moreover have "¬ B C OS A J"
            by (simp add: T4 col124__nos midpoint_col)
          moreover have "Coplanar A B C J"
            using T3 bet__coplanar bet_conga__bet calculation(1) conga_sym 
              ncoplanar_perm_15 by blast
          moreover have "A B J CongA A B J"
            using CongA_def assms(1) calculation(1) conga_refl by auto
          ultimately show ?thesis
            using SumA_def by blast
        qed
        thus ?thesis
          by auto
      next
        assume T5: "¬ Bet D E F"
        have "A B C D E F SumA A B C"
        proof -
          have "E Out D F"
            using T2 T5 l6_4_2 by auto
          hence "C B C CongA D E F"
            using assms(2) l11_21_b out_trivial by auto
          moreover have "¬ B C OS A C"
            using os_distincts by blast
          moreover have "Coplanar A B C C"
            using ncop_distincts by auto
          moreover have "A B C CongA A B C"
            using assms(1) assms(2) conga_refl by auto
          ultimately show ?thesis
            using SumA_def by blast
        qed
        thus ?thesis
          by auto
      qed
    next
      assume T6: "¬ Col D E F"
      then obtain J where T7: "D E F CongA C B J ∧ C B TS J A"
        using T1 ex_conga_ts not_col_permutation_4 not_col_permutation_5 by presburger
      thus ?thesis
      proof -
        have "C B J CongA D E F"
          using T7 not_conga_sym by blast
        moreover have "¬ B C OS A J"
          by (simp add: T7 invert_two_sides l9_2 l9_9)
        moreover have "Coplanar A B C J"
          using T7 ncoplanar_perm_15 ts__coplanar by blast
        moreover have "A B J CongA A B J"
          using T7 assms(1) conga_diff56 conga_refl by blast
        ultimately show ?thesis
          using SumA_def by blast
      qed
    qed
  qed
  thus ?thesis
    by auto
qed

lemma suma2__conga:
  assumes "A B C D E F SumA G H I" and
    "A B C D E F SumA G' H' I'"
  shows "G H I CongA G' H' I'"
proof -
  obtain J where P1: "C B J CongA D E F ∧ ¬ B C OS A J ∧ Coplanar A B C J ∧ A B J CongA G H I"
    using SumA_def assms(1) by blast
  obtain J' where P2: "C B J' CongA D E F ∧ ¬ B C OS A J' ∧ Coplanar A B C J' ∧ 
A B J' CongA G' H' I'"
    using SumA_def assms(2) by blast
  have P3: "C B J CongA C B J'"
  proof -
    have "C B J CongA D E F"
      by (simp add: P1)
    moreover have "D E F CongA C B J'"
      by (simp add: P2 conga_sym)
    ultimately show ?thesis
      using not_conga by blast
  qed
  have P4: "A B J CongA A B J'"
  proof cases
    assume P5: "Col A B C"
    thus ?thesis
    proof cases
      assume P6: "Bet A B C"
      show ?thesis
      proof -
        have "C B J CongA C B J'"
          by (simp add: P3)
        moreover have "Bet C B A"
          by (simp add: P6 between_symmetry)
        moreover have "A ≠ B"
          using assms(1) suma_distincts by blast
        ultimately show ?thesis
          using l11_13 by blast
      qed
    next
      assume P7: "¬ Bet A B C"
      moreover have "B Out A C"
        by (simp add: P5 calculation l6_4_2)
      moreover have "B ≠ J"
        using CongA_def P3 by blast
      then moreover have "B Out J J"
        using out_trivial by auto
      moreover have "B ≠ J'"
        using CongA_def P3 by blast
      then moreover have "B Out J' J'"
        using out_trivial by auto
      ultimately show ?thesis
        using P3 l11_10 by blast
    qed
  next
    assume P8: "¬ Col A B C"
    show ?thesis
    proof cases
      assume P9: "Col D E F"
      have "B Out J' J"
      proof cases
        assume P10: "Bet D E F"
        show ?thesis
        proof -
          have "D E F CongA J' B C"
            using P2 conga_right_comm not_conga_sym by blast
          hence "Bet J' B C"
            using P10 bet_conga__bet by blast
          moreover have "D E F CongA J B C"
            by (simp add: P1 conga_right_comm conga_sym)
          then moreover have "Bet J B C"
            using P10 bet_conga__bet by blast
          ultimately show ?thesis
            by (metis CongA_def P3 l6_2)
        qed
      next
        assume P11: "¬ Bet D E F"
        have P12: "E Out D F"
          by (simp add: P11 P9 l6_4_2)
        show ?thesis
        proof -
          have "B Out J' C"
          proof -
            have "D E F CongA J' B C"
              using P2 conga_right_comm conga_sym by blast
            thus ?thesis
              using l11_21_a P12 by blast
          qed
          moreover have "B Out C J"
            by (metis P3 P8 bet_conga__bet calculation col_conga_col col_out2_col 
                l6_4_2 l6_6 not_col_distincts not_conga_sym out_bet_out_1 out_trivial)
          ultimately show ?thesis
            using l6_7 by blast
        qed
      qed
      thus ?thesis
        using P8 not_col_distincts out2__conga out_trivial by blast
    next
      assume P13: "¬ Col D E F"
      show ?thesis
      proof -
        have "B C TS A J"
        proof -
          have "Coplanar B C A J"
            using P1 coplanar_perm_8 by blast
          moreover have "¬ Col A B C"
            by (simp add: P8)
          moreover have "¬ B C OS A J"
            using P1 by simp
          moreover have "¬ Col J B C"
          proof -
            have "D E F CongA J B C"
              using P1 conga_right_comm not_conga_sym by blast
            thus ?thesis
              using P13 ncol_conga_ncol by blast
          qed
          ultimately show ?thesis
            using cop__one_or_two_sides by blast
        qed
        moreover have "B C TS A J'"
        proof -
          have "Coplanar B C A J'"
            using P2 coplanar_perm_8 by blast
          moreover have "¬ Col A B C"
            by (simp add: P8)
          moreover have "¬ B C OS A J'"
            using P2 by simp
          moreover have "¬ Col J' B C"
          proof -
            have "D E F CongA J' B C"
              using P2 conga_right_comm not_conga_sym by blast
            thus ?thesis
              using P13 ncol_conga_ncol by blast
          qed
          ultimately show ?thesis
            using cop_nos__ts by blast
        qed
        moreover have "A B C CongA A B C"
          by (metis P8 conga_pseudo_refl conga_right_comm not_col_distincts)
        moreover have "C B J CongA C B J'"
          by (simp add: P3)
        ultimately show ?thesis
          using l11_22a by blast
      qed
    qed
  qed
  thus ?thesis
    by (meson P1 P2 not_conga not_conga_sym)
qed

lemma suma_sym:
  assumes "A B C D E F SumA G H I"
  shows "D E F A B C SumA G H I"
proof -
  obtain J where P1: "C B J CongA D E F ∧ ¬ B C OS A J ∧ Coplanar A B C J ∧ A B J CongA G H I"
    using SumA_def assms(1) by blast
  show ?thesis
  proof cases
    assume P2: "Col A B C"
    thus ?thesis
    proof cases
      assume P3: "Bet A B C"
      obtain K where P4: "Bet F E K ∧ Cong F E E K"
        using Cong_perm segment_construction by blast
      show ?thesis
      proof -
        have P5: "F E K CongA A B C"
          by (metis CongA_def P1 P3 P4 cong_diff conga_line)
        moreover have "¬ E F OS D K"
          using P4 bet_col col124__nos invert_one_side by blast
        moreover have "Coplanar D E F K"
          using P4 bet__coplanar ncoplanar_perm_15 by blast
        moreover have "D E K CongA G H I"
        proof -
          have "D E K CongA A B J"
          proof -
            have "F E D CongA C B J"
              by (simp add: P1 conga_left_comm conga_sym)
            moreover have "Bet F E K"
              by (simp add: P4)
            moreover have "K ≠ E"
              using P4 calculation(1) cong_identity conga_diff1 by blast
            moreover have "Bet C B A"
              by (simp add: Bet_perm P3)
            moreover have "A ≠ B"
              using CongA_def P5 by blast
            ultimately show ?thesis
              using conga_right_comm l11_13 not_conga_sym by blast
          qed
          thus ?thesis
            using P1 not_conga by blast
        qed
        ultimately show ?thesis
          using SumA_def by blast
      qed
    next
      assume T1: "¬ Bet A B C"
      hence T2: "B Out A C"
        by (simp add: P2 l6_4_2)
      show ?thesis
      proof -
        have "F E F CongA A B C"
          by (metis T2 assms l11_21_b out_trivial suma_distincts)
        moreover have "¬ E F OS D F"
          using os_distincts by auto
        moreover have "Coplanar D E F F"
          using ncop_distincts by auto
        moreover have "D E F CongA G H I"
        proof -
          have "A B J CongA D E F"
          proof -
            have "C B J CongA D E F"
              by (simp add: P1)
            moreover have "B Out A C"
              by (simp add: T2)
            moreover have "J ≠ B"
              using calculation(1) conga_distinct by auto
            moreover have "D ≠ E"
              using calculation(1) conga_distinct by blast
            moreover have "F ≠ E"
              using calculation(1) conga_distinct by blast
            ultimately show ?thesis
              by (meson Out_cases not_conga out2__conga out_trivial)
          qed
          hence "D E F CongA A B J"
            using not_conga_sym by blast
          thus ?thesis
            using P1 not_conga by blast
        qed
        ultimately show ?thesis
          using SumA_def by blast
      qed
    qed
  next
    assume Q1: "¬ Col A B C"
    show ?thesis
    proof cases
      assume Q2: "Col D E F"
      obtain K where Q3: "A B C CongA F E K"
        using P1 angle_construction_3 conga_diff1 conga_diff56 by fastforce
      show ?thesis
      proof -
        have "F E K CongA A B C"
          by (simp add: Q3 conga_sym)
        moreover have "¬ E F OS D K"
          using Col_cases Q2 one_side_not_col123 by blast
        moreover have "Coplanar D E F K"
          by (simp add: Q2 col__coplanar)
        moreover have "D E K CongA G H I"
        proof -
          have "D E K CongA A B J"
          proof cases
            assume "Bet D E F"
            hence "J B A CongA D E K"
              by (metis P1 bet_conga__bet calculation(1) conga_diff45 
                  conga_right_comm l11_13 not_conga_sym)
            thus ?thesis
              using conga_right_comm not_conga_sym by blast
          next
            assume "¬ Bet D E F"
            hence W2: "E Out D F"
              using Q2 or_bet_out by blast
            have "A B J CongA D E K"
            proof -
              have "A B C CongA F E K"
                by (simp add: Q3)
              moreover have "A ≠ B"
                using Q1 col_trivial_1 by auto
              moreover have "E Out D F"
                by (simp add: W2)
              moreover have "B Out J C"
              proof -
                have "D E F CongA J B C"
                  by (simp add: P1 conga_left_comm conga_sym)
                thus ?thesis
                  using W2 out_conga_out by blast
              qed
              moreover have "K ≠ E"
                using CongA_def Q3 by blast
              ultimately show ?thesis
                using l11_10 out_trivial by blast
            qed
            thus ?thesis
              using not_conga_sym by blast
          qed
          thus ?thesis
            using P1 not_conga by blast
        qed
        ultimately show ?thesis
          using SumA_def by blast
      qed
    next
      assume W3: "¬ Col D E F"
      then obtain K where W4: "A B C CongA F E K ∧ F E TS K D"
        using Q1 ex_conga_ts not_col_permutation_3 by blast
      show ?thesis
      proof -
        have "F E K CongA A B C"
          using W4 not_conga_sym by blast
        moreover have "¬ E F OS D K"
        proof -
          have "E F TS D K"
            using W4 invert_two_sides l9_2 by blast
          thus ?thesis
            using l9_9 by auto
        qed
        moreover have "Coplanar D E F K"
        proof -
          have "E F TS D K"
            using W4 invert_two_sides l9_2 by blast
          thus ?thesis
            using ncoplanar_perm_8 ts__coplanar by blast
        qed
        moreover have "D E K CongA G H I"
        proof -
          have "A B J CongA K E D"
          proof -
            have "B C TS A J"
            proof -
              have "Coplanar B C A J"
                using P1 ncoplanar_perm_12 by blast
              moreover have "¬ Col A B C"
                by (simp add: Q1)
              moreover have "¬ B C OS A J"
                using P1 by simp
              moreover have "¬ Col J B C"
              proof -
                {
                  assume "Col J B C"
                  have "Col D E F"
                  proof -
                    have "Col C B J"
                      using Col_perm ‹Col J B C› by blast
                    moreover have "C B J CongA D E F"
                      by (simp add: P1)
                    ultimately show ?thesis
                      using col_conga_col by blast
                  qed
                  hence "False"
                    by (simp add: W3)
                }
                thus ?thesis by blast
              qed
              ultimately show ?thesis
                using cop_nos__ts by blast
            qed
            moreover have "E F TS K D"
              using W4 invert_two_sides by blast
            moreover have "A B C CongA K E F"
              by (simp add: W4 conga_right_comm)
            moreover have "C B J CongA F E D"
              by (simp add: P1 conga_right_comm)
            ultimately show ?thesis
              using l11_22a by auto
          qed
          hence "D E K CongA A B J"
            using conga_left_comm not_conga_sym by blast
          thus ?thesis
            using P1 not_conga by blast
        qed
        ultimately show ?thesis
          using SumA_def by blast
      qed
    qed
  qed
qed

lemma conga3_suma__suma:
  assumes "A B C D E F SumA G H I" and
    "A B C CongA A' B' C'" and
    "D E F CongA D' E' F'" and
    "G H I CongA G' H' I'"
  shows "A' B' C' D' E' F' SumA G' H' I'"
proof -
  have "D' E' F' A B C SumA G' H' I'"
  proof -
    obtain J where P1: "C B J CongA D E F ∧ ¬ B C OS A J ∧ Coplanar A B C J ∧ A B J CongA G H I"
      using SumA_def assms(1) by blast
    have "A B C D' E' F' SumA G' H' I'"
    proof -
      have "C B J CongA D' E' F'"
        using P1 assms(3) not_conga by blast
      moreover have "¬ B C OS A J"
        using P1 by simp
      moreover have "Coplanar A B C J"
        using P1 by simp
      moreover have "A B J CongA G' H' I'"
        using P1 assms(4) not_conga by blast
      ultimately show ?thesis
        using SumA_def by blast
    qed
    thus ?thesis
      by (simp add: suma_sym)
  qed
  then obtain J where P2: "F' E' J CongA A B C  ∧ ¬ E' F' OS D' J ∧ 
Coplanar D' E' F' J ∧ D' E' J CongA G' H' I'"
    using SumA_def by blast
  have "D' E' F' A' B' C' SumA G' H' I'"
  proof -
    have "F' E' J CongA A' B' C'"
    proof -
      have "F' E' J CongA A B C"
        by (simp add: P2)
      moreover have "A B C CongA A' B' C'"
        by (simp add: assms(2))
      ultimately show ?thesis
        using not_conga by blast
    qed
    moreover have "¬ E' F' OS D' J"
      using P2 by simp
    moreover have "Coplanar D' E' F' J"
      using P2 by simp
    moreover have "D' E' J CongA G' H' I'"
      by (simp add: P2)
    ultimately show ?thesis
      using SumA_def by blast
  qed
  thus ?thesis
    by (simp add: suma_sym)
qed

lemma out6_suma__suma:
  assumes "A B C D E F SumA G H I" and
    "B Out A A'" and
    "B Out C C'" and
    "E Out D D'" and
    "E Out F F'" and
    "H Out G G'" and
    "H Out I I'"
  shows "A' B C' D' E F' SumA G' H I'"
proof -
  have "A B C CongA A' B C'"
    using Out_cases assms(2) assms(3) out2__conga by blast
  moreover have "D E F CongA D' E F'"
    using Out_cases assms(4) assms(5) out2__conga by blast
  moreover have "G H I CongA G' H I'"
    by (simp add: assms(6) assms(7) l6_6 out2__conga)
  ultimately show ?thesis
    using assms(1) conga3_suma__suma by blast
qed

lemma out546_suma__conga:
  assumes "A B C D E F SumA G H I" and
    "E Out D F"
  shows "A B C CongA G H I"
proof -
  have "A B C D E F SumA A B C"
  proof -
    have "C B C CongA D E F"
      by (metis assms(1) assms(2) l11_21_b out_trivial suma_distincts)
    moreover have "¬ B C OS A C"
      using os_distincts by auto
    moreover have "Coplanar A B C C"
      using ncop_distincts by auto
    moreover have "A B C CongA A B C"
      by (metis suma_distincts assms(1) conga_pseudo_refl conga_right_comm)
    ultimately show ?thesis
      using SumA_def by blast
  qed
  thus ?thesis using suma2__conga assms(1) by blast
qed

lemma out546__suma:
  assumes "A ≠ B" and
    "B ≠ C" and
    "E Out D F"
  shows "A B C D E F SumA A B C"
proof -
  have P1: "D ≠ E"
    using assms(3) out_diff1 by auto
  have P2: "F ≠ E"
    using Out_def assms(3) by auto
  then obtain G H I where P3: "A B C D E F SumA G H I"
    using P1 assms(1) assms(2) ex_suma by presburger
  hence "G H I CongA A B C"
    by (meson conga_sym out546_suma__conga assms(3))
  thus ?thesis
    using P1 P2 P3 assms(1) assms(2) assms(3) conga3_suma__suma
      conga_refl out_diff1 by auto
qed

lemma out213_suma__conga:
  assumes "A B C D E F SumA G H I" and
    "B Out A C"
  shows "D E F CongA G H I"
  using assms(1) assms(2) out546_suma__conga suma_sym by blast

lemma out213__suma:
  assumes "D ≠ E" and
    "E ≠ F" and
    "B Out A C"
  shows "A B C D E F SumA D E F"
  by (simp add: assms(1) assms(2) assms(3) out546__suma suma_sym)

lemma suma_left_comm:
  assumes "A B C D E F SumA G H I"
  shows "C B A D E F SumA G H I"
proof -
  have "A B C CongA C B A"
    using assms conga_pseudo_refl suma_distincts by fastforce
  moreover have "D E F CongA D E F"
    by (metis assms conga_refl suma_distincts)
  moreover have "G H I CongA G H I"
    by (metis assms conga_refl suma_distincts)
  ultimately show ?thesis
    using assms conga3_suma__suma by blast
qed

lemma suma_middle_comm:
  assumes "A B C D E F SumA G H I"
  shows "A B C F E D SumA G H I"
  using assms suma_left_comm suma_sym by blast

lemma suma_right_comm:
  assumes "A B C D E F SumA G H I"
  shows "A B C D E F SumA I H G"
proof -
  have "A B C CongA A B C"
    using assms conga_refl suma_distincts by fastforce
  moreover have "D E F CongA D E F"
    by (metis assms conga_refl suma_distincts)
  moreover have "G H I CongA I H G"
    by (meson conga_right_comm suma2__conga assms)
  ultimately show ?thesis
    using assms conga3_suma__suma by blast
qed

lemma suma_comm:
  assumes "A B C D E F SumA G H I"
  shows "C B A F E D SumA I H G"
  by (simp add: assms suma_left_comm suma_middle_comm suma_right_comm)

lemma ts__suma:
  assumes "A B TS C D"
  shows "C B A A B D SumA C B D"
proof -
  have "A B D CongA A B D"
    by (metis conga_right_comm assms conga_pseudo_refl ts_distincts)
  moreover have "¬ B A OS C D"
    using assms invert_one_side l9_9 by blast
  moreover have "Coplanar C B A D"
    using assms ncoplanar_perm_14 ts__coplanar by blast
  moreover have "C B D CongA C B D"
    by (metis assms conga_refl ts_distincts)
  ultimately show ?thesis
    using SumA_def by blast
qed

lemma ts__suma_1:
  assumes "A B TS C D"
  shows "C A B B A D SumA C A D"
  by (simp add: assms invert_two_sides ts__suma)

lemma inangle__suma:
  assumes "P InAngle A B C"
  shows "A B P P B C SumA A B C"
proof -
  have "Coplanar A B P C"
    by (simp add: assms coplanar_perm_8 inangle__coplanar)
  moreover have "¬ B P OS A C"
    by (meson assms col123__nos col124__nos in_angle_two_sides invert_two_sides 
        l9_9_bis not_col_permutation_5)
  ultimately show ?thesis
    using SumA_def assms conga_refl inangle_distincts by blast
qed

lemma bet__suma:
  assumes "A ≠ B" and
    "B ≠ C" and
    "P ≠ B" and "Bet A B C"
  shows "A B P P B C SumA A B C"
proof -
  have "P InAngle A B C"
    using assms(1) assms(2) assms(3) assms(4) in_angle_line by auto
  thus ?thesis
    by (simp add: inangle__suma)
qed

lemma sams_chara:
  assumes "A ≠ B" and
    "A' ≠ B" and
    "Bet A B A'"
  shows "SAMS A B C D E F ⟷ D E F LeA C B A'"
proof -
  {
    assume "SAMS A B C D E F"
    then obtain J where "C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J"
      using SAMS_def by auto
    have "C B J CongA D E F" 
      by (simp add: ‹C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J›)
    have "¬ B C OS A J"      
      by (simp add: ‹C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J›)
    have "¬ A B TS C J" 
      by (simp add: ‹C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J›)
    have "Coplanar A B C J" 
      by (simp add: ‹C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J›)
    have "A ≠ A'"
      using assms(2) assms(3) between_identity by blast
    have "C ≠ B" 
      using ‹C B J CongA D E F› conga_diff1 by auto
    have "J ≠ B" 
      using CongA_def ‹C B J CongA D E F› by presburger
    have "D ≠ E" 
      using ‹C B J CongA D E F› conga_diff45 by blast
    have "F ≠ E" 
      using CongA_def ‹C B J CongA D E F› by blast
    {
      assume "E Out D F"
      hence "D E F LeA C B A'"
        using assms(2) l11_31_1 ‹C ≠ B› by force
    }
    {
      assume "¬ Bet A B C"
      have "D E F LeA C B A'"
      proof cases
        assume "Col A B C"
        hence "Bet C B A'"
          using assms(1) assms(3) between_exchange3 outer_transitivity_between2 
            third_point ‹¬ Bet A B C› by blast
        thus ?thesis
          using assms(2) l11_31_2 by (simp add: ‹C ≠ B› ‹D ≠ E› ‹F ≠ E›)
      next
        assume T9: "¬ Col A B C"
        show ?thesis
        proof cases
          assume T10: "Col D E F"
          show ?thesis
          proof cases
            assume T11: "Bet D E F"
            have "D E F CongA C B J" 
              using ‹C B J CongA D E F› conga_sym_equiv by auto
            hence T12: "Bet C B J"
              using T11 bet_conga__bet by blast
            have "A B TS C J"
            proof -
              have "¬ Col J A B"
                using T9 T12 bet_col col2__eq col_permutation_1 ‹J ≠ B› by blast
              moreover have "∃ T. Col T A B ∧ Bet C T J"
                using T12 col_trivial_3 by blast
              ultimately show ?thesis
                using T9 TS_def col_permutation_1 by blast
            qed
            hence "False" 
              using ‹¬ A B TS C J› by blast
            thus ?thesis by simp
          next
            assume "¬ Bet D E F"
            thus ?thesis
              using T10 ‹E Out D F ⟹ D E F LeA C B A'› or_bet_out by auto
          qed
        next
          assume T13: "¬ Col D E F"
          show ?thesis
          proof -
            have "C B J LeA C B A'"
            proof -
              have "J InAngle C B A'"
              proof -
                have "A' ≠ B"
                  by (simp add: assms(2))
                moreover have "Bet A B A'"
                  by (simp add: assms(3))
                moreover have "C InAngle A B J"
                proof -
                  have "¬ Col J B C"
                  proof -
                    have "¬ Col D E F"
                      by (simp add: T13)
                    moreover have "D E F CongA J B C" 
                      using conga_left_comm not_conga_sym 
                        ‹C B J CongA D E F› by blast
                    ultimately show ?thesis
                      using ncol_conga_ncol by blast
                  qed
                  hence "B C TS A J" 
                    using T9 cop_nos__ts coplanar_perm_8 
                      ‹Coplanar A B C J› ‹¬ B C OS A J› by blast
                  then obtain X where T14: "Col X B C ∧ Bet A X J"
                    using TS_def by blast
                  {
                    assume T15: "X ≠ B"
                    have "B Out X C"
                    proof -
                      have "Col B X C"
                        by (simp add: Col_perm T14)
                      moreover have "B A OS X C"
                      proof -
                        have "A B OS X C"
                        proof -
                          have "A B OS X J"
                            using T14 T9 T15 bet_out calculation col_transitivity_2 
                              col_trivial_2 l6_21 out_one_side by metis
                          moreover have "A B OS J C"
                            using T14 T9 calculation cop_nts__os l5_2 
                              not_col_permutation_2 one_side_chara one_side_symmetry 
                              ‹ ¬ A B TS C J› ‹Coplanar A B C J› by (metis)
                          ultimately show ?thesis
                            using one_side_transitivity by blast
                        qed
                        thus ?thesis
                          by (simp add: invert_one_side)
                      qed
                      ultimately show ?thesis
                        using col_one_side_out by auto
                    qed
                  }
                  hence "Bet A X J ∧ (X = B ∨ B Out X C)"
                    using T14 by blast
                  thus ?thesis
                    using InAngle_def ‹C ≠ B› ‹J ≠ B› assms(1) by auto
                qed
                ultimately show ?thesis
                  using in_angle_reverse l11_24 by blast
              qed
              moreover have "C B J CongA C B J" 
                using ‹C ≠ B› ‹J ≠ B› conga_refl by presburger
              ultimately show ?thesis
                by (simp add: inangle__lea)
            qed
            moreover have "D E F LeA C B J" 
              using ‹C B J CongA D E F› conga__lea456123 by auto
            ultimately show ?thesis
              using lea_trans by blast
          qed
        qed
      qed
    }
    hence "D E F LeA C B A'" 
      using SAMS_def ‹E Out D F ⟹ D E F LeA C B A'› 
        ‹SAMS A B C D E F› by fastforce
  }
  {
    assume P1: "D E F LeA C B A'"
    have P2: "A ≠ A'"
      using assms(2) assms(3) between_identity by blast
    have P3: "C ≠ B"
      using P1 lea_distincts by auto
    have P4: "D ≠ E"
      using P1 lea_distincts by auto
    have P5: "F ≠ E"
      using P1 lea_distincts by auto
    have "SAMS A B C D E F"
    proof cases
      assume P6: "Col A B C"
      show ?thesis
      proof cases
        assume P7: "Bet A B C"
        have "E Out D F"
        proof -
          have "B Out C A'"
            by (meson Bet_perm P3 P7 assms(1) assms(2) assms(3) l6_2)
          moreover have "C B A' CongA D E F"
            using P1 calculation l11_21_b out_lea__out by blast
          ultimately show ?thesis
            using out_conga_out by blast
        qed
        moreover have "C B C CongA D E F"
          using P3 calculation l11_21_b out_trivial by auto
        moreover have "¬ B C OS A C"
          using os_distincts by auto
        moreover have "¬ A B TS C C"
          by (simp add: not_two_sides_id)
        moreover have "Coplanar A B C C"
          using ncop_distincts by auto
        ultimately show ?thesis
          using SAMS_def assms(1) by blast
      next
        assume P8: "¬ Bet A B C"
        have P9: "B Out A C"
          by (simp add: P6 P8 l6_4_2)
        obtain J where P10: "D E F CongA C B J"
          using P3 P4 P5 angle_construction_3 by blast
        show ?thesis
        proof -
          have "C B J CongA D E F"
            using P10 not_conga_sym by blast
          moreover have "¬ B C OS A J"
            using Col_cases P6 one_side_not_col123 by blast
          moreover have "¬ A B TS C J"
            using Col_cases P6 TS_def by blast
          moreover have "Coplanar A B C J"
            using P6 col__coplanar by auto
          ultimately show ?thesis
            using P8 SAMS_def assms(1) by blast
        qed
      qed
    next
      assume P11: "¬ Col A B C"
      have P12: "¬ Col A' B C"
        using P11 assms(2) assms(3) bet_col bet_col1 colx by blast
      show ?thesis
      proof cases
        assume P13: "Col D E F"
        have P14: "E Out D F"
        proof -
          {
            assume P14: "Bet D E F"
            have "D E F LeA C B A'"
              by (simp add: P1)
            hence "Bet C B A'"
              using P14 bet_lea__bet by blast
            hence "Col A' B C"
              using Col_def Col_perm by blast
            hence "False"
              by (simp add: P12)
          }
          hence "¬ Bet D E F" by auto
          thus ?thesis
            by (simp add: P13 l6_4_2)
        qed
        show ?thesis
        proof -
          have "C B C CongA D E F"
            by (simp add: P3 P14 l11_21_b out_trivial)
          moreover have "¬ B C OS A C"
            using os_distincts by auto
          moreover have "¬ A B TS C C"
            by (simp add: not_two_sides_id)
          moreover have "Coplanar A B C C"
            using ncop_distincts by auto
          ultimately show ?thesis
            using P14 SAMS_def assms(1) by blast
        qed
      next
        assume P15: "¬ Col D E F"
        obtain J where P16: "D E F CongA C B J ∧ C B TS J A"
          using P11 P15 ex_conga_ts not_col_permutation_3 by presburger
        show ?thesis
        proof -
          have "C B J CongA D E F"
            by (simp add: P16 conga_sym)
          moreover have "¬ B C OS A J"
          proof -
            have "C B TS A J"
              using P16 by (simp add: l9_2)
            thus ?thesis
              using invert_one_side l9_9 by blast
          qed
          moreover have "¬ A B TS C J ∧ Coplanar A B C J"
          proof cases
            assume "Col A B J"
            thus ?thesis
              using TS_def ncop__ncols not_col_permutation_1 by blast
          next
            assume P17: "¬ Col A B J"
            have "¬ A B TS C J"
            proof -
              have "A' B OS J C"
              proof -
                have "¬ Col A' B C"
                  by (simp add: P12)
                moreover have "¬ Col B A' J"
                proof -
                  {
                    assume "Col B A' J"
                    hence "False"
                      by (metis P17 assms(2) assms(3) bet_col col_trivial_2 colx)
                  }
                  thus ?thesis by auto
                qed
                moreover have "J InAngle A' B C"
                proof -
                  obtain K where P20: "K InAngle C B A' ∧ D E F CongA C B K"
                    using LeA_def P1 by blast
                  have "J InAngle C B A'"
                  proof -
                    have "C B A' CongA C B A'"
                      by (simp add: P3 assms(2) conga_pseudo_refl conga_right_comm)
                    moreover have "C B K CongA C B J"
                    proof -
                      have "C B K CongA D E F"
                        using P20 not_conga_sym by blast
                      moreover have "D E F CongA C B J"
                        by (simp add: P16)
                      ultimately show ?thesis
                        using not_conga by blast
                    qed
                    moreover have "K InAngle C B A'"
                      using P20 by simp
                    moreover have "C B OS J A'"
                    proof -
                      have "C B TS J A" using P16
                        by simp
                      moreover have "C B TS A' A"
                        using Col_perm P12 assms(3) bet__ts between_symmetry 
                          calculation invert_two_sides ts_distincts by blast
                      ultimately show ?thesis
                        using OS_def by auto
                    qed
                    ultimately show ?thesis
                      using conga_preserves_in_angle by blast
                  qed
                  thus ?thesis
                    by (simp add: l11_24)
                qed
                ultimately show ?thesis
                  by (simp add: in_angle_one_side)
              qed
              hence "A' B OS C J"
                by (simp add: one_side_symmetry)
              hence "¬ A' B TS C J"
                by (simp add: l9_9_bis)
              thus ?thesis
                using assms(2) assms(3) bet_col bet_col1 col_preserves_two_sides by blast
            qed
            moreover have "Coplanar A B C J"
            proof -
              have "C B TS J A"
                using P16 by simp
              thus ?thesis
                by (simp add: coplanar_perm_20 ts__coplanar)
            qed
            ultimately  show ?thesis by auto
          qed
          ultimately show ?thesis
            using P11 SAMS_def assms(1) bet_col by auto
        qed
      qed
    qed
  }
  thus ?thesis
    using ‹SAMS A B C D E F ⟹ D E F LeA C B A'› by blast
qed

lemma sams_distincts:
  assumes "SAMS A B C D E F"
  shows "A ≠ B ∧ B ≠ C ∧ D ≠ E ∧ E ≠ F"
proof -
  obtain J where "C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J"
    using SAMS_def assms by auto
  thus ?thesis
    by (metis SAMS_def assms conga_distinct)
qed

lemma sams_sym:
  assumes "SAMS A B C D E F"
  shows "SAMS D E F A B C"
proof -
  have P1: "A ≠ B"
    using assms sams_distincts by blast
  have P3: "D ≠ E"
    using assms sams_distincts by blast
  obtain D' where P5: "E Midpoint D D'"
    using symmetric_point_construction by blast
  obtain A' where P6: "B Midpoint A A'"
    using symmetric_point_construction by blast
  have P8: "E ≠ D'"
    using P3 P5 is_midpoint_id_2 by blast
  have P9: "A ≠ A'"
    using P1 P6 l7_3 by auto
  hence P10: "B ≠ A'"
    using P6 P9 midpoint_not_midpoint by auto
  hence "D E F LeA C B A'"
    using P1 P6 assms midpoint_bet sams_chara by fastforce
  hence "D E F LeA A' B C"
    by (simp add: lea_right_comm)
  hence "A B C LeA D' E F"
    by (metis Mid_cases P1 P10 P3 P5 P6 P8 l11_36 midpoint_bet)
  hence "A B C LeA F E D'"
    by (simp add: lea_right_comm)
  moreover have "D ≠ E"
    by (simp add: P3)
  moreover have "D' ≠ E"
    using P8 by auto
  moreover have "Bet D E D'"
    by (simp add: P5 midpoint_bet)
  thus ?thesis
    using P3 P8 calculation(1) sams_chara by fastforce
qed

lemma sams_right_comm:
  assumes "SAMS A B C D E F"
  shows "SAMS A B C F E D"
proof -
  have P1: "E Out D F ∨ ¬ Bet A B C"
    using SAMS_def assms by blast
  obtain J where P2: "C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J"
    using SAMS_def assms by auto
  {
    assume "E Out D F"
    hence "E Out F D ∨ ¬ Bet A B C"
      by (simp add: l6_6)
  }
  {
    assume "¬ Bet A B C"
    hence "E Out F D ∨ ¬ Bet A B C" by auto
  }
  hence "E Out F D ∨ ¬ Bet A B C"
    using ‹E Out D F ⟹ E Out F D ∨ ¬ Bet A B C› P1 by auto
  moreover have "C B J CongA F E D"
  proof -
    have "C B J CongA D E F"
      by (simp add: P2)
    thus ?thesis
      by (simp add: conga_right_comm)
  qed
  ultimately show ?thesis
    using P2 SAMS_def assms by auto
qed

lemma sams_left_comm:
  assumes "SAMS A B C D E F"
  shows "SAMS C B A D E F"
proof -
  have "SAMS D E F A B C"
    by (simp add: assms sams_sym)
  hence "SAMS D E F C B A"
    using sams_right_comm by blast
  thus ?thesis
    using sams_sym by blast
qed

lemma sams_comm:
  assumes "SAMS A B C D E F"
  shows "SAMS C B A F E D"
  using assms sams_left_comm sams_right_comm by blast

lemma conga2_sams__sams:
  assumes "A B C CongA A' B' C'" and
    "D E F CongA D' E' F'" and
    "SAMS A B C D E F"
  shows "SAMS A' B' C' D' E' F'"
proof -
  obtain A0 where "B Midpoint A A0"
    using symmetric_point_construction by auto
  obtain A'0 where "B' Midpoint A' A'0"
    using symmetric_point_construction by blast
  have "D' E' F' LeA C' B' A'0"
  proof -
    have "D E F LeA C B A0"
      by (metis ‹B Midpoint A A0› assms(1) assms(3) conga_distinct 
          midpoint_bet midpoint_distinct_2 sams_chara)
    moreover have "D E F CongA D' E' F'"
      by (simp add: assms(2))
    moreover have "C B A0 CongA C' B' A'0"
    proof -
      have "A0 B C CongA A'0 B' C'"
        by (metis ‹B Midpoint A A0› ‹B' Midpoint A' A'0› assms(1) calculation(1) 
            conga_diff45 l11_13 lea_distincts midpoint_bet midpoint_not_midpoint)
      thus ?thesis
        using conga_comm by blast
    qed
    ultimately show ?thesis
      using l11_30 by blast
  qed
  thus ?thesis
    by (metis ‹B' Midpoint A' A'0› assms(1) conga_distinct lea_distincts 
        midpoint_bet sams_chara)
qed

lemma out546__sams:
  assumes "A ≠ B" and
    "B ≠ C" and
    "E Out D F"
  shows "SAMS A B C D E F"
proof -
  obtain A' where "Bet A B A' ∧ Cong B A' A B"
    using segment_construction by blast
  hence "D E F LeA C B A'"
    using assms(1) assms(2) assms(3) cong_diff_3 l11_31_1 by fastforce
  thus ?thesis
    using ‹Bet A B A' ∧ Cong B A' A B› assms(1) lea_distincts sams_chara by blast
qed

lemma out213__sams:
  assumes "D ≠ E" and
    "E ≠ F" and
    "B Out A C"
  shows "SAMS A B C D E F"
  by (simp add: sams_sym assms(1) assms(2) assms(3) out546__sams)

lemma bet_suma__sams:
  assumes "A B C D E F SumA G H I" and
    "Bet G H I"
  shows "SAMS A B C D E F"
proof -
  obtain A' where P1: "C B A' CongA D E F ∧ ¬ B C OS A A' ∧ Coplanar A B C A' ∧ A B A' CongA G H I"
    using SumA_def assms(1) by auto
  hence "G H I CongA A B A'"
    using not_conga_sym by blast
  hence "Bet A B A'"
    using assms(2) bet_conga__bet by blast
  show ?thesis
  proof -
    have "E Out D F ∨ ¬ Bet A B C"
    proof -
      {
        assume "Bet A B C"
        hence "E Out D F"
        proof -
          have "B Out C A'"
          proof -
            have "C ≠ B"
              using assms(1) suma_distincts by blast
            moreover have "A' ≠ B"
              using CongA_def ‹G H I CongA A B A'› by blast
            moreover have "A ≠ B"
              using CongA_def ‹G H I CongA A B A'› by blast
            moreover have "Bet C B A"
              by (simp add: Bet_perm ‹Bet A B C›)
            ultimately show ?thesis
              using Out_def ‹Bet A B A'› ‹Bet A B C› l5_2 by auto
          qed
          moreover have "C B A' CongA D E F"
            using P1 by simp
          ultimately show ?thesis
            using l11_21_a by blast
        qed
      }
      thus ?thesis
        by blast
    qed
    moreover have "∃ J. (C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J)"
    proof -
      have "C B A' CongA D E F"
        by (simp add: P1)
      moreover have "¬ B C OS A A'"
        by (simp add: P1)
      moreover have "¬ A B TS C A'"
        using Col_def TS_def ‹Bet A B A'› by blast
      moreover have "Coplanar A B C A'"
        by (simp add: P1)
      ultimately show ?thesis
        by blast
    qed
    ultimately show ?thesis
      using CongA_def SAMS_def 
        ‹C B A' CongA D E F ∧ ¬ B C OS A A' ∧ Coplanar A B C A' ∧ A B A' CongA G H I› 
      by auto
  qed
qed

lemma bet__sams:
  assumes "A ≠ B" and
    "B ≠ C" and
    "P ≠ B" and
    "Bet A B C"
  shows "SAMS A B P P B C"
  by (meson assms(1) assms(2) assms(3) assms(4) bet__suma bet_suma__sams)

lemma suppa__sams:
  assumes "A B C SuppA D E F"
  shows "SAMS A B C D E F"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms by auto
  hence "SAMS A B C C B A'"
    by (metis assms bet__sams conga_diff45 conga_diff56 suppa2__conga123)
  thus ?thesis
    by (meson P1 assms conga2_sams__sams not_conga_sym suppa2__conga123)
qed

lemma os_ts__sams:
  assumes "B P TS A C" and
    "A B OS P C"
  shows "SAMS A B P P B C"
proof -
  have "B Out P C ∨ ¬ Bet A B P"
    using assms(2) bet_col col123__nos by blast
  moreover have "∃ J. (P B J CongA P B C ∧ ¬ B P OS A J ∧ ¬ A B TS P J ∧ Coplanar A B P J)"
    by (metis assms(1) assms(2) conga_refl l9_9 os__coplanar os_distincts)
  ultimately show ?thesis
    using SAMS_def assms(2) os_distincts by auto
qed

lemma os2__sams:
  assumes "A B OS P C" and
    "C B OS P A"
  shows "SAMS A B P P B C"
  by (simp add: os_ts__sams assms(1) assms(2) invert_one_side l9_31)

lemma inangle__sams:
  assumes "P InAngle A B C"
  shows "SAMS A B P P B C"
proof -
  have "Bet A B C ∨ B Out A C ∨ ¬ Col A B C"
    using l6_4_2 by blast
  {
    assume "Bet A B C"
    hence "SAMS A B P P B C"
      using assms bet__sams inangle_distincts by fastforce
  }
  {
    assume "B Out A C"
    hence "SAMS A B P P B C"
      by (metis assms in_angle_out inangle_distincts out213__sams)
  }
  {
    assume "¬ Col A B C"
    hence "¬ Bet A B C"
      using Col_def by auto
    {
      assume "Col B A P"
      have "SAMS A B P P B C"
        by (metis ‹Col B A P› ‹¬ Bet A B C› assms col_in_angle_out inangle_distincts out213__sams)
    }
    {
      assume "¬ Col B A P"
      {
        assume "Col B C P"
        have "SAMS A B P P B C"
          by (metis sams_comm ‹Col B C P› ‹¬ Bet A B C› assms between_symmetry 
              col_in_angle_out inangle_distincts l11_24 out546__sams)
      }
      {
        assume "¬ Col B C P"
        have "SAMS A B P P B C"
        proof -
          have "B P TS A C"
            by (simp add: ‹¬ Col B A P› ‹¬ Col B C P› assms in_angle_two_sides 
                invert_two_sides)
          moreover have "A B OS P C"
            by (simp add: ‹¬ Col A B C› ‹¬ Col B A P› assms in_angle_one_side)
          ultimately show ?thesis
            by (simp add: os_ts__sams)
        qed
      }
      hence "SAMS A B P P B C"
        using ‹Col B C P ⟹ SAMS A B P P B C› by blast
    }
    hence "SAMS A B P P B C"
      using ‹Col B A P ⟹ SAMS A B P P B C› by blast
  }
  thus ?thesis
    using ‹B Out A C ⟹ SAMS A B P P B C› 
      ‹Bet A B C ⟹ SAMS A B P P B C› ‹Bet A B C ∨ B Out A C ∨ ¬ Col A B C› 
    by blast
qed

lemma sams_suma__lea123789:
  assumes "A B C D E F SumA G H I" and
    "SAMS A B C D E F"
  shows "A B C LeA G H I"
proof cases
  assume "Col A B C"
  show ?thesis
  proof cases
    assume "Bet A B C"
    have P1: "(A ≠ B ∧ (E Out D F ∨ ¬ Bet A B C)) ∧ 
(∃ J. (C B J CongA D E F ∧ ¬ (B C OS A J) ∧ ¬ (A B TS C J) ∧ Coplanar A B C J))"
      using SAMS_def assms(2) by auto
    {
      assume "E Out D F"
      hence "A B C CongA G H I"
        using assms(1) out546_suma__conga by auto
      hence "A B C LeA G H I"
        by (simp add: conga__lea)
    }
    thus ?thesis
      using P1 ‹Bet A B C› by blast
  next
    assume "¬ Bet A B C"
    hence "B Out A C"
      using ‹Col A B C› or_bet_out by auto
    thus ?thesis
      by (metis assms(1) l11_31_1 suma_distincts)
  qed
next
  assume "¬ Col A B C"
  show ?thesis
  proof cases
    assume "Col D E F"
    show ?thesis
    proof cases
      assume "Bet D E F"
      have "SAMS D E F A B C"
        using assms(2) sams_sym by auto
      hence "B Out A C"
        using SAMS_def ‹Bet D E F› by blast
      thus ?thesis using l11_31_1
        by (metis assms(1) suma_distincts)
    next
      assume "¬ Bet D E F"
      have "A B C CongA G H I"
      proof -
        have "A B C D E F SumA G H I"
          by (simp add: assms(1))
        moreover have "E Out D F"
          using ‹Col D E F› ‹¬ Bet D E F› l6_4_2 by auto
        ultimately show ?thesis
          using out546_suma__conga by auto
      qed
      show ?thesis
        by (simp add: ‹A B C CongA G H I› conga__lea)
    qed
  next
    assume "¬ Col D E F"
    show ?thesis
    proof cases
      assume "Col G H I"
      show ?thesis
      proof cases
        assume "Bet G H I"
        thus ?thesis
          by (metis assms(1) l11_31_2 suma_distincts)
      next
        assume "¬ Bet G H I"
        hence "H Out G I"
          by (simp add: ‹Col G H I› l6_4_2)
        have "E Out D F ∨ ¬ Bet A B C"
          using ‹¬ Col A B C› bet_col by auto
        {
          assume "¬ Bet A B C"
          then obtain J where P2: "C B J CongA D E F ∧ ¬ B C OS A J ∧ 
  Coplanar A B C J ∧ A B J CongA G H I"
            using SumA_def assms(1) by blast
          have "G H I CongA A B J"
            using P2 not_conga_sym by blast
          hence "B Out A J"
            using ‹H Out G I› out_conga_out by blast
          hence "B C OS A J"
            using Col_perm ‹¬ Col A B C› out_one_side by blast
          hence "False"
            using ‹C B J CongA D E F ∧ ¬ B C OS A J ∧ 
    Coplanar A B C J ∧ A B J CongA G H I› by linarith
        }
        hence "False"
          using Col_def ‹¬ Col A B C› by blast
        thus ?thesis by blast
      qed
    next
      assume "¬ Col G H I"
      obtain J where P4: "C B J CongA D E F ∧ ¬ B C OS A J ∧ 
¬ A B TS C J ∧ Coplanar A B C J"
        using SAMS_def assms(2) by auto
      {
        assume "Col J B C"
        have "J B C CongA D E F"
          by (simp add: P4 conga_left_comm)
        hence "Col D E F"
          using col_conga_col ‹Col J B C› by blast
        hence "False"
          using ‹¬ Col D E F› by blast
      }
      hence "¬ Col J B C" by blast
      have "A B J CongA G H I"
      proof -
        have "A B C D E F SumA A B J"
        proof -
          have "C B J CongA D E F"
            using P4 by simp
          moreover have "¬ B C OS A J"
            by (simp add: P4)
          moreover have "Coplanar A B C J"
            by (simp add: P4)
          moreover have "A B J CongA A B J"
            by (metis ‹¬ Col A B C› ‹¬ Col J B C› col_trivial_1 conga_refl)
          ultimately show ?thesis
            using SumA_def by blast
        qed
        thus ?thesis
          using assms(1) suma2__conga by auto
      qed
      have "¬ Col J B A"
        using ‹A B J CongA G H I› ‹¬ Col G H I› col_conga_col not_col_permutation_3 by blast
      have "A B C LeA A B J"
      proof -
        have "C InAngle A B J"
          by (metis Col_perm P4 ‹¬ Col A B C› ‹¬ Col J B A› ‹¬ Col J B C› 
              cop_nos__ts coplanar_perm_7 coplanar_perm_8 invert_two_sides 
              l9_2 os_ts__inangle)
        moreover have "A B C CongA A B C"
          using calculation in_angle_asym inangle3123 inangle_distincts by auto
        ultimately show ?thesis
          using inangle__lea by blast
      qed
      thus ?thesis
        using ‹A B J CongA G H I› conga__lea lea_trans by blast
    qed
  qed
qed

lemma sams_suma__lea456789:
  assumes "A B C D E F SumA G H I" and
    "SAMS A B C D E F"
  shows "D E F LeA G H I"
proof -
  have "D E F A B C SumA G H I"
    by (simp add: assms(1) suma_sym)
  moreover have "SAMS D E F A B C"
    using assms(2) sams_sym by blast
  ultimately show ?thesis
    using sams_suma__lea123789 by auto
qed

lemma sams_lea2__sams:
  assumes "SAMS A' B' C' D' E' F'" and
    "A B C LeA A' B' C'" and
    "D E F LeA D' E' F'"
  shows "SAMS A B C D E F"
proof -
  obtain A0 where "B Midpoint A A0"
    using symmetric_point_construction by auto
  obtain A'0 where "B' Midpoint A' A'0"
    using symmetric_point_construction by auto
  have "D E F LeA C B A0"
  proof -
    have "D' E' F' LeA C B A0"
    proof -
      have "D' E' F' LeA C' B' A'0"
        by (metis ‹B' Midpoint A' A'0› assms(1) assms(2) lea_distincts 
            midpoint_bet midpoint_distinct_2 sams_chara)
      moreover have "C' B' A'0 LeA C B A0"
        by (metis Mid_cases ‹B Midpoint A A0› ‹B' Midpoint A' A'0› assms(2) 
            l11_36_aux2 l7_3_2 lea_comm lea_distincts midpoint_bet sym_preserve_diff)
      ultimately show ?thesis
        using lea_trans by blast
    qed
    moreover have "D E F LeA D' E' F'"
      using assms(3) by auto
    ultimately show ?thesis
      using ‹D' E' F' LeA C B A0› assms(3) lea_trans by blast
  qed
  thus ?thesis
    by (metis ‹B Midpoint A A0› assms(2) lea_distincts midpoint_bet sams_chara)
qed

lemma sams_lea456_suma2__lea:
  assumes "D E F LeA D' E' F'" and
    "SAMS A B C D' E' F'" and
    "A B C D E F SumA G H I" and
    "A B C D' E' F' SumA G' H' I'"
  shows "G H I LeA G' H' I'"
proof cases
  assume "E' Out D' F'"
  have "G H I CongA G' H' I'"
  proof -
    have "G H I CongA A B C"
    proof -
      have "A B C D E F SumA G H I"
        by (simp add: assms(3))
      moreover have "E Out D F"
        using ‹E' Out D' F'› assms(1) out_lea__out by blast
      ultimately show ?thesis
        using conga_sym out546_suma__conga by blast
    qed
    moreover have "A B C CongA G' H' I'"
      using ‹E' Out D' F'› assms(4) out546_suma__conga by blast
    ultimately show ?thesis
      using conga_trans by blast
  qed
  thus ?thesis
    by (simp add: conga__lea)
next
  assume T1: "¬ E' Out D' F'"
  show ?thesis
  proof cases
    assume T2: "Col A B C"
    have "E' Out D' F' ∨ ¬ Bet A B C"
      using assms(2) SAMS_def by simp
    {
      assume "¬ Bet A B C"
      hence "B Out A C"
        by (simp add: T2 l6_4_2)
      have "G H I LeA G' H' I'"
      proof -
        have "D E F LeA D' E' F'"
          by (simp add: assms(1))
        moreover have "D E F CongA G H I"
          using ‹B Out A C› assms(3) out213_suma__conga by auto
        moreover have "D' E' F' CongA G' H' I'"
          using ‹B Out A C› assms(4) out213_suma__conga by auto
        ultimately show ?thesis
          using l11_30 by blast
      qed
    }
    thus ?thesis
      using T1 ‹E' Out D' F' ∨ ¬ Bet A B C› by auto
  next
    assume "¬ Col A B C"
    show ?thesis
    proof cases
      assume "Col D' E' F'"
      have "SAMS D' E' F' A B C"
        by (simp add: assms(2) sams_sym)
      {
        assume "¬ Bet D' E' F'"
        hence "G H I LeA G' H' I'"
          using not_bet_out T1 ‹Col D' E' F'› by auto
      }
      thus ?thesis
        by (metis assms(2) assms(3) assms(4) bet_lea__bet l11_31_2 
            sams_suma__lea456789 suma_distincts)
    next
      assume "¬ Col D' E' F'"
      show ?thesis
      proof cases
        assume "Col D E F"
        have "¬ Bet D E F"
          using bet_lea__bet Col_def ‹¬ Col D' E' F'› assms(1) by blast
        thus ?thesis
        proof -
          have "A B C LeA G' H' I'"
            using assms(2) assms(4) sams_suma__lea123789 by auto
          moreover have "A B C CongA G H I"
            by (meson ‹Col D E F› ‹¬ Bet D E F› assms(3) or_bet_out 
                out213_suma__conga suma_sym)
          moreover have "G' H' I' CongA G' H' I'"
          proof -
            have "G' ≠ H'"
              using calculation(1) lea_distincts by blast
            moreover have "H' ≠ I'"
              using ‹A B C LeA G' H' I'› lea_distincts by blast
            ultimately show ?thesis
              using conga_refl by auto
          qed
          ultimately show ?thesis
            using l11_30 by blast
        qed
      next
        assume "¬ Col D E F"
        show ?thesis
        proof cases
          assume "Col G' H' I'"
          show ?thesis
          proof cases
            assume "Bet G' H' I'"
            show ?thesis
            proof -
              have "G ≠ H"
                using assms(3) suma_distincts by auto
              moreover have "I ≠ H"
                using assms(3) suma_distincts by blast
              moreover have "G' ≠ H'"
                using assms(4) suma_distincts by auto
              moreover have "I' ≠ H'"
                using assms(4) suma_distincts by blast
              ultimately show ?thesis
                by (simp add: ‹Bet G' H' I'› l11_31_2)
            qed
          next
            assume "¬ Bet G' H' I'"
            have "B Out A C"
            proof -
              have "H' Out G' I'"
                using ‹Col G' H' I'› l6_4_2 by (simp add: ‹¬ Bet G' H' I'›)
              moreover have "A B C LeA G' H' I'" using sams_suma__lea123789
                using assms(2) assms(4) by auto
              ultimately show ?thesis
                using out_lea__out by blast
            qed
            hence "Col A B C"
              using Col_perm out_col by blast
            hence "False"
              using ‹¬ Col A B C› by auto
            thus ?thesis by blast
          qed
        next
          assume "¬ Col G' H' I'"
          obtain F'1 where P5: "C B F'1 CongA D' E' F' ∧ ¬ B C OS A F'1 ∧ 
¬ A B TS C F'1 ∧ Coplanar A B C F'1"
            using SAMS_def assms(2) by auto
          have P6: "D E F LeA C B F'1"
          proof -
            have "D E F CongA D E F"
              using ‹¬ Col D E F› conga_refl not_col_distincts by fastforce
            moreover have "D' E' F' CongA C B F'1"
              by (simp add: P5 conga_sym)
            ultimately show ?thesis
              using assms(1) l11_30 by blast
          qed
          then obtain F1 where P6: "F1 InAngle C B F'1 ∧ D E F CongA C B F1"
            using LeA_def by auto
          have "A B F'1 CongA G' H' I'"
          proof -
            have "A B C D' E' F' SumA A B F'1"
            proof -
              have "C B F'1 CongA D' E' F'"
                using P5 by blast
              moreover have "¬ B C OS A F'1"
                using P5 by auto
              moreover have "Coplanar A B C F'1"
                by (simp add: P5)
              moreover have "A B F'1 CongA A B F'1"
              proof -
                have "A ≠ B"
                  using ‹¬ Col A B C› col_trivial_1 by blast
                moreover have "B ≠ F'1"
                  using P6 inangle_distincts by auto
                ultimately show ?thesis
                  using conga_refl by auto
              qed
              ultimately show ?thesis
                using SumA_def by blast
            qed
            moreover have "A B C D' E' F' SumA G' H' I'"
              by (simp add: assms(4))
            ultimately show ?thesis
              using suma2__conga by auto
          qed
          have "¬ Col A B F'1"
            using ‹A B F'1 CongA G' H' I'› ‹¬ Col G' H' I'› col_conga_col by blast
          have "¬ Col C B F'1"
          proof -
            have "¬ Col D' E' F'"
              by (simp add: ‹¬ Col D' E' F'›)
            moreover have "D' E' F' CongA C B F'1"
              using P5 not_conga_sym by blast
            ultimately show ?thesis
              using ncol_conga_ncol by blast
          qed
          show ?thesis
          proof -
            have "A B F1 LeA A B F'1"
            proof -
              have "F1 InAngle A B F'1"
              proof -
                have "F1 InAngle F'1 B A"
                proof -
                  have "F1 InAngle F'1 B C"
                    by (simp add: P6 l11_24)
                  moreover have "C InAngle F'1 B A"
                  proof -
                    have "B C TS A F'1"
                      using Col_perm P5 ‹¬ Col A B C› ‹¬ Col C B F'1› 
                        cop_nos__ts ncoplanar_perm_12 by blast
                    obtain X where "Col X B C ∧ Bet A X F'1"
                      using TS_def ‹B C TS A F'1› by auto
                    have "Bet F'1 X A"
                      using Bet_perm ‹Col X B C ∧ Bet A X F'1› by blast
                    moreover have "(X = B) ∨ (B Out X C)"
                    proof -
                      have "B A OS X C"
                      proof -
                        have "A B OS X F'1"
                          by (metis ‹Col X B C ∧ Bet A X F'1› ‹¬ Col A B C› 
                              ‹¬ Col A B F'1› bet_out_1 calculation out_one_side)
                        moreover have "A B OS F'1 C"
                          using Col_perm P5 ‹¬ Col A B C› ‹¬ Col A B F'1› 
                            cop_nos__ts one_side_symmetry by blast
                        ultimately show ?thesis
                          using invert_one_side one_side_transitivity by blast
                      qed
                      thus ?thesis
                        using Col_cases ‹Col X B C ∧ Bet A X F'1› col_one_side_out by blast
                    qed
                    ultimately show ?thesis
                      by (metis InAngle_def ‹¬ Col A B C› ‹¬ Col A B F'1› not_col_distincts)
                  qed
                  ultimately show ?thesis
                    using in_angle_trans by blast
                qed
                thus ?thesis
                  using l11_24 by blast
              qed
              moreover have "A B F1 CongA A B F1"
              proof -
                have "A ≠ B"
                  using ‹¬ Col A B C› col_trivial_1 by blast
                moreover have "B ≠ F1"
                  using P6 conga_diff56 by blast
                ultimately show ?thesis
                  using conga_refl by auto
              qed
              ultimately show ?thesis
                by (simp add: inangle__lea)
            qed
            moreover have "A B F1 CongA G H I"
            proof -
              have "A B C D E F SumA A B F1"
              proof -
                have "B C TS F1 A"
                proof -
                  have "B C TS F'1 A"
                  proof -
                    have "B C TS A F'1"
                      using Col_perm P5 ‹¬ Col A B C› ‹¬ Col C B F'1› 
                        cop_nos__ts ncoplanar_perm_12 by blast
                    thus ?thesis
                      using l9_2 by blast
                  qed
                  moreover have "B C OS F'1 F1"
                  proof -
                    have "¬ Col C B F'1"
                      by (simp add: ‹¬ Col C B F'1›)
                    moreover have "¬ Col B C F1"
                    proof -
                      have "¬ Col D E F"
                        using ‹¬ Col D E F› by auto
                      moreover have "D E F CongA C B F1"
                        by (simp add: P6)
                      ultimately show ?thesis
                        using ncol_conga_ncol not_col_permutation_4 by blast
                    qed
                    moreover have "F1 InAngle C B F'1" using P6 by blast
                    ultimately show ?thesis
                      using in_angle_one_side invert_one_side one_side_symmetry by blast
                  qed
                  ultimately show ?thesis
                    using l9_8_2 by blast
                qed
                thus ?thesis
                proof -
                  have "C B F1 CongA D E F"
                    using P6 not_conga_sym by blast
                  moreover have "¬ B C OS A F1"
                    using ‹B C TS F1 A› l9_9 one_side_symmetry by blast
                  moreover have "Coplanar A B C F1"
                    using ‹B C TS F1 A› ncoplanar_perm_9 ts__coplanar by blast
                  moreover have "A B F1 CongA A B F1"
                  proof -
                    have "A ≠ B"
                      using ‹¬ Col A B C› col_trivial_1 by blast
                    moreover have "B ≠ F1"
                      using P6 conga_diff56 by blast
                    ultimately show ?thesis
                      using conga_refl by auto
                  qed
                  ultimately show ?thesis
                    using SumA_def by blast
                qed
              qed
              moreover have "A B C D E F SumA G H I"
                by (simp add: assms(3))
              ultimately show ?thesis
                using suma2__conga by auto
            qed
            ultimately show ?thesis
              using ‹A B F'1 CongA G' H' I'› l11_30 by blast
          qed
        qed
      qed
    qed
  qed
qed

lemma sams_lea123_suma2__lea:
  assumes "A B C LeA A' B' C'" and
    "SAMS A' B' C' D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D E F SumA G' H' I'"
  shows "G H I LeA G' H' I'"
  by (meson assms(1) assms(2) assms(3) assms(4) sams_lea456_suma2__lea sams_sym suma_sym)

lemma sams_lea2_suma2__lea:
  assumes "A B C LeA A' B' C'" and
    "D E F LeA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "G H I LeA G' H' I'"
proof -
  obtain G'' H'' I'' where "A B C D' E' F' SumA G'' H'' I''"
    using assms(4) assms(5) ex_suma suma_distincts by presburger
  have "G H I LeA G'' H'' I''"
  proof -
    have "D E F LeA D' E' F'"
      by (simp add: assms(2))
    moreover have "SAMS A B C D' E' F'"
    proof -
      have "SAMS A' B' C' D' E' F'"
        by (simp add: assms(3))
      moreover have "A B C LeA A' B' C'"
        using assms(1) by auto
      moreover have "D' E' F' LeA D' E' F'"
        using assms(2) lea_distincts lea_refl by blast
      ultimately show ?thesis
        using sams_lea2__sams by blast
    qed
    moreover have "A B C D E F SumA G H I"
      by (simp add: assms(4))
    moreover have "A B C D' E' F' SumA G'' H'' I''"
      by (simp add: ‹A B C D' E' F' SumA G'' H'' I''›)
    ultimately show ?thesis
      using sams_lea456_suma2__lea by blast
  qed
  moreover have "G'' H'' I'' LeA G' H' I'"
    using sams_lea123_suma2__lea assms(3) assms(5) ‹A B C D' E' F' SumA G'' H'' I''› 
      assms(1) by blast
  ultimately show ?thesis
    using lea_trans by blast
qed

lemma sams2_suma2__conga456:
  assumes "SAMS A B C D E F" and
    "SAMS A B C D' E' F'" and
    "A B C D E F SumA G H I" and
    "A B C D' E' F' SumA G H I"
  shows "D E F CongA D' E' F'"
proof cases
  assume "Col A B C"
  show ?thesis
  proof cases
    assume P2: "Bet A B C"
    hence "E Out D F"
      using assms(1) SAMS_def by blast
    moreover have "E' Out D' F'"
      using P2 assms(2) SAMS_def by blast
    ultimately show ?thesis
      by (simp add: l11_21_b)
  next
    assume "¬ Bet A B C"
    hence "B Out A C"
      using ‹Col A B C› or_bet_out by blast
    show ?thesis
    proof -
      have "D E F CongA G H I"
      proof -
        have "A B C D E F SumA G H I"
          by (simp add: assms(3))
        thus ?thesis
          using ‹B Out A C› out213_suma__conga by auto
      qed
      moreover have "G H I CongA D' E' F'"
      proof -
        have "A B C D' E' F' SumA G H I"
          by (simp add: assms(4))
        hence "D' E' F' CongA G H I"
          using ‹B Out A C› out213_suma__conga by auto
        thus ?thesis
          using not_conga_sym by blast
      qed
      ultimately show ?thesis
        using not_conga by blast
    qed
  qed
next
  assume "¬ Col A B C"
  obtain J where T1: "C B J CongA D E F ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J"
    using assms(1) SAMS_def by blast
  have T1A: "C B J CongA D E F"
    using T1 by simp
  have T1B: "¬ B C OS A J"
    using T1 by simp
  have T1C: "¬ A B TS C J"
    using T1 by simp
  have T1D: "Coplanar A B C J"
    using T1 by simp
  obtain J' where T2: "C B J' CongA D' E' F' ∧ ¬ B C OS A J' ∧ 
¬ A B TS C J' ∧ Coplanar A B C J'"
    using assms(2) SAMS_def by blast
  have T2A: "C B J' CongA D' E' F'"
    using T2 by simp
  have T2B: "¬ B C OS A J'"
    using T2 by simp
  have T2C: "¬ A B TS C J'"
    using T2 by simp
  have T2D: "Coplanar A B C J'"
    using T2 by simp
  have T3: "C B J CongA C B J'"
  proof -
    have "A B J CongA A B J'"
    proof -
      have "A B J CongA G H I"
      proof -
        have "A B C D E F SumA A B J"
          using SumA_def T1A T1B T1D ‹¬ Col A B C› conga_distinct 
            conga_refl not_col_distincts by auto
        thus ?thesis
          using assms(3) suma2__conga by blast
      qed
      moreover have "G H I CongA A B J'"
      proof -
        have "A B C D' E' F' SumA G H I"
          by (simp add: assms(4))
        moreover have "A B C D' E' F' SumA A B J'"
          using SumA_def T2A T2B T2D ‹¬ Col A B C› conga_distinct 
            conga_refl not_col_distincts by auto
        ultimately show ?thesis
          using suma2__conga by auto
      qed
      ultimately show ?thesis
        using conga_trans by blast
    qed
    have "B Out J J' ∨ A B TS J J'"
    proof -
      have "Coplanar A B J J'"
        using T1D T2D ‹¬ Col A B C› coplanar_trans_1 ncoplanar_perm_8 
          not_col_permutation_2 by blast
      moreover have "A B J CongA A B J'"
        by (simp add: ‹A B J CongA A B J'›)
      ultimately show ?thesis
        by (simp add: conga_cop__or_out_ts)
    qed
    {
      assume "B Out J J'"
      hence "C B J CongA C B J'"
        by (metis Out_cases ‹¬ Col A B C› bet_out between_trivial 
            not_col_distincts out2__conga)
    }
    {
      assume "A B TS J J'"
      hence "A B OS J C"
        by (meson T1C T1D TS_def ‹¬ Col A B C› cop_nts__os not_col_permutation_2 
            one_side_symmetry)
      hence "A B TS C J'"
        using ‹A B TS J J'› l9_8_2 by blast
      hence "False"
        by (simp add: T2C)
      hence "C B J CongA C B J'"
        by blast
    }
    thus ?thesis
      using ‹B Out J J' ⟹ C B J CongA C B J'› ‹B Out J J' ∨ A B TS J J'› by blast
  qed
  hence "C B J CongA D' E' F'"
    using T2A not_conga by blast
  thus ?thesis
    using T1A not_conga not_conga_sym by blast
qed

lemma sams2_suma2__conga123:
  assumes "SAMS A B C D E F" and
    "SAMS A' B' C' D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D E F SumA G H I"
  shows "A B C CongA A' B' C'"
proof -
  have "SAMS D E F A B C"
    by (simp add: assms(1) sams_sym)
  moreover have "SAMS D E F A' B' C'"
    by (simp add: assms(2) sams_sym)
  moreover have "D E F  A B C SumA G H I"
    by (simp add: assms(3) suma_sym)
  moreover have "D E F A' B' C' SumA G H I"
    using assms(4) suma_sym by blast
  ultimately show ?thesis
    using sams2_suma2__conga456 by auto
qed

lemma suma_assoc_1:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'" and
    "A' B' C' G H I SumA K L M"
  shows "A B C D' E' F' SumA K L M"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ Cong A B B A0"
    using Cong_perm segment_construction by blast
  obtain D0 where P2: "Bet D E D0 ∧ Cong D E E D0"
    using Cong_perm segment_construction by blast
  show ?thesis
  proof cases
    assume "Col A B C"
    show ?thesis
    proof cases
      assume "Bet A B C"
      hence "E Out D F"
        using SAMS_def assms(1) by simp
      show ?thesis
      proof -
        have "A' B' C' CongA A B C"
          using assms(3) ‹E Out D F› conga_sym out546_suma__conga by blast
        moreover have "G H I CongA D' E' F'"
          using assms(4) ‹E Out D F› out213_suma__conga by auto
        ultimately show ?thesis
          by (meson conga3_suma__suma suma2__conga assms(5))
      qed
    next
      assume "¬ Bet A B C"
      hence "B Out A C"
        using ‹Col A B C› l6_4_2 by auto
      have "A ≠ B"
        using ‹B Out A C› out_distinct by auto
      have "B ≠ C"
        using ‹¬ Bet A B C› between_trivial by auto
      have "D' ≠ E'"
        using assms(4) suma_distincts by blast
      have "E' ≠ F'"
        using assms(4) suma_distincts by auto
      show ?thesis
      proof -
        obtain K0 L0 M0 where P3:"A B C D' E' F' SumA K0 L0 M0"
          using ex_suma ‹A ≠ B› ‹B ≠ C› ‹D' ≠ E'› ‹E' ≠ F'› by presburger
        moreover have "A B C CongA A B C"
          using ‹A ≠ B› ‹B ≠ C› conga_refl by auto
        moreover have "D' E' F' CongA D' E' F'"
          using ‹D' ≠ E'› ‹E' ≠ F'› conga_refl by auto
        moreover have "K0 L0 M0 CongA K L M"
        proof -
          have "K0 L0 M0 CongA D' E' F'"
            using P3 ‹B Out A C› conga_sym out213_suma__conga by blast
          moreover have "D' E' F' CongA K L M"
          proof -
            have "D E F G H I SumA D' E' F'"
              by (simp add: assms(4))
            moreover have "D E F G H I SumA K L M"
              by (meson conga3_suma__suma out213_suma__conga sams2_suma2__conga456 
                  suma2__conga ‹B Out A C› assms(2) assms(3) assms(5) 
                  calculation not_conga_sym)
            ultimately show ?thesis
              using suma2__conga by auto
          qed
          ultimately show ?thesis
            using not_conga by blast
        qed
        ultimately show ?thesis
          using conga3_suma__suma by blast
      qed
    qed
  next
    assume T1: "¬ Col A B C"
    have "¬ Col C B A0"
      by (metis Col_def P1 ‹¬ Col A B C› cong_diff l6_16_1)
    show ?thesis
    proof cases
      assume "Col D E F"
      show ?thesis
      proof cases
        assume "Bet D E F"
        have "H Out G I" using SAMS_def assms(2) ‹Bet D E F› by blast
        have "A B C D E F SumA A' B' C'"
          by (simp add: assms(3))
        moreover have "A B C CongA A B C"
          by (metis ‹¬ Col A B C› conga_pseudo_refl conga_right_comm not_col_distincts)
        moreover have "D E F CongA D' E' F'"
          using ‹H Out G I› assms(4) out546_suma__conga by auto
        moreover have "A' B' C' CongA K L M"
          using ‹H Out G I› assms(5) out546_suma__conga by auto
        ultimately show ?thesis
          using conga3_suma__suma by blast
      next
        assume "¬ Bet D E F"
        hence "E Out D F"
          using not_bet_out by (simp add: ‹Col D E F›)
        show ?thesis
        proof -
          have "A' B' C' CongA A B C"
            using assms(3) ‹E Out D F› conga_sym out546_suma__conga by blast
          moreover have "G H I CongA D' E' F'"
            using out546_suma__conga ‹E Out D F› assms(4) out213_suma__conga by auto
          moreover have "K L M CongA K L M"
          proof -
            have "K ≠ L ∧ L ≠ M"
              using assms(5) suma_distincts by blast
            thus ?thesis
              using conga_refl by auto
          qed
          ultimately show ?thesis
            using assms(5) conga3_suma__suma by blast
        qed
      qed
    next
      assume "¬ Col D E F"
      hence "¬ Col F E D0"
        by (metis Col_def P2 cong_diff l6_16_1 not_col_distincts)
      show ?thesis
      proof cases
        assume "Col G H I"
        show ?thesis
        proof cases
          assume "Bet G H I"
          have "SAMS G H I D E F"
            by (simp add: assms(2) sams_sym)
          hence "E Out D F"
            using SAMS_def ‹Bet G H I› by blast
          hence "Col D E F"
            using Col_perm out_col by blast
          hence "False"
            using ‹¬ Col D E F› by auto
          thus ?thesis by simp
        next
          assume "¬ Bet G H I"
          hence "H Out G I"
            using SAMS_def by (simp add: ‹Col G H I› l6_4_2)
          show ?thesis
          proof -
            have "A B C CongA A B C"
              by (metis ‹¬ Col A B C› conga_refl not_col_distincts)
            moreover have "D E F CongA D' E' F'"
              using assms(4) out546_suma__conga ‹H Out G I› by auto
            moreover have "A' B' C' CongA K L M"
              using ‹H Out G I› assms(5) out546_suma__conga by auto
            ultimately show ?thesis
              using assms(3) conga3_suma__suma by blast
          qed
        qed
      next
        assume "¬ Col G H I"
        have "¬ B C OS A A0"
          using P1 col_trivial_1 one_side_chara by blast
        have "E F TS D D0"
          by (metis P2 ‹¬ Col D E F› ‹¬ Col F E D0› bet__ts bet_col 
              between_trivial not_col_permutation_1)
        show ?thesis
        proof cases
          assume "Col A' B' C'"
          show ?thesis
          proof cases
            assume "Bet A' B' C'"
            show ?thesis
            proof cases
              assume "Col D' E' F'"
              show ?thesis
              proof cases
                assume "Bet D' E' F'"
                have "A B C CongA G H I"
                proof -
                  have "A B C CongA D0 E F"
                  proof -
                    have "SAMS A B C D E F"
                      by (simp add: assms(1))
                    moreover have "SAMS D0 E F D E F"
                      by (metis P2 ‹¬ Col D E F› ‹¬ Col F E D0› bet__sams 
                          between_symmetry not_col_distincts sams_right_comm)
                    moreover have "A B C D E F SumA A' B' C'"
                      by (simp add: assms(3))
                    moreover have "D0 E F D E F SumA A' B' C'"
                    proof -
                      have "D E F D0 E F SumA A' B' C'"
                      proof -
                        have "F E D0 CongA D0 E F"
                          by (metis ‹¬ Col F E D0› col_trivial_1 col_trivial_2 
                              conga_pseudo_refl)
                        moreover have "¬ E F OS D D0"
                          using P2 col_trivial_1 one_side_chara by blast
                        moreover have "Coplanar D E F D0"
                          by (meson P2 bet__coplanar ncoplanar_perm_1)
                        moreover have "D E D0 CongA A' B' C'"
                          using assms(3) P2 ‹Bet A' B' C'› ‹¬ Col F E D0› 
                            conga_line not_col_distincts suma_distincts by auto
                        ultimately show ?thesis
                          using SumA_def by blast
                      qed
                      thus ?thesis
                        by (simp add: ‹D E F D0 E F SumA A' B' C'› suma_sym)
                    qed
                    ultimately show ?thesis
                      using sams2_suma2__conga123 by blast
                  qed
                  moreover have "D0 E F CongA G H I"
                  proof -
                    have "SAMS D E F D0 E F"
                      using P2 ‹¬ Col D E F› ‹¬ Col F E D0› bet__sams 
                        not_col_distincts sams_right_comm by auto
                    moreover have "D E F D0 E F SumA D' E' F'"
                    proof -
                      have "F E D0 CongA D0 E F"
                        by (metis (no_types) ‹¬ Col F E D0› col_trivial_1
                            col_trivial_2 conga_pseudo_refl)
                      moreover have "¬ E F OS D D0"
                        using P2 col_trivial_1 one_side_chara by blast
                      moreover have "Coplanar D E F D0"
                        using P2 bet__coplanar ncoplanar_perm_1 by blast
                      moreover have "D E D0 CongA D' E' F'"
                        using assms(3) P2 ‹Bet D' E' F'› ‹¬ Col F E D0› assms(4) 
                          conga_line not_col_distincts suma_distincts by auto
                      ultimately show ?thesis
                        using SumA_def by blast
                    qed
                    ultimately show ?thesis
                      using assms(2) assms(4) sams2_suma2__conga456 by auto
                  qed
                  ultimately show ?thesis
                    using conga_trans by blast
                qed
                hence "G H I CongA A B C"
                  using not_conga_sym by blast
                have "D' E' F' A B C SumA K L M"
                proof -
                  have "A' B' C' CongA D' E' F'"
                    by (metis suma_distincts ‹Bet A' B' C'› ‹Bet D' E' F'› 
                        assms(4) assms(5) conga_line)
                  thus ?thesis
                    by (meson conga3_suma__suma suma2__conga 
                        ‹G H I CongA A B C› assms(5))
                qed
                thus ?thesis
                  by (simp add: suma_sym)
              next
                assume "¬ Bet D' E' F'"
                hence "E' Out D' F'"
                  by (simp add: ‹Col D' E' F'› l6_4_2)
                have "D E F LeA D' E' F'"
                  using assms(2) assms(4) sams_suma__lea123789 by blast
                hence "E Out D F"
                  using ‹E' Out D' F'› out_lea__out by blast
                hence "Col D E F"
                  using Col_perm out_col by blast
                hence "False"
                  using ‹¬ Col D E F› by auto
                thus ?thesis by simp
              qed
            next
              assume "¬ Col D' E' F'"
              have "D E F CongA C B A0"
              proof -
                have "SAMS A B C D E F"
                  by (simp add: assms(1))
                moreover have "SAMS A B C C B A0"
                  using P1 ‹¬ Col A B C› ‹¬ Col C B A0› bet__sams not_col_distincts by auto
                moreover have "A B C D E F SumA A' B' C'"
                  by (simp add: assms(3))
                moreover have "A B C C B A0 SumA A' B' C'"
                proof -
                  have "A B C C B A0 SumA A B A0"
                    by (metis P1 ‹¬ Col A B C› ‹¬ Col C B A0› bet__suma 
                        col_trivial_1 col_trivial_2)
                  moreover have "A B C CongA A B C"
                    using ‹SAMS A B C C B A0› calculation 
                      sams2_suma2__conga123 by auto
                  moreover have "C B A0 CongA C B A0"
                    using ‹SAMS A B C C B A0› calculation(1) 
                      sams2_suma2__conga456 by auto
                  moreover have "A B A0 CongA A' B' C'"
                    using P1 ‹Bet A' B' C'› ‹¬ Col C B A0› assms(3) 
                      conga_line not_col_distincts suma_distincts by auto
                  ultimately show ?thesis
                    using conga3_suma__suma by blast
                qed
                ultimately show ?thesis
                  using sams2_suma2__conga456 by blast
              qed
              have "SAMS C B A0 G H I"
              proof -
                have "D E F CongA C B A0"
                  by (simp add: ‹D E F CongA C B A0›)
                moreover have "G H I CongA G H I"
                  using ‹¬ Col G H I› conga_refl not_col_distincts by fastforce
                moreover have "SAMS D E F G H I"
                  by (simp add: assms(2))
                ultimately show ?thesis
                  using conga2_sams__sams by blast
              qed
              then obtain J where P3: "A0 B J CongA G H I ∧ ¬ B A0 OS C J ∧ 
¬ C B TS A0 J ∧ Coplanar C B A0 J"
                using SAMS_def by blast
              obtain F1 where P4: "F E F1 CongA G H I ∧ ¬ E F OS D F1 ∧ 
¬ D E TS F F1 ∧ Coplanar D E F F1"
                using SAMS_def assms(2) by auto
              have "C B J CongA D' E' F'"
              proof -
                have "C B J CongA D E F1"
                proof -
                  have "(B A0 TS C J ∧ E F TS D F1) ∨ (B A0 OS C J ∧ E F OS D F1)"
                  proof -
                    have "B A0 TS C J"
                    proof -
                      have "Coplanar B A0 C J"
                        using P3 ncoplanar_perm_12 by blast
                      moreover have "¬ Col C B A0"
                        by (simp add: ‹¬ Col C B A0›)
                      moreover have "¬ Col J B A0"
                        using P3 ‹¬ Col G H I› col_conga_col not_col_permutation_3 by blast
                      moreover have "¬ B A0 OS C J"
                        using P3 by simp
                      ultimately show ?thesis
                        by (simp add: cop_nos__ts)
                    qed
                    moreover have "E F TS D F1"
                    proof -
                      have "Coplanar E F D F1"
                        using P4 ncoplanar_perm_12 by blast
                      moreover have "¬ Col D E F"
                        by (simp add: ‹¬ Col D E F›)
                      moreover have "¬ Col F1 E F"
                        using P4 ‹¬ Col G H I› col_conga_col col_permutation_3 by blast
                      moreover have "¬ E F OS D F1"
                        using P4 by auto
                      ultimately show ?thesis
                        by (simp add: cop_nos__ts)
                    qed
                    ultimately show ?thesis
                      by simp
                  qed
                  moreover have "C B A0 CongA D E F"
                    using ‹D E F CongA C B A0› not_conga_sym by blast
                  moreover have "A0 B J CongA F E F1"
                  proof -
                    have "A0 B J CongA G H I"
                      by (simp add: P3)
                    moreover have "G H I CongA F E F1"
                      using P4 not_conga_sym by blast
                    ultimately show ?thesis
                      using conga_trans by blast
                  qed
                  ultimately show ?thesis
                    using l11_22 by auto
                qed
                moreover have "D E F1 CongA D' E' F'"
                proof -
                  have "D E F G H I SumA D E F1"
                    using P4 SumA_def ‹¬ Col D E F› conga_distinct 
                      conga_refl not_col_distincts by auto
                  moreover have "D E F G H I SumA D' E' F'"
                    by (simp add: assms(4))
                  ultimately show ?thesis
                    using suma2__conga by auto
                qed
                ultimately show ?thesis
                  using conga_trans by blast
              qed
              show ?thesis
              proof -
                have "A B C D' E' F' SumA A B J"
                proof -
                  have "C B TS J A"
                  proof -
                    have "C B TS A0 A"
                    proof -
                      have "B ≠ A0"
                        using ‹¬ Col C B A0› not_col_distincts by blast
                      moreover have "¬ Col B C A"
                        using Col_cases ‹¬ Col A B C› by auto
                      moreover have "Bet A B A0"
                        by (simp add: P1)
                      ultimately show ?thesis
                        by (metis Bet_cases Col_cases ‹¬ Col C B A0› 
                            bet__ts invert_two_sides not_col_distincts)
                    qed
                    moreover have "C B OS A0 J"
                    proof -
                      have "¬ Col J C B"
                        using ‹C B J CongA D' E' F'› ‹¬ Col D' E' F'› 
                          col_conga_col not_col_permutation_2 by blast
                      moreover have "¬ Col A0 C B"
                        using Col_cases ‹¬ Col C B A0› by blast
                      ultimately show ?thesis
                        using P3 cop_nos__ts by blast
                    qed
                    ultimately show ?thesis
                      using l9_8_2 by blast
                  qed
                  moreover have "C B J CongA D' E' F'"
                    by (simp add: ‹C B J CongA D' E' F'›)
                  moreover have "¬ B C OS A J"
                    using calculation(1) invert_one_side l9_9_bis 
                      one_side_symmetry by blast
                  moreover have "Coplanar A B C J"
                    using calculation(1) ncoplanar_perm_15 ts__coplanar by blast
                  moreover have "A B J CongA A B J"
                  proof -
                    have "A ≠ B"
                      using ‹¬ Col A B C› col_trivial_1 by auto
                    moreover have "B ≠ J"
                      using ‹C B TS J A› ts_distincts by blast
                    ultimately show ?thesis
                      using conga_refl by auto
                  qed
                  ultimately show ?thesis
                    using SumA_def by blast
                qed
                moreover have "A B J CongA K L M"
                proof -
                  have "A' B' C' G H I SumA A B J"
                  proof -
                    have "A B A0 CongA A' B' C'"
                      using P1 ‹Bet A' B' C'› ‹¬ Col A B C› ‹¬ Col C B A0› 
                        assms(5) conga_line not_col_distincts suma_distincts by auto
                    moreover have "A0 B J CongA G H I"
                      by (simp add: P3)
                    moreover have "A B A0 A0 B J SumA A B J"
                    proof -
                      have "A0 B J CongA A0 B J"
                      proof -
                        have "A0 ≠ B"
                          using ‹¬ Col C B A0› col_trivial_2 by auto
                        moreover have "B ≠ J"
                          using CongA_def ‹A0 B J CongA G H I› by blast
                        ultimately show ?thesis
                          using conga_refl by auto
                      qed
                      moreover have "¬ B A0 OS A J"
                        by (simp add: Col_def P1 col123__nos)
                      moreover have "Coplanar A B A0 J"
                        using P1 bet__coplanar by auto
                      moreover have "A B J CongA A B J"
                        using P1 ‹¬ Col A B C› between_symmetry calculation(1) 
                          l11_13 not_col_distincts by blast
                      ultimately show ?thesis
                        using SumA_def by blast
                    qed
                    ultimately show ?thesis
                      by (meson conga3_suma__suma suma2__conga)
                  qed
                  moreover have "A' B' C' G H I SumA K L M"
                    by (simp add: assms(5))
                  ultimately show ?thesis
                    using suma2__conga by auto
                qed
                ultimately show ?thesis
                proof -
                  have "A B C CongA A B C ∧ D' E' F' CongA D' E' F'"
                    using CongA_def ‹A B J CongA K L M› ‹C B J CongA D' E' F'› 
                      conga_refl by presburger
                  thus ?thesis
                    using ‹A B C D' E' F' SumA A B J› ‹A B J CongA K L M› 
                      conga3_suma__suma by blast
                qed
              qed
            qed
          next
            assume "¬ Bet A' B' C'"
            have "B Out A C"
            proof -
              have "A B C LeA A' B' C'" 
                using assms(1) assms(3) sams_suma__lea123789 by auto
              moreover have "B' Out A' C'"
                using ‹Col A' B' C'› ‹¬ Bet A' B' C'› or_bet_out by blast
              ultimately show ?thesis
                using out_lea__out by blast
            qed
            hence "Col A B C"
              using Col_perm out_col by blast
            hence "False"
              using ‹¬ Col A B C› by auto
            thus ?thesis by simp
          qed
        next
          assume "¬ Col A' B' C'"
          obtain C1 where P6: "C B C1 CongA D E F ∧ ¬ B C OS A C1 ∧ 
¬ A B TS C C1 ∧ Coplanar A B C C1"
            using SAMS_def assms(1) by auto
          have P6A: "C B C1 CongA D E F"
            using P6 by simp
          have P6B: "¬ B C OS A C1"
            using P6 by simp
          have P6C: "¬ A B TS C C1"
            using P6 by simp
          have P6D: "Coplanar A B C C1"
            using P6 by simp
          have "A' B' C' CongA A B C1"
          proof -
            have "A B C D E F SumA A B C1"
              using P6A P6B P6D SumA_def ‹¬ Col A B C› conga_distinct conga_refl 
                not_col_distincts by auto
            moreover have "A B C D E F SumA A' B' C'"
              by (simp add: assms(3))
            ultimately show ?thesis
              using suma2__conga by auto
          qed
          have "B C1 OS C A"
          proof -
            have "B A OS C C1"
            proof -
              have "A B OS C C1"
              proof -
                have "¬ Col C A B"
                  using Col_perm ‹¬ Col A B C› by blast
                moreover have "¬ Col C1 A B"
                  using ‹¬ Col A' B' C'› ‹A' B' C' CongA A B C1› col_permutation_1 
                    ncol_conga_ncol by blast
                ultimately show ?thesis
                  using P6C P6D cop_nos__ts by blast
              qed
              thus ?thesis
                by (simp add: invert_one_side)
            qed
            moreover have "B C TS A C1"
            proof -
              have "Coplanar B C A C1"
                using P6D ncoplanar_perm_12 by blast
              moreover have "¬ Col C1 B C"
              proof -
                have "D E F CongA C1 B C"
                  using P6A conga_left_comm not_conga_sym by blast
                thus ?thesis
                  using  ‹¬ Col D E F› ncol_conga_ncol by blast
              qed
              ultimately show ?thesis
                using T1 P6B cop_nos__ts by blast
            qed
            ultimately show ?thesis
              using os_ts1324__os one_side_symmetry by blast
          qed
          show ?thesis
          proof cases
            assume "Col D' E' F'"
            show ?thesis
            proof cases
              assume "Bet D' E' F'"
              obtain C0 where P7: "Bet C B C0 ∧ Cong C B B C0"
                using Cong_perm segment_construction by blast
              have "B C1 TS C C0"
                by (metis P7 ‹B C1 OS C A› bet__ts cong_diff_2 not_col_distincts 
                    one_side_not_col123)
              show ?thesis
              proof -
                have "A B C C B C0 SumA A B C0"
                proof -
                  have "C B C0 CongA C B C0"
                    by (metis P7 T1 cong_diff conga_line not_col_distincts)
                  moreover have "¬ B C OS A C0"
                    using P7 bet_col col124__nos invert_one_side by blast
                  moreover have "Coplanar A B C C0"
                    using P7 bet__coplanar ncoplanar_perm_15 by blast
                  moreover have "A B C0 CongA A B C0"
                    by (metis P7 T1 cong_diff conga_refl not_col_distincts)
                  ultimately show ?thesis
                    using SumA_def by blast
                qed
                moreover have "A B C0 CongA K L M"
                proof -
                  have "A' B' C' G H I SumA A B C0"
                  proof -
                    have "A B C1 C1 B C0 SumA A B C0"
                      using ‹B C1 TS C C0› ‹B C1 OS C A› l9_8_2 ts__suma_1 by blast
                    moreover have "A B C1 CongA A' B' C'"
                      by (simp add: P6 ‹A' B' C' CongA A B C1› conga_sym)
                    moreover have "C1 B C0 CongA G H I"
                    proof -
                      have "SAMS C B C1 C1 B C0"
                        by (metis P7 ‹B C1 TS C C0› bet__sams ts_distincts)
                      moreover have "SAMS C B C1 G H I"
                      proof -
                        have "D E F CongA C B C1"
                          using P6A not_conga_sym by blast
                        moreover have "G H I CongA G H I"
                          using ‹¬ Col G H I› conga_refl not_col_distincts by fastforce
                        moreover have "SAMS D E F G H I"
                          by (simp add: assms(2))
                        ultimately show ?thesis
                          using conga2_sams__sams by blast
                      qed
                      moreover have "C B C1 C1 B C0 SumA C B C0"
                        by (simp add: ‹B C1 TS C C0› ts__suma_1)
                      moreover have "C B C1 G H I SumA C B C0"
                      proof -
                        have "D E F G H I SumA D' E' F'"
                          by (simp add: assms(4))
                        moreover have "D E F CongA C B C1"
                          using P6A not_conga_sym by blast
                        moreover have "G H I CongA G H I"
                          using ‹¬ Col G H I› conga_refl not_col_distincts by fastforce
                        moreover have "D' E' F' CongA C B C0" using P7 assms(4)
                          by (metis P6A suma_distincts ‹Bet D' E' F'› 
                              cong_diff conga_diff1 conga_line)
                        ultimately show ?thesis
                          using conga3_suma__suma by blast
                      qed
                      ultimately show ?thesis
                        using sams2_suma2__conga456 by auto
                    qed
                    moreover have "A B C0 CongA A B C0"
                      by (metis P7 T1 cong_diff conga_refl not_col_distincts)
                    ultimately show ?thesis
                      using conga3_suma__suma by blast
                  qed
                  thus ?thesis
                    using assms(5) suma2__conga by auto
                qed
                moreover have "A B C CongA A B C"
                proof -
                  have "A ≠ B ∧ B ≠ C"
                    using T1 col_trivial_1 col_trivial_2 by auto
                  thus ?thesis
                    using conga_refl by auto
                qed
                moreover have "C B C0 CongA D' E' F'"
                proof -
                  have "C ≠ B"
                    using T1 col_trivial_2 by blast
                  moreover have "B ≠ C0"
                    using ‹B C1 TS C C0› ts_distincts by blast
                  moreover have "D' ≠ E'"
                    using assms(4) suma_distincts by blast
                  moreover have "E' ≠ F'"
                    using assms(4) suma_distincts by auto
                  ultimately show ?thesis
                    by (simp add: P7 ‹Bet D' E' F'› conga_line)
                qed
                ultimately show ?thesis
                  using conga3_suma__suma by blast
              qed
            next
              assume "¬ Bet D' E' F'"
              hence "E' Out D' F'"
                by (simp add: ‹Col D' E' F'› l6_4_2)
              have "D E F LeA D' E' F'"
                using sams_suma__lea123789 assms(2) assms(4) by auto
              hence "E Out D F"
                using ‹E' Out D' F'› out_lea__out by blast
              hence "False"
                using Col_cases ‹¬ Col D E F› out_col by blast
              thus ?thesis by simp
            qed
          next
            assume "¬ Col D' E' F'"
            have "SAMS C B C1 G H I"
            proof -
              have "D E F CongA C B C1"
                using P6A not_conga_sym by blast
              moreover have "G H I CongA G H I"
                using ‹¬ Col G H I› conga_refl not_col_distincts by fastforce
              ultimately show ?thesis
                using assms(2) conga2_sams__sams by blast
            qed
            then obtain J where P7: "C1 B J CongA G H I ∧ ¬ B C1 OS C J ∧ 
¬ C B TS C1 J ∧ Coplanar C B C1 J"
              using SAMS_def by blast
            have P7A: "C1 B J CongA G H I"
              using P7 by simp
            have P7B: "¬ B C1 OS C J"
              using P7 by simp
            have P7C: "¬ C B TS C1 J"
              using P7 by simp
            have P7D: "Coplanar C B C1 J"
              using P7 by simp
            obtain F1 where P8: "F E F1 CongA G H I ∧ ¬ E F OS D F1 ∧ 
¬ D E TS F F1 ∧ Coplanar D E F F1"
              using SAMS_def assms(2) by auto
            have P8A: "F E F1 CongA G H I"
              using P8 by simp
            have P8B: "¬ E F OS D F1"
              using P8 by simp
            have P8C: "¬ D E TS F F1"
              using P8 by simp
            have P8D: "Coplanar D E F F1"
              using P8 by simp
            have "C B J CongA D' E' F'"
            proof -
              have "C B J CongA D E F1"
              proof -
                have "B C1 TS C J"
                proof -
                  have "Coplanar B C1 C J"
                    using P7D ncoplanar_perm_12 by blast
                  moreover have "¬ Col C B C1"
                    using ‹B C1 OS C A› not_col_permutation_2 
                      one_side_not_col123 by blast
                  moreover have "¬ Col J B C1"
                    using P7 ‹¬ Col G H I› col_conga_col not_col_permutation_3 by blast
                  moreover have "¬ B C1 OS C J"
                    by (simp add: P7B)
                  ultimately show ?thesis
                    by (simp add: cop_nos__ts)
                qed
                moreover have "E F TS D F1"
                proof -
                  have "Coplanar E F D F1"
                    using P8D ncoplanar_perm_12 by blast
                  moreover have "¬ Col F1 E F"
                    using P8 ‹¬ Col G H I› col_conga_col 
                      not_col_permutation_3 by blast
                  ultimately show ?thesis
                    using P8B ‹¬ Col D E F› cop_nos__ts by blast
                qed
                moreover have "C B C1 CongA D E F"
                  using P6A by blast
                moreover have "C1 B J CongA F E F1"
                  using P8 by (meson P7A not_conga not_conga_sym)
                ultimately show ?thesis
                  using l11_22a by blast
              qed
              moreover have "D E F1 CongA D' E' F'"
              proof -
                have "D E F G H I SumA D E F1"
                  using P8A P8B P8D SumA_def ‹¬ Col D E F› conga_distinct 
                    conga_refl not_col_distincts by auto
                moreover have "D E F G H I SumA D' E' F'"
                  by (simp add: assms(4))
                ultimately show ?thesis
                  using suma2__conga by auto
              qed
              ultimately show ?thesis
                using conga_trans by blast
            qed
            have "¬ Col C B C1"
              using ‹B C1 OS C A› col123__nos col_permutation_1 by blast
            show ?thesis
            proof -
              have "A B C C B J SumA A B J"
              proof -
                have "B C TS J A"
                proof -
                  have "B C TS C1 A" using cop_nos__ts
                    using P6B P6D T1 ‹¬ Col C B C1› l9_2 ncoplanar_perm_12 
                      not_col_permutation_3 by blast
                  moreover have "B C OS C1 J"
                  proof -
                    have "¬ Col C1 C B"
                      using Col_perm ‹¬ Col C B C1› by blast
                    moreover have "¬ Col J C B"
                      using ‹C B J CongA D' E' F'› ‹¬ Col D' E' F'› col_conga_col 
                        col_permutation_1 by blast
                    ultimately show ?thesis
                      using P7C P7D cop_nos__ts invert_one_side by blast
                  qed
                  ultimately show ?thesis
                    using l9_8_2 by blast
                qed
                thus ?thesis
                  by (simp add: l9_2 ts__suma_1)
              qed
              moreover have "A B C CongA A B C"
                using T1 conga_refl not_col_distincts by fastforce
              moreover have "A B J CongA K L M"
              proof -
                have "A' B' C' G H I SumA A B J"
                proof -
                  have "A B C1 C1 B J SumA A B J"
                  proof -
                    have "B C1 TS A J"
                    proof -
                      have "B C1 TS C J"
                      proof -
                        have "Coplanar B C1 C J"
                          using P7D ncoplanar_perm_12 by blast
                        moreover have "¬ Col J B C1"
                          using P7 ‹¬ Col G H I› col_conga_col 
                            not_col_permutation_3 by blast
                        ultimately show ?thesis
                          by (simp add: ‹¬ Col C B C1› P7B cop_nos__ts)
                      qed
                      moreover have "B C1 OS C A"
                        by (simp add: ‹B C1 OS C A›)
                      ultimately show ?thesis
                        using l9_8_2 by blast
                    qed
                    thus ?thesis
                      by (simp add: ts__suma_1)
                  qed
                  moreover have "A B C1 CongA A' B' C'"
                    using ‹A' B' C' CongA A B C1› not_conga_sym by blast
                  moreover have "C1 B J CongA G H I"
                    by (simp add: P7A)
                  moreover have "A B J CongA A B J"
                    using ‹A B C C B J SumA A B J› suma2__conga by auto
                  ultimately show ?thesis
                    using conga3_suma__suma by blast
                qed
                moreover have "A' B' C' G H I SumA K L M"
                  using assms(5) by simp
                ultimately show ?thesis
                  using suma2__conga by auto
              qed
              ultimately show ?thesis
                using  ‹C B J CongA D' E' F'› conga3_suma__suma by blast
            qed
          qed
        qed
      qed
    qed
  qed
qed

lemma suma_assoc_2:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'" and
    "A B C D' E' F' SumA K L M"
  shows "A' B' C' G H I SumA K L M"
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) sams_sym suma_assoc_1 suma_sym)

lemma suma_assoc:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'"
  shows
    "A' B' C' G H I SumA K L M ⟷ A B C D' E' F' SumA K L M"
  by (meson assms(1) assms(2) assms(3) assms(4) suma_assoc_1 suma_assoc_2)

lemma sams_assoc_1:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'" and
    "SAMS A' B' C' G H I"
  shows "SAMS A B C D' E' F'"
proof cases
  assume "Col A B C"
  {
    assume "E Out D F"
    have "SAMS A B C D' E' F'"
    proof -
      have "A' B' C' CongA A B C"
        using assms(3) ‹E Out D F› conga_sym out546_suma__conga by blast
      moreover have "G H I CongA D' E' F'"
        using ‹E Out D F› assms(4) out213_suma__conga by blast
      ultimately show ?thesis
        using assms(5) conga2_sams__sams by blast
    qed
  }
  {
    assume "¬ Bet A B C"
    hence P1: "B Out A C"
      using ‹Col A B C› or_bet_out by blast
    have "SAMS D' E' F' A B C"
    proof -
      have "D' ≠ E'"
        using assms(4) suma_distincts by auto
      moreover have "F' E' F' CongA A B C"
      proof -
        have "E' ≠ F'"
          using assms(4) suma_distincts by blast
        hence "E' Out F' F'"
          using out_trivial by auto
        thus ?thesis
          using P1 l11_21_b by blast
      qed
      moreover have "¬ E' F' OS D' F'"
        using os_distincts by blast
      moreover have "¬ D' E' TS F' F'"
        by (simp add: not_two_sides_id)
      moreover have "Coplanar D' E' F' F'"
        using ncop_distincts by blast
      ultimately show ?thesis using SAMS_def P1 by blast
    qed
    hence "SAMS A B C D' E' F'"
      using sams_sym by blast
  }
  thus ?thesis
    using SAMS_def assms(1) ‹E Out D F ⟹ SAMS A B C D' E' F'› by blast
next
  assume "¬ Col A B C"
  show ?thesis
  proof cases
    assume "Col D E F"
    have "H Out G I ∨ ¬ Bet D E F"
      using SAMS_def assms(2) by blast
    {
      assume "H Out G I"
      have "SAMS A B C D' E' F'"
      proof -
        have "A B C CongA A B C"
          using ‹¬ Col A B C› conga_refl not_col_distincts by fastforce
        moreover have "D E F CongA D' E' F'"
          using ‹H Out G I› assms(4) out546_suma__conga by blast
        ultimately show ?thesis
          using assms(1) conga2_sams__sams by blast
      qed
    }
    {
      assume "¬ Bet D E F"
      hence "E Out D F"
        using ‹Col D E F› l6_4_2 by blast
      have "SAMS A B C D' E' F'"
      proof -
        have "A' B' C' CongA A B C"
          using out546_suma__conga ‹E Out D F› assms(3) not_conga_sym by blast
        moreover have "G H I CongA D' E' F'"
          using out213_suma__conga ‹E Out D F› assms(4) by auto
        ultimately show ?thesis
          using assms(5) conga2_sams__sams by auto
      qed
    }
    thus ?thesis
      using ‹H Out G I ⟹ SAMS A B C D' E' F'› ‹H Out G I ∨ ¬ Bet D E F› by blast
  next
    assume "¬ Col D E F"
    show ?thesis
    proof cases
      assume "Col G H I"
      have "SAMS G H I D E F"
        by (simp add: assms(2) sams_sym)
      hence "E Out D F ∨ ¬ Bet G H I"
        using SAMS_def by blast
      {
        assume "E Out D F"
        hence "False"
          using Col_cases ‹¬ Col D E F› out_col by blast
        hence "SAMS A B C D' E' F'"
          by simp
      }
      {
        assume "¬ Bet G H I"
        hence "H Out G I"
          by (simp add: ‹Col G H I› l6_4_2)
        have "SAMS A B C D' E' F'"
        proof -
          have "A B C CongA A B C"
            by (metis ‹¬ Col A B C› col_trivial_1 col_trivial_2 conga_refl)
          moreover have "D E F CongA D' E' F'"
            using out546_suma__conga ‹H Out G I› assms(4) by blast
          moreover have "SAMS A B C D E F"
            using assms(1) by auto
          ultimately show ?thesis
            using conga2_sams__sams by auto
        qed
      }
      thus ?thesis
        using ‹E Out D F ∨ ¬ Bet G H I› ‹E Out D F ⟹ SAMS A B C D' E' F'› by blast
    next
      assume "¬ Col G H I"
      show ?thesis
      proof -
        have "¬ Bet A B C"
          using Col_def ‹¬ Col A B C› by auto
        moreover have "∃ J. (C B J CongA D' E' F' ∧ ¬ B C OS A J ∧ 
¬ A B TS C J ∧ Coplanar A B C J)"
        proof -
          have "¬ Col A' B' C'"
          proof -
            {
              assume "Col A' B' C'"
              have "H Out G I ∨ ¬ Bet A' B' C'"
                using SAMS_def assms(5) by blast
              {
                assume "H Out G I"
                hence "False"
                  using Col_cases ‹¬ Col G H I› out_col by blast
              }
              {
                assume "¬ Bet A' B' C'"
                hence "B' Out A' C'"
                  using not_bet_out ‹Col A' B' C'› by blast
                have "A B C LeA A' B' C'"
                  using assms(1) assms(3) sams_suma__lea123789 by auto
                hence "B Out A C"
                  using ‹B' Out A' C'› out_lea__out by blast
                hence "Col A B C"
                  using Col_perm out_col by blast
                hence "False"
                  using ‹¬ Col A B C› by auto
              }
              hence "False"
                using ‹H Out G I ⟹ False› ‹H Out G I ∨ ¬ Bet A' B' C'› by blast
            }
            thus ?thesis by blast
          qed
          obtain C1 where P1: "C B C1 CongA D E F ∧ ¬ B C OS A C1 ∧ 
¬ A B TS C C1 ∧ Coplanar A B C C1"
            using SAMS_def assms(1) by auto
          have P1A: "C B C1 CongA D E F"
            using P1 by simp
          have P1B: "¬ B C OS A C1"
            using P1 by simp
          have P1C: "¬ A B TS C C1"
            using P1 by simp
          have P1D: "Coplanar A B C C1"
            using P1 by simp
          have "A B C1 CongA A' B' C'"
          proof -
            have "A B C D E F SumA A B C1"
              using P1A P1B P1D SumA_def ‹¬ Col A B C› conga_distinct 
                conga_refl not_col_distincts by auto
            thus ?thesis
              using assms(3) suma2__conga by auto
          qed
          have "SAMS C B C1 G H I"
          proof -
            have "D E F CongA C B C1"
              using P1A not_conga_sym by blast
            moreover have "G H I CongA G H I"
              using ‹¬ Col G H I› conga_refl not_col_distincts by fastforce
            ultimately show ?thesis using conga2_sams__sams
              using assms(2) by blast
          qed
          then obtain J where T1: "C1 B J CongA G H I ∧ ¬ B C1 OS C J ∧
¬ C B TS C1 J ∧ Coplanar C B C1 J"
            using SAMS_def by auto
          have T1A: "C1 B J CongA G H I"
            using T1 by simp
          have T1B: "¬ B C1 OS C J"
            using T1 by simp
          have T1C: "¬ C B TS C1 J"
            using T1 by simp
          have T1D: "Coplanar C B C1 J"
            using T1 by simp
          have "SAMS A B C1 C1 B J"
          proof -
            have "A' B' C' CongA A B C1"
              using ‹A B C1 CongA A' B' C'› not_conga_sym by blast
            moreover have "G H I CongA C1 B J"
              using T1A not_conga_sym by blast
            ultimately show ?thesis
              using assms(5) conga2_sams__sams by auto
          qed
          then obtain J' where T2: "C1 B J' CongA C1 B J ∧ ¬ B C1 OS A J' ∧ 
¬ A B TS C1 J' ∧ Coplanar A B C1 J'"
            using SAMS_def by auto
          have T2A: "C1 B J' CongA C1 B J"
            using T2 by simp
          have T2B: "¬ B C1 OS A J'"
            using T2 by simp
          have T2C: "¬ A B TS C1 J'"
            using T2 by simp
          have T2D: "Coplanar A B C1 J'"
            using T2 by simp
          have "A' B' C' CongA A B C1"
            using ‹A B C1 CongA A' B' C'› not_conga_sym by blast
          hence "¬ Col A B C1"
            using ncol_conga_ncol ‹¬ Col A' B' C'› by blast
          have "D E F CongA C B C1"
            using P1A not_conga_sym by blast
          hence "¬ Col C B C1"
            using ncol_conga_ncol ‹¬ Col D E F› by blast
          hence "Coplanar C1 B A J"
            using coplanar_trans_1 P1D T1D coplanar_perm_15 
              coplanar_perm_6 by blast
          have "Coplanar C1 B J' J"
            using T2D ‹Coplanar C1 B A J› ‹¬ Col A B C1› coplanar_perm_14 
              coplanar_perm_6 coplanar_trans_1 by blast
          have "B Out J' J ∨ C1 B TS J' J"
            by (meson T2 ‹Coplanar C1 B A J› ‹¬ Col A B C1› conga_cop__or_out_ts 
                coplanar_trans_1 ncoplanar_perm_14 ncoplanar_perm_6)
          {
            assume "B Out J' J"
            have "∃ J. (C B J CongA D' E' F' ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J)"
            proof -
              have "C B C1 C1 B J SumA C B J"
              proof -
                have "C1 B J CongA C1 B J"
                  using CongA_def T2A conga_refl by auto
                moreover have "C B J CongA C B J"
                  using ‹¬ Col C B C1› calculation conga_diff56 
                    conga_pseudo_refl conga_right_comm not_col_distincts by blast
                ultimately show ?thesis
                  using T1D T1B SumA_def by blast
              qed
              hence "D E F G H I SumA C B J"
                using conga3_suma__suma by (meson P1A T1A suma2__conga)
              hence "C B J CongA D' E' F'"
                using assms(4) suma2__conga by auto
              moreover have "¬ B C OS A J"
                by (metis Col_perm P1B P1D T1C ‹¬ Col A B C› 
                    ‹¬ Col C B C1› cop_nos__ts coplanar_perm_8 invert_two_sides 
                    l9_2 l9_8_2)
              moreover have "¬ A B TS C J"
              proof cases
                assume "Col A B J"
                thus ?thesis
                  using TS_def invert_two_sides not_col_permutation_3 by blast
              next
                assume "¬ Col A B J"
                have "A B OS C J"
                proof -
                  have "A B OS C C1"
                    by (simp add: P1C P1D ‹¬ Col A B C1› ‹¬ Col A B C› cop_nts__os 
                        not_col_permutation_2)
                  moreover have "A B OS C1 J"
                  proof -
                    have "A B OS C1 J'"
                      by (metis T2C T2D ‹B Out J' J› ‹¬ Col A B C1› ‹¬ Col A B J› 
                          col_trivial_2 colx cop_nts__os not_col_permutation_2 
                          out_col out_distinct)
                    thus ?thesis
                      using ‹B Out J' J› invert_one_side out_out_one_side by blast
                  qed
                  ultimately show ?thesis
                    using one_side_transitivity by blast
                qed
                thus ?thesis
                  using l9_9 by blast
              qed
              moreover have "Coplanar A B C J"
                by (meson P1D ‹Coplanar C1 B A J› ‹¬ Col A B C1› coplanar_perm_18 
                    coplanar_perm_2 coplanar_trans_1 not_col_permutation_2)
              ultimately show ?thesis
                by blast
            qed
          }
          {
            assume "C1 B TS J' J"
            have "B C1 OS C J"
            proof -
              have "B C1 TS C J'"
              proof -
                have "B C1 TS A J'"
                  by (meson T2B T2D TS_def ‹C1 B TS J' J› ‹¬ Col A B C1› 
                      cop_nts__os invert_two_sides ncoplanar_perm_12)
                moreover have "B C1 OS A C"
                  by (meson P1B P1C P1D ‹¬ Col A B C1› ‹¬ Col A B C› ‹¬ Col C B C1› 
                      cop_nts__os invert_one_side ncoplanar_perm_12 
                      not_col_permutation_2 not_col_permutation_3 os_ts1324__os)
                ultimately show ?thesis
                  using l9_8_2 by blast
              qed
              moreover have "B C1 TS J J'"
                using ‹C1 B TS J' J› invert_two_sides l9_2 by blast
              ultimately show ?thesis
                using OS_def by blast
            qed
            hence "False"
              by (simp add: T1B)
            hence "∃ J. (C B J CongA D' E' F' ∧ ¬ B C OS A J ∧ ¬ A B TS C J ∧ Coplanar A B C J)"
              by auto
          }
          thus ?thesis
            using ‹B Out J' J ⟹ ∃J. C B J CongA D' E' F' ∧ ¬ B C OS A J ∧ 
  ¬ A B TS C J ∧ Coplanar A B C J› 
              ‹B Out J' J ∨ C1 B TS J' J› by blast
        qed
        ultimately show ?thesis
          using SAMS_def not_bet_distincts by auto
      qed
    qed
  qed
qed

lemma sams_assoc_2:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'" and
    "SAMS A B C D' E' F'"
  shows "SAMS A' B' C' G H I"
proof -
  have "SAMS G H I A' B' C'"
  proof -
    have "SAMS G H I D E F"
      by (simp add: assms(2) sams_sym)
    moreover have "SAMS D E F A B C"
      by (simp add: assms(1) sams_sym)
    moreover have "G H I D E F SumA D' E' F'"
      by (simp add: assms(4) suma_sym)
    moreover have "D E F A B C SumA A' B' C'"
      by (simp add: assms(3) suma_sym)
    moreover have "SAMS D' E' F' A B C"
      by (simp add: assms(5) sams_sym)
    ultimately show ?thesis
      using sams_assoc_1 by blast
  qed
  thus ?thesis
    using sams_sym by blast
qed

lemma sams_assoc:
  assumes "SAMS A B C D E F" and
    "SAMS D E F G H I" and
    "A B C D E F SumA A' B' C'" and
    "D E F G H I SumA D' E' F'"
  shows "(SAMS A' B' C' G H I) ⟷ (SAMS A B C D' E' F')"
  using sams_assoc_1 sams_assoc_2 by (meson assms(1) assms(2) assms(3) assms(4))

lemma sams_nos__nts:
  assumes "SAMS A B C C B J" and
    "¬ B C OS A J"
  shows "¬  A B TS C J"
proof -
  obtain J' where P1: "C B J' CongA C B J ∧ ¬ B C OS A J' ∧ ¬ A B TS C J' ∧ Coplanar A B C J'"
    using SAMS_def assms(1) by blast
  have P1A: "C B J' CongA C B J"
    using P1 by simp
  have P1B: "¬ B C OS A J'"
    using P1 by simp
  have P1C: "¬ A B TS C J'"
    using P1 by simp
  have P1D: "Coplanar A B C J'"
    using P1 by simp
  have P2: "B Out C J ∨ ¬ Bet A B C"
    using SAMS_def assms(1) by blast
  {
    assume "A B TS C J"
    have "Coplanar C B J J'"
    proof -
      have "¬ Col A C B"
        using TS_def ‹A B TS C J› not_col_permutation_4 by blast
      moreover have "Coplanar A C B J"
        using ‹A B TS C J› ncoplanar_perm_2 ts__coplanar by blast
      moreover have "Coplanar A C B J'"
        using P1D ncoplanar_perm_2 by blast
      ultimately show ?thesis
        using coplanar_trans_1 by blast
    qed
    have "B Out J J' ∨ C B TS J J'"
      by (metis P1 ‹A B TS C J› ‹Coplanar C B J J'› bet_conga__bet bet_out 
          col_conga_col col_two_sides_bet conga_distinct conga_os__out conga_sym cop_nts__os invert_two_sides l5_2 l6_6 not_col_permutation_3 not_col_permutation_4)
    {
      assume "B Out J J'"
      have "¬ Col B A J ∨ ¬ Col B A J'"
        using TS_def ‹A B TS C J› not_col_permutation_3 by blast
      hence "A B OS C J'"
        by (metis ‹B Out J J'› Col_cases P1C P1D TS_def 
            ‹A B TS C J› col2__eq cop_nts__os l6_3_1 out_col)
      hence "A B TS C J'"
        by (meson ‹A B TS C J› ‹B Out J J'› l6_6 l9_2 not_col_distincts 
            out_two_sides_two_sides)
      hence "False"
        by (simp add: P1C)
    }
    {
      assume "C B TS J J'"
      hence "¬ Col C A B ∧ ¬ Col J A B"
        using TS_def ‹A B TS C J› by blast
      hence "False"
        by (metis P1B P1D TS_def ‹C B TS J J'› assms(2) cop_nts__os 
            invert_two_sides l9_8_1 ncoplanar_perm_12 not_col_permutation_1)
    }
    hence "False"
      using ‹B Out J J' ⟹ False› ‹B Out J J' ∨ C B TS J J'› by blast
  }
  thus ?thesis by auto
qed

lemma conga_sams_nos__nts:
  assumes "SAMS A B C D E F" and
    "C B J CongA D E F" and
    "¬ B C OS A J"
  shows "¬ A B TS C J"
proof -
  have "SAMS A B C C B J"
  proof -
    have "A B C CongA A B C"
      using assms(1) conga_refl sams_distincts by fastforce
    moreover have "D E F CongA C B J"
      using assms(2) not_conga_sym by blast
    ultimately show ?thesis
      using assms(1) conga2_sams__sams by auto
  qed
  thus ?thesis
    by (simp add: assms(3) sams_nos__nts)
qed

lemma sams_lea2_suma2__conga123:
  assumes "A B C LeA A' B' C'" and
    "D E F LeA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G H I"
  shows "A B C CongA A' B' C'"
proof -
  have "SAMS A B C D E F"
    using assms(1) assms(2) assms(3) sams_lea2__sams by blast
  moreover have "SAMS A' B' C' D E F"
    by (metis assms(2) assms(3) lea_refl sams_distincts sams_lea2__sams)
  moreover have "A' B' C' D E F SumA G H I"
  proof -
    obtain G' H' I' where P1: "A' B' C' D E F SumA G' H' I'"
      using calculation(2) ex_suma sams_distincts by blast
    show ?thesis
    proof -
      have "A' ≠ B' ∧ B' ≠ C'"
        using assms(1) lea_distincts by blast
      hence "A' B' C' CongA A' B' C'"
        using conga_refl by auto
      moreover
      have "D ≠ E ∧ E ≠ F"
        using ‹SAMS A B C D E F› sams_distincts by blast
      hence "D E F CongA D E F"
        using conga_refl by auto
      moreover have "G' H' I' CongA G H I"
      proof -
        have "G' H' I' LeA G H I"
          using P1 assms(2) assms(3) assms(5) sams_lea456_suma2__lea by blast
        moreover have "G H I LeA G' H' I'"
        proof -
          have "SAMS A' B' C' D E F"
            using ‹SAMS A' B' C' D E F› by auto
          thus ?thesis
            using P1 assms(1) assms(4) sams_lea123_suma2__lea by blast
        qed
        ultimately show ?thesis
          by (simp add: lea_asym)
      qed
      ultimately show ?thesis
        using P1 conga3_suma__suma by blast
    qed
  qed
  ultimately show ?thesis
    using assms(4) sams2_suma2__conga123 by blast
qed

lemma sams_lea2_suma2__conga456:
  assumes "A B C LeA A' B' C'" and
    "D E F LeA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G H I"
  shows "D E F CongA D' E' F'"
proof -
  have "SAMS D' E' F' A' B' C'"
    by (simp add: assms(3) sams_sym)
  moreover have "D E F A B C SumA G H I"
    by (simp add: assms(4) suma_sym)
  moreover have "D' E' F' A' B' C' SumA G H I"
    by (simp add: assms(5) suma_sym)
  ultimately show ?thesis
    using assms(1) assms(2) sams_lea2_suma2__conga123 by auto
qed

lemma sams_suma__out213:
  assumes "A B C D E F SumA D E F" and
    "SAMS A B C D E F"
  shows "B Out A C"
proof -
  have "E ≠ D"
    using assms(2) sams_distincts by blast
  hence "E Out D D"
    using out_trivial by auto
  moreover have "D E D CongA A B C"
  proof -
    have "D E D LeA A B C"
      using assms(1) lea121345 suma_distincts by auto
    moreover
    have "E ≠ D ∧ E ≠ F"
      using assms(2) sams_distincts by blast
    hence "D E F LeA D E F"
      using lea_refl by auto
    moreover have "D E D D E F SumA D E F"
    proof -
      have "¬ E D OS D F"
        using os_distincts by auto
      moreover have "Coplanar D E D F"
        using ncop_distincts by auto
      ultimately show ?thesis
        using SumA_def ‹D E F LeA D E F› lea_asym by blast
    qed
    ultimately show ?thesis
      using assms(1) assms(2) sams_lea2_suma2__conga123 by auto
  qed
  ultimately show ?thesis
    using eq_conga_out by blast
qed

lemma sams_suma__out546:
  assumes "A B C D E F SumA A B C" and
    "SAMS A B C D E F"
  shows "E Out D F"
proof -
  have "D E F A B C SumA A B C"
    using assms(1) suma_sym by blast
  moreover have "SAMS D E F A B C"
    using assms(2) sams_sym by blast
  ultimately show ?thesis
    using sams_suma__out213 by blast
qed

lemma sams_lea_lta123_suma2__lta:
  assumes "A B C LtA A' B' C'" and
    "D E F LeA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "G H I LtA G' H' I'"
proof -
  have "G H I LeA G' H' I'"
  proof -
    have "A B C LeA A' B' C'"
      by (simp add: assms(1) lta__lea)
    thus ?thesis
      using assms(2) assms(3) assms(4) assms(5) sams_lea2_suma2__lea by blast
  qed
  moreover have "¬ G H I CongA G' H' I'"
  proof -
    {
      assume "G H I CongA G' H' I'"
      have "A B C CongA A' B' C'"
      proof -
        have "A B C LeA A' B' C'"
          by (simp add: assms(1) lta__lea)
        moreover have "A' B' C' D' E' F' SumA G H I"
          by (meson ‹G H I CongA G' H' I'› assms(3) assms(5) conga3_suma__suma 
              conga_sym sams2_suma2__conga123 sams2_suma2__conga456)
        ultimately show ?thesis
          using assms(2) assms(3) assms(4) sams_lea2_suma2__conga123 by blast
      qed
      hence "False"
        using assms(1) lta_not_conga by auto
    }
    thus ?thesis
      by auto
  qed
  ultimately show ?thesis
    using LtA_def by blast
qed

lemma sams_lea_lta456_suma2__lta:
  assumes "A B C LeA A' B' C'" and
    "D E F LtA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "G H I LtA G' H' I'"
  using sams_lea_lta123_suma2__lta 
  by (meson assms(1) assms(2) assms(3) assms(4) assms(5) sams_sym suma_sym)

lemma sams_lta2_suma2__lta:
  assumes "A B C LtA A' B' C'" and
    "D E F LtA D' E' F'" and
    "SAMS A' B' C' D' E' F'" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "G H I LtA G' H' I'"
  using sams_lea_lta123_suma2__lta 
  by (meson LtA_def assms(1) assms(2) assms(3) assms(4) assms(5))

lemma sams_lea2_suma2__lea123:
  assumes "D' E' F' LeA D E F" and
    "G H I LeA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "A B C LeA A' B' C'"
proof cases
  assume "A' B' C' LtA A B C"
  hence "G' H' I' LtA G H I" using sams_lea_lta123_suma2__lta
    using assms(1) assms(3) assms(4) assms(5) by blast
  hence "¬ G H I LeA G' H' I'"
    using lea__nlta by blast
  hence "False"
    using assms(2) by auto
  thus ?thesis by auto
next
  assume "¬ A' B' C' LtA A B C"
  have "A' ≠ B' ∧ B' ≠ C' ∧ A ≠ B ∧ B ≠ C"
    using assms(4) assms(5) suma_distincts by auto
  thus ?thesis
    by (simp add: ‹¬ A' B' C' LtA A B C› nlta__lea)
qed

lemma sams_lea2_suma2__lea456:
  assumes "A' B' C' LeA A B C" and
    "G H I LeA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "D E F LeA D' E' F'"
proof -
  have "SAMS D E F A B C"
    by (simp add: assms(3) sams_sym)
  moreover have "D E F A B C SumA G H I"
    by (simp add: assms(4) suma_sym)
  moreover have "D' E' F' A' B' C' SumA G' H' I'"
    by (simp add: assms(5) suma_sym)
  ultimately show ?thesis
    using assms(1) assms(2) sams_lea2_suma2__lea123 by blast
qed

lemma sams_lea_lta456_suma2__lta123:
  assumes "D' E' F' LtA D E F" and
    "G H I LeA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "A B C LtA A' B' C'"
proof cases
  assume "A' B' C' LeA A B C"
  hence "G' H' I' LtA G H I"
    using sams_lea_lta456_suma2__lta assms(1) assms(3) assms(4) assms(5) by blast
  hence "¬ G H I LeA G' H' I'"
    using lea__nlta by blast
  hence "False"
    using assms(2) by blast
  thus ?thesis by blast
next
  assume "¬ A' B' C' LeA A B C"
  have "A' ≠ B' ∧ B' ≠ C' ∧ A ≠ B ∧ B ≠ C"
    using assms(4) assms(5) suma_distincts by auto
  thus ?thesis using nlea__lta
    by (simp add: ‹¬ A' B' C' LeA A B C›)
qed

lemma sams_lea_lta123_suma2__lta456:
  assumes "A' B' C' LtA A B C" and
    "G H I LeA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "D E F LtA D' E' F'"
proof -
  have "SAMS D E F A B C"
    by (simp add: assms(3) sams_sym)
  moreover have "D E F A B C SumA G H I"
    by (simp add: assms(4) suma_sym)
  moreover have "D' E' F' A' B' C' SumA G' H' I'"
    by (simp add: assms(5) suma_sym)
  ultimately show ?thesis
    using assms(1) assms(2) sams_lea_lta456_suma2__lta123 by blast
qed

lemma sams_lea_lta789_suma2__lta123:
  assumes "D' E' F' LeA D E F" and
    "G H I LtA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "A B C LtA A' B' C'"
proof cases
  assume "A' B' C' LeA A B C"
  hence "G' H' I' LeA G H I"
    using assms(1) assms(3) assms(4) assms(5) sams_lea2_suma2__lea by blast
  hence "¬ G H I LtA G' H' I'"
    by (simp add: lea__nlta)
  hence "False"
    using assms(2) by blast
  thus ?thesis by auto
next
  assume "¬ A' B' C' LeA A B C"
  have "A' ≠ B' ∧ B' ≠ C' ∧ A ≠ B ∧ B ≠ C"
    using assms(4) assms(5) suma_distincts by auto
  thus ?thesis
    using nlea__lta by (simp add: ‹¬ A' B' C' LeA A B C›)
qed

lemma sams_lea_lta789_suma2__lta456:
  assumes "A' B' C' LeA A B C" and
    "G H I LtA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "D E F LtA D' E' F'"
proof -
  have "SAMS D E F A B C"
    by (simp add: assms(3) sams_sym)
  moreover have "D E F A B C SumA G H I"
    by (simp add: assms(4) suma_sym)
  moreover have "D' E' F' A' B' C' SumA G' H' I'"
    using assms(5) suma_sym by blast
  ultimately show ?thesis
    using assms(1) assms(2) sams_lea_lta789_suma2__lta123 by blast
qed

lemma sams_lta2_suma2__lta123:
  assumes "D' E' F' LtA D E F" and
    "G H I LtA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "A B C LtA A' B' C'"
proof -
  have "D' E' F' LeA D E F"
    by (simp add: assms(1) lta__lea)
  thus ?thesis
    using assms(2) assms(3) assms(4) assms(5) sams_lea_lta789_suma2__lta123 by blast
qed

lemma sams_lta2_suma2__lta456:
  assumes "A' B' C' LtA A B C" and
    "G H I LtA G' H' I'" and
    "SAMS A B C D E F" and
    "A B C D E F SumA G H I" and
    "A' B' C' D' E' F' SumA G' H' I'"
  shows "D E F LtA D' E' F'"
proof -
  have "A' B' C' LeA A B C"
    by (simp add: assms(1) lta__lea)
  thus ?thesis
    using assms(2) assms(3) assms(4) assms(5) sams_lea_lta789_suma2__lta456 by blast
qed

lemma sams123231:
  assumes "A ≠ B" and
    "A ≠ C" and
    "B ≠ C"
  shows "SAMS A B C B C A"
proof -
  obtain A' where "B Midpoint A A'"
    using symmetric_point_construction by auto
  hence "A' ≠ B"
    using assms(1) midpoint_not_midpoint by blast
  moreover have "Bet A B A'"
    by (simp add: ‹B Midpoint A A'› midpoint_bet)
  moreover have "B C A LeA C B A'"
  proof cases
    assume "Col A B C"
    show ?thesis
    proof cases
      assume "Bet A C B"
      thus ?thesis
        by (metis assms(2) assms(3) between_exchange3 calculation(1) 
            calculation(2) l11_31_2)
    next
      assume "¬ Bet A C B"
      hence "C Out B A"
        using Col_cases ‹Col A B C› l6_6 or_bet_out by blast
      thus ?thesis
        using assms(3) calculation(1) l11_31_1 by auto
    qed
  next
    assume "¬ Col A B C"
    thus ?thesis
      using l11_41_aux ‹B Midpoint A A'› calculation(1) lta__lea 
        midpoint_bet not_col_permutation_4 by blast
  qed
  ultimately show ?thesis
    using assms(1) sams_chara by blast
qed

lemma col_suma__col:
  assumes "Col D E F" and
    "A B C B C A SumA D E F"
  shows "Col A B C"
proof -
  {
    assume "¬ Col A B C"
    have "False"
    proof cases
      assume "Bet D E F"
      obtain P where P1: "Bet A B P ∧ Cong A B B P"
        using Cong_perm segment_construction by blast
      have "D E F LtA A B P"
      proof -
        have "A B C LeA A B C"
          using ‹¬ Col A B C› lea_total not_col_distincts by blast
        moreover
        have "B C TS A P"
          by (metis Cong_perm P1 ‹¬ Col A B C› bet__ts bet_col between_trivial2 
              cong_reverse_identity not_col_permutation_1)
        hence "B C A LtA C B P"
          using Col_perm P1 ‹¬ Col A B C› calculation l11_41_aux ts_distincts by blast
        moreover have "A B C C B P SumA A B P"
          by (simp add: ‹B C TS A P› ts__suma_1)
        ultimately show ?thesis
          by (meson P1 sams_lea_lta456_suma2__lta assms(2) bet_suma__sams)
      qed
      thus ?thesis
        using P1 ‹Bet D E F› bet2_lta__lta lta_distincts by blast
    next
      assume "¬ Bet D E F"
      have "C Out B A"
      proof -
        have "E Out D F"
          by (simp add: ‹¬ Bet D E F› assms(1) l6_4_2)
        moreover have "B C A LeA D E F"
          using sams_suma__lea456789
          by (metis assms(2) sams123231 suma_distincts)
        ultimately show ?thesis
          using out_lea__out by blast
      qed
      thus ?thesis
        using Col_cases ‹¬ Col A B C› out_col by blast
    qed
  }
  thus ?thesis by auto
qed

lemma ncol_suma__ncol:
  assumes "¬ Col A B C" and
    "A B C B C A SumA D E F"
  shows "¬ Col D E F"
  using col_suma__col assms(1) assms(2) by blast

lemma per2_suma__bet:
  assumes "Per A B C" and
    "Per D E F" and
    "A B C D E F SumA G H I"
  shows "Bet G H I"
proof -
  obtain A1 where P1: "C B A1 CongA D E F ∧ ¬ B C OS A A1 ∧ 
Coplanar A B C A1 ∧ A B A1 CongA G H I"
    using SumA_def assms(3) by blast
  hence "D E F CongA A1 B C"
    using conga_right_comm conga_sym by blast
  hence "Per A1 B C"
    using assms(2) l11_17 by blast
  have "Bet A B A1"
  proof -
    have "Col B A A1"
    proof -
      have "Coplanar C A A1 B"
        using P1 ncoplanar_perm_10 by blast
      moreover have "C ≠ B"
        using ‹D E F CongA A1 B C› conga_distinct by auto
      ultimately show ?thesis
        using assms(1) ‹Per A1 B C› col_permutation_2 cop_per2__col by blast
    qed
    moreover have "B C TS A A1"
    proof -
      have "Coplanar B C A A1"
        using calculation ncop__ncols by blast
      moreover
      have "A ≠ B ∧ B ≠ C"
        using CongA_def P1 by blast
      hence "¬ Col A B C"
        by (simp add: assms(1) per_not_col)
      moreover
      have "A1 ≠ B ∧ B ≠ C"
        using ‹D E F CongA A1 B C› conga_distinct by blast
      hence "¬ Col A1 B C"
        using  ‹Per A1 B C› by (simp add: per_not_col)
      ultimately show ?thesis
        by (simp add: P1 cop_nos__ts)
    qed
    ultimately show ?thesis
      using col_two_sides_bet by blast
  qed
  thus ?thesis
    using P1 bet_conga__bet by blast
qed

lemma bet_per2__suma:
  assumes "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F" and
    "G ≠ H" and
    "H ≠ I" and
    "Per A B C" and
    "Per D E F" and
    "Bet G H I"
  shows "A B C D E F SumA G H I"
proof -
  obtain G' H' I' where "A B C D E F SumA G' H' I'"
    using assms(1) assms(2) assms(3) assms(4) ex_suma by blast
  moreover have "A B C CongA A B C"
    using assms(1) assms(2) conga_refl by auto
  moreover have "D E F CongA D E F"
    using assms(3) assms(4) conga_refl by auto
  moreover have "G' H' I' CongA G H I"
  proof -
    have "G' ≠ H'"
      using calculation(1) suma_distincts by auto
    moreover have "H' ≠ I'"
      using ‹A B C D E F SumA G' H' I'› suma_distincts by blast
    moreover have "Bet G' H' I'"
      using  ‹A B C D E F SumA G' H' I'› assms(7) assms(8) per2_suma__bet by auto
    ultimately show ?thesis
      using conga_line by (simp add: assms(5) assms(6) assms(9))
  qed
  ultimately show ?thesis
    using conga3_suma__suma by blast
qed

lemma per2__sams:
  assumes "A ≠ B" and
    "B ≠ C" and
    "D ≠ E" and
    "E ≠ F" and
    "Per A B C" and
    "Per D E F"
  shows "SAMS A B C D E F"
proof -
  obtain G H I where "A B C D E F SumA G H I"
    using assms(1) assms(2) assms(3) assms(4) ex_suma by blast
  moreover hence "Bet G H I"
    using assms(5) assms(6) per2_suma__bet by auto
  ultimately show ?thesis
    using bet_suma__sams by blast
qed

lemma bet_per_suma__per456:
  assumes "Per A B C" and
    "Bet G H I" and
    "A B C D E F SumA G H I"
  shows "Per D E F"
proof -
  obtain A1 where "B Midpoint A A1"
    using symmetric_point_construction by auto
  have "¬ Col A B C"
    using assms(1) assms(3) per_col_eq suma_distincts by blast
  have "A B C CongA D E F"
  proof -
    have "SAMS A B C A B C"
      using ‹¬ Col A B C› assms(1) not_col_distincts per2__sams by auto
    moreover have "SAMS A B C D E F"
      using assms(2) assms(3) bet_suma__sams by blast
    moreover have "A B C A B C SumA G H I"
      using assms(1) assms(2) assms(3) bet_per2__suma suma_distincts by blast
    ultimately show ?thesis
      using assms(3) sams2_suma2__conga456 by auto
  qed
  thus ?thesis
    using assms(1) l11_17 by blast
qed

lemma bet_per_suma__per123:
  assumes "Per D E F" and
    "Bet G H I" and
    "A B C D E F SumA G H I"
  shows "Per A B C"
  using bet_per_suma__per456 by (meson assms(1) assms(2) assms(3) suma_sym)

lemma bet_suma__per:
  assumes "Bet D E F" and
    "A B C A B C SumA D E F"
  shows "Per A B C"
proof -
  obtain A' where "C B A' CongA A B C ∧ A B A' CongA D E F"
    using SumA_def assms(2) by blast
  have "Per C B A"
  proof -
    have "Bet A B A'"
    proof -
      have "D E F CongA A B A'"
        using ‹C B A' CongA A B C ∧ A B A' CongA D E F› not_conga_sym by blast
      thus ?thesis
        using assms(1) bet_conga__bet by blast
    qed
    moreover have "C B A CongA C B A'"
      using conga_left_comm not_conga_sym 
        ‹C B A' CongA A B C ∧ A B A' CongA D E F› by blast
    ultimately show ?thesis
      using l11_18_2 by auto
  qed
  thus ?thesis
    using Per_cases by auto
qed

lemma acute__sams:
  assumes "Acute A B C"
  shows "SAMS A B C A B C"
proof -
  obtain A' where "B Midpoint A A'"
    using symmetric_point_construction by auto
  show ?thesis
  proof -
    have "A ≠ B ∧ A' ≠ B"
      using ‹B Midpoint A A'› acute_distincts assms is_midpoint_id_2 by blast
    moreover have "Bet A B A'"
      by (simp add: ‹B Midpoint A A'› midpoint_bet)
    moreover
    have "Obtuse C B A'"
      using acute_bet__obtuse assms calculation(1) calculation(2) 
        obtuse_sym by blast
    hence "A B C LeA C B A'"
      by (metis acute__not_obtuse assms calculation(1) lea_obtuse_obtuse 
          lea_total obtuse_distincts)
    ultimately show ?thesis
      using sams_chara by blast
  qed
qed

lemma acute_suma__nbet:
  assumes "Acute A B C" and
    "A B C A B C SumA D E F"
  shows  "¬ Bet D E F"
proof -
  {
    assume "Bet D E F"
    hence "Per A B C"
      using assms(2) bet_suma__per by auto
    hence "A B C LtA A B C"
      using acute_not_per assms(1) by auto
    hence "False"
      by (simp add: nlta)
  }
  thus ?thesis by blast
qed

lemma acute2__sams:
  assumes "Acute A B C" and
    "Acute D E F"
  shows "SAMS A B C D E F"
  by (metis acute__sams acute_distincts assms(1) assms(2) lea_total sams_lea2__sams)

lemma acute2_suma__nbet_a:
  assumes "Acute A B C" and
    "D E F LeA A B C" and
    "A B C D E F SumA G H I"
  shows "¬ Bet G H I"
proof -
  {
    assume "Bet G H I"
    obtain A' B' C' where "A B C A B C SumA A' B' C'"
      using acute_distincts assms(1) ex_suma by metis 
    have "G H I LeA A' B' C'"
    proof -
      have "A B C LeA A B C"
        using acute_distincts assms(1) lea_refl by blast
      moreover have "SAMS A B C A B C"
        by (simp add: acute__sams assms(1))
      ultimately show ?thesis
        using ‹A B C A B C SumA A' B' C'› assms(1) assms(2) assms(3) 
          sams_lea456_suma2__lea by blast
    qed
    hence "Bet A' B' C'"
      using ‹Bet G H I› bet_lea__bet by blast
    hence "False"
      using acute_suma__nbet assms(1) assms(3) ‹A B C A B C SumA A' B' C'› by blast
  }
  thus ?thesis by blast
qed

lemma acute2_suma__nbet:
  assumes "Acute A B C" and
    "Acute D E F" and
    "A B C D E F SumA G H I"
  shows "¬ Bet G H I"
proof -
  have "A ≠ B ∧ B ≠ C ∧ D ≠ E ∧ E ≠ F"
    using assms(3) suma_distincts by auto
  hence "A B C LeA D E F ∨ D E F LeA A B C"
    by (simp add: lea_total)
  moreover
  {
    assume P3: "A B C LeA D E F"
    have "D E F A B C SumA G H I"
      by (simp add: assms(3) suma_sym)
    hence "¬ Bet G H I"
      using P3 assms(2) acute2_suma__nbet_a by auto
  }
  {
    assume "D E F LeA A B C"
    hence  "¬ Bet G H I"
      using acute2_suma__nbet_a assms(1) assms(3) by auto
  }
  thus ?thesis
    using ‹A B C LeA D E F ⟹ ¬ Bet G H I› calculation by blast
qed

lemma acute_per__sams:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C" and
    "Acute D E F"
  shows "SAMS A B C D E F"
proof -
  have "SAMS A B C A B C"
    by (simp add: assms(1) assms(2) assms(3) per2__sams)
  moreover have "A B C LeA A B C"
    using assms(1) assms(2) lea_refl by auto
  moreover have "D E F LeA A B C"
    by (metis acute_distincts acute_lea_acute acute_not_per assms(1) 
        assms(2) assms(3) assms(4) lea_total)
  ultimately show ?thesis
    using sams_lea2__sams by blast
qed

lemma acute_per_suma__nbet:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C" and
    "Acute D E F" and
    "A B C D E F SumA G H I"
  shows "¬ Bet G H I"
proof -
  {
    assume "Bet G H I"
    have "G H I LtA G H I"
    proof -
      have "A B C LeA A B C"
        using assms(1) assms(2) lea_refl by auto
      moreover have "D E F LtA A B C"
        by (simp add: acute_per__lta assms(1) assms(2) assms(3) assms(4))
      moreover have "SAMS A B C A B C"
        by (simp add: assms(1) assms(2) assms(3) per2__sams)
      moreover have "A B C D E F SumA G H I"
        by (simp add: assms(5))
      moreover have "A B C A B C SumA G H I"
        by (meson bet_per_suma__per456 Tarski_neutral_dimensionless_axioms 
            ‹Bet G H I› acute_not_per assms(3) assms(4) calculation(4))
      ultimately show ?thesis
        using sams_lea_lta456_suma2__lta by blast
    qed
    hence "False"
      by (simp add: nlta)
  }
  thus ?thesis by blast
qed

lemma obtuse__nsams:
  assumes "Obtuse A B C"
  shows "¬ SAMS A B C A B C"
proof -
  {
    assume "SAMS A B C A B C"
    obtain A' where "B Midpoint A A'"
      using symmetric_point_construction by auto
    have "A B C LtA A B C"
    proof -
      have "A B C LeA A' B C"
        by (metis ‹B Midpoint A A'› ‹SAMS A B C A B C› lea_right_comm 
            midpoint_bet midpoint_distinct_2 sams_chara sams_distincts)
      moreover have "A' B C LtA A B C"
        using ‹B Midpoint A A'› assms calculation lea_distincts 
          midpoint_bet obtuse_chara by blast
      ultimately show ?thesis
        using lea__nlta by blast
    qed
    hence "False"
      by (simp add: nlta)
  }
  thus ?thesis by blast
qed

lemma nbet_sams_suma__acute:
  assumes "¬ Bet D E F" and
    "SAMS A B C A B C" and
    "A B C A B C SumA D E F"
  shows "Acute A B C"
proof -
  have "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
    by (metis angle_partition l8_20_1_R1 l8_5)
  {
    assume "Per A B C"
    hence "Bet D E F"
      using assms(3) per2_suma__bet by auto
    hence "False"
      using assms(1) by auto
  }
  {
    assume "Obtuse A B C"
    hence "¬ SAMS A B C A B C"
      by (simp add: obtuse__nsams)
    hence "False"
      using assms(2) by auto
  }
  thus ?thesis
    using ‹Acute A B C ∨ Per A B C ∨ Obtuse A B C› ‹Per A B C ⟹ False› by auto
qed

lemma nsams__obtuse:
  assumes "A ≠ B" and
    "B ≠ C" and
    "¬ SAMS A B C A B C"
  shows "Obtuse A B C"
proof -
  {
    assume "Per A B C"
    obtain A' where "B Midpoint A A'"
      using symmetric_point_construction by blast
    have "¬ Col A B C"
      using ‹Per A B C› assms(1) assms(2) per_col_eq by blast
    have "SAMS A B C A B C"
    proof -
      have "C B A' CongA A B C"
        using ‹Per A B C› assms(1) assms(2) assms(3) per2__sams by blast
      moreover have "¬ B C OS A A'"
        by (meson Col_cases ‹B Midpoint A A'› col_one_side_out l6_4_1
            midpoint_bet midpoint_col)
      moreover have "¬ A B TS C A'"
        using Col_def Midpoint_def TS_def ‹B Midpoint A A'› by blast
      moreover have "Coplanar A B C A'"
        using ‹Per A B C› assms(1) assms(2) assms(3) per2__sams by blast
      ultimately show ?thesis
        using SAMS_def ‹¬ Col A B C› assms(1) bet_col by auto
    qed
    hence "False"
      using assms(3) by auto
  }
  {
    assume "Acute A B C"
    hence "SAMS A B C A B C"
      by (simp add: acute__sams)
    hence "False"
      using assms(3) by auto
  }
  thus ?thesis
    using ‹Per A B C ⟹ False› angle_partition assms(1) assms(2) by auto
qed

lemma sams2_suma2__conga:
  assumes "SAMS A B C A B C" and
    "A B C A B C SumA D E F" and
    "SAMS A' B' C' A' B' C'" and
    "A' B' C' A' B' C' SumA D E F"
  shows "A B C CongA A' B' C'"
proof -
  have "A B C LeA A' B' C' ∨ A' B' C' LeA A B C"
    using assms(1) assms(3) lea_total sams_distincts by auto
  moreover
  have "A B C LeA A' B' C' ⟶ A B C CongA A' B' C'"
    using assms(2) assms(3) assms(4) sams_lea2_suma2__conga123 by auto
  ultimately show ?thesis
    by (meson conga_sym sams_lea2_suma2__conga123 assms(1) assms(2) assms(4))
qed

lemma acute2_suma2__conga:
  assumes "Acute A B C" and
    "A B C A B C SumA D E F" and
    "Acute A' B' C'" and
    "A' B' C' A' B' C' SumA D E F"
  shows "A B C CongA A' B' C'"
proof -
  have "SAMS A B C A B C"
    by (simp add: acute__sams assms(1))
  moreover have "SAMS A' B' C' A' B' C'"
    by (simp add: acute__sams assms(3))
  ultimately show ?thesis
    using assms(2) assms(4) sams2_suma2__conga by auto
qed

lemma bet2_suma__out:
  assumes "Bet A B C" and
    "Bet D E F" and
    "A B C D E F SumA G H I"
  shows "H Out G I"
proof -
  have "A B C D E F SumA A B A"
  proof -
    have "C B A CongA D E F"
      by (metis Bet_cases assms(1) assms(2) assms(3) conga_line suma_distincts)
    moreover have "¬ B C OS A A"
      by (simp add: Col_def assms(1) col124__nos)
    moreover have "Coplanar A B C A"
      using ncop_distincts by blast
    moreover have "A B A CongA A B A"
      using calculation(1) conga_diff2 conga_trivial_1 by auto
    ultimately show ?thesis
      using SumA_def by blast
  qed
  hence "A B A CongA G H I"
    using assms(3) suma2__conga by auto
  thus ?thesis
    using eq_conga_out by auto
qed

lemma col2_suma__col:
  assumes "Col A B C" and
    "Col D E F" and
    "A B C D E F SumA G H I"
  shows "Col G H I"
proof cases
  assume "Bet A B C"
  show ?thesis
  proof cases
    assume "Bet D E F"
    thus ?thesis using bet2_suma__out
      by (meson ‹Bet A B C› assms(3) not_col_permutation_4 out_col)
  next
    assume "¬ Bet D E F"
    show ?thesis
    proof -
      have "E Out D F"
        using ‹¬ Bet D E F› assms(2) or_bet_out by auto
      hence "A B C CongA G H I"
        using assms(3) out546_suma__conga by auto
      thus ?thesis
        using assms(1) col_conga_col by blast
    qed
  qed
next
  assume "¬ Bet A B C"
  have "D E F CongA G H I"
  proof -
    have "B Out A C"
      by (simp add: ‹¬ Bet A B C› assms(1) l6_4_2)
    thus ?thesis
      using assms(3) out213_suma__conga by auto
  qed
  thus ?thesis
    using assms(2) col_conga_col by blast
qed

lemma suma_suppa__bet:
  assumes "A B C SuppA D E F" and
    "A B C D E F SumA G H I"
  shows "Bet G H I"
proof -
  obtain A' where P1: "Bet A B A' ∧ D E F CongA C B A'"
    using SuppA_def assms(1) by auto
  obtain A'' where P2: "C B A'' CongA D E F ∧ ¬ B C OS A A'' ∧ 
Coplanar A B C A'' ∧ A B A'' CongA G H I"
    using SumA_def assms(2) by auto
  have "B Out A' A'' ∨ C B TS A' A''"
  proof -
    have "Coplanar C B A' A''"
    proof -
      have "Coplanar C A'' B A"
        using P2 coplanar_perm_17 by blast
      moreover have "B ≠ A"
        using SuppA_def assms(1) by auto
      moreover have "Col B A A'" using P1
        by (simp add: bet_col col_permutation_4)
      ultimately show ?thesis
        using col_cop__cop coplanar_perm_3 by blast
    qed
    moreover have "C B A' CongA C B A''"
    proof -
      have "C B A' CongA D E F"
        using P1 not_conga_sym by blast
      moreover have "D E F CongA C B A''"
        using P2 not_conga_sym by blast
      ultimately show ?thesis
        using not_conga by blast
    qed
    ultimately show ?thesis
      using conga_cop__or_out_ts by simp
  qed
  have "Bet A B A''"
  proof -
    have "¬ C B TS A' A''"
    proof -
      {
        assume "C B TS A' A''"
        have "B C TS A A'"
        proof -
          {
            assume "Col A B C"
            hence "Col A' C B"
              using P1 assms(1) bet_col bet_col1 col3 suppa_distincts by blast
            hence "False"
              using TS_def ‹C B TS A' A''› by auto
          }
          hence "¬ Col A B C" by auto
          moreover have "¬ Col A' B C"
            using TS_def ‹C B TS A' A''› not_col_permutation_5 by blast
          moreover
          have "∃ T. (Col T B C ∧ Bet A T A')"
            using P1 not_col_distincts by blast
          ultimately show ?thesis
            by (simp add: TS_def)
        qed
        hence "B C OS A A''"
          using OS_def ‹C B TS A' A''› invert_two_sides l9_2 by blast
        hence "False"
          using P2 by simp
      }
      thus ?thesis by blast
    qed
    hence "B Out A' A''"
      using ‹B Out A' A'' ∨ C B TS A' A''› by auto
    moreover have "A' ≠ B ∧ A'' ≠ B ∧ A ≠ B"
      using P2 calculation conga_diff1 out_diff1 out_diff2 by blast
    moreover have "Bet A' B A"
      using P1 Bet_perm by blast
    ultimately show ?thesis
      using bet_out__bet between_symmetry by blast
  qed
  moreover have "A B A'' CongA G H I"
    using P2 by blast
  ultimately show ?thesis
    using bet_conga__bet by blast
qed

lemma bet_suppa__suma:
  assumes "G ≠ H" and
    "H ≠ I" and
    "A B C SuppA D E F" and
    "Bet G H I"
  shows "A B C D E F SumA G H I"
proof -
  obtain G' H' I' where "A B C D E F SumA G' H' I'"
    using assms(3) ex_suma suppa_distincts by blast
  moreover have "A B C CongA A B C"
    using calculation conga_refl suma_distincts by fastforce
  moreover
  have "D ≠ E ∧ E ≠ F"
    using assms(3) suppa_distincts by auto
  hence "D E F CongA D E F"
    using conga_refl by auto
  moreover
  have "G' H' I' CongA G H I"
  proof -
    have "G' ≠ H' ∧ H' ≠ I'"
      using calculation(1) suma_distincts by auto
    moreover have "Bet G' H' I'"
      using  ‹A B C D E F SumA G' H' I'› assms(3) suma_suppa__bet by blast
    ultimately show ?thesis
      using assms(1) assms(2) assms(4) conga_line by auto
  qed
  ultimately show ?thesis
    using conga3_suma__suma by blast
qed

lemma bet_suma__suppa:
  assumes "A B C D E F SumA G H I" and
    "Bet G H I"
  shows "A B C SuppA D E F"
proof -
  obtain A' where "C B A' CongA D E F ∧ A B A' CongA G H I"
    using SumA_def assms(1) by blast
  moreover
  have "G H I CongA A B A'"
    using calculation not_conga_sym by blast
  hence "Bet A B A'"
    using assms(2) bet_conga__bet by blast
  moreover have "D E F CongA C B A'"
    using calculation(1) not_conga_sym by blast
  ultimately show ?thesis
    by (metis SuppA_def conga_diff1)
qed

lemma bet2_suma__suma:
  assumes "A' ≠ B" and
    "D' ≠  E" and
    "Bet A B A'" and
    "Bet D E D'" and
    "A B C D E F SumA G H I"
  shows "A' B C D' E F SumA G H I"
proof -
  obtain J where P1: "C B J CongA D E F ∧ ¬ B C OS A J ∧ 
Coplanar A B C J ∧ A B J CongA G H I"
    using SumA_def assms(5) by auto
  moreover
  obtain C' where P2: "Bet C B C' ∧ Cong B C' B C"
    using segment_construction by blast
  moreover
  have "A B C' D' E F SumA G H I"
  proof -
    have "C' B J CongA D' E F"
      by (metis assms(2) assms(4) calculation(1) calculation(2) 
          cong_diff_3 conga_diff1 l11_13)
    moreover have "¬ B C' OS A J"
      by (metis Col_cases P1 P2 bet_col col_one_side cong_diff)
    moreover have "Coplanar A B C' J"
    proof-
      have "Coplanar A B C J" 
        using P1 by blast
      hence "Coplanar A B J C" 
        using coplanar_perm_1 by blast
      hence "Coplanar A B J C'" 
        by (metis P2 bet_col col_cop2__cop cong_diff ncop_distincts)
      thus ?thesis 
        using coplanar_perm_1 by blast
    qed
    ultimately show ?thesis
      using P1 SumA_def by blast
  qed
  moreover have "A B C' CongA A' B C"
    using assms(1) assms(3) assms(5) between_symmetry calculation(2) 
      calculation(3) l11_14 suma_distincts by auto
  moreover
  have "D' ≠ E ∧ E ≠ F"
    using assms(2) calculation(1) conga_distinct by blast
  hence "D' E F CongA D' E F"
    using conga_refl by auto
  moreover
  have "G ≠ H ∧ H ≠ I"
    using assms(5) suma_distincts by blast
  hence "G H I CongA G H I"
    using conga_refl by auto
  ultimately show ?thesis
    using conga3_suma__suma by blast
qed

lemma suma_suppa2__suma:
  assumes "A B C SuppA A' B' C'" and
    "D E F SuppA D' E' F'" and
    "A B C D E F SumA G H I"
  shows "A' B' C' D' E' F' SumA G H I"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ A' B' C' CongA C B A0"
    using SuppA_def assms(1) by auto
  obtain D0 where P2: "Bet D E D0 ∧ D' E' F' CongA F E D0"
    using SuppA_def assms(2) by auto
  show ?thesis
  proof -
    have "A0 B C D0 E F SumA G H I"
    proof -
      have "A0 ≠ B"
        using CongA_def P1 by auto
      moreover have "D0 ≠ E"
        using CongA_def P2 by blast
      ultimately show ?thesis
        using P1 P2 assms(3) bet2_suma__suma by auto
    qed
    moreover have "A0 B C CongA A' B' C'"
      using P1 conga_left_comm not_conga_sym by blast
    moreover have "D0 E F CongA D' E' F'"
      using P2 conga_left_comm not_conga_sym by blast
    moreover
    have "G ≠ H ∧ H ≠ I"
      using assms(3) suma_distincts by blast
    hence "G H I CongA G H I"
      using conga_refl by auto
    ultimately show ?thesis
      using conga3_suma__suma by blast
  qed
qed

lemma suma2_obtuse2__conga:
  assumes "Obtuse A B C" and
    "A B C A B C SumA D E F" and
    "Obtuse A' B' C'" and
    "A' B' C' A' B' C' SumA D E F"
  shows "A B C CongA A' B' C'"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ Cong B A0 A B"
    using segment_construction by blast
  moreover
  obtain A0' where P2: "Bet A' B' A0' ∧ Cong B' A0' A' B'"
    using segment_construction by blast
  moreover
  have "A0 B C CongA A0' B' C'"
  proof -
    have "Acute A0 B C"
      using assms(1) bet_obtuse__acute P1 cong_diff_3 obtuse_distincts by blast
    moreover have "A0 B C A0 B C SumA D E F"
      using P1 acute_distincts assms(2) bet2_suma__suma calculation by blast
    moreover have "Acute A0' B' C'"
      using P2 assms(3) bet_obtuse__acute cong_diff_3 obtuse_distincts by blast
    moreover have "A0' B' C' A0' B' C' SumA D E F"
      by (metis P2 assms(4) bet2_suma__suma cong_diff_3)
    ultimately show ?thesis
      using acute2_suma2__conga by blast
  qed
  moreover have "Bet A0 B A"
    using Bet_perm calculation(1) by blast
  moreover have "Bet A0' B' A'"
    using Bet_perm calculation(2) by blast
  moreover have "A ≠ B"
    using assms(1) obtuse_distincts by blast
  moreover have "A' ≠ B'"
    using assms(3) obtuse_distincts by blast
  ultimately show ?thesis
    using l11_13 by blast
qed

lemma bet_suma2__or_conga:
  assumes "A0 ≠ B" and
    "Bet A B A0" and
    "A B C A B C SumA D E F" and
    "A' B' C' A' B' C' SumA D E F"
  shows "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
proof -
  {
    fix A' B' C'
    assume"Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F"
    have "Per A B C ∨ Acute A B C ∨ Obtuse A B C"
      by (metis angle_partition l8_20_1_R1 l8_5)
    {
      assume "Per A B C"
      hence "Bet D E F"
        using per2_suma__bet assms(3) by auto
      hence "False"
        using  ‹Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F› acute_suma__nbet by blast
      hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'" by blast
    }
    {
      assume "Acute A B C"
      have "Acute A' B' C'"
        by (simp add: ‹Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F›)
      moreover have "A' B' C' A' B' C' SumA D E F"
        by (simp add: ‹Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F›)
      ultimately
      have "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
        using assms(3) ‹Acute A B C› acute2_suma2__conga by auto
    }
    {
      assume "Obtuse A B C"
      have "Acute A0 B C"
        using ‹Obtuse A B C› assms(1) assms(2) bet_obtuse__acute by auto
      moreover have "A0 B C A0 B C SumA D E F"
        using assms(1) assms(2) assms(3) bet2_suma__suma by auto
      ultimately have "A0 B C CongA A' B' C'"
        using ‹Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F› acute2_suma2__conga by auto
      hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'" by blast
    }
    hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
      using ‹Acute A B C ⟹ A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'› 
        ‹Per A B C ⟹ A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'› 
        ‹Per A B C ∨ Acute A B C ∨ Obtuse A B C› by blast
  }
  hence P1: "∀ A' B' C'. (Acute A' B' C' ∧ A' B' C' A' B' C' SumA D E F) 
⟶ (A B C CongA A' B' C' ∨ A0 B C CongA A' B' C')" by blast
  have "Per A' B' C' ∨ Acute A' B' C' ∨ Obtuse A' B' C'"
    by (metis angle_partition l8_20_1_R1 l8_5)
  {
    assume P2: "Per A' B' C'"
    have "A B C CongA A' B' C'"
    proof -
      have "A ≠ B ∧ B ≠ C"
        using assms(3) suma_distincts by blast
      moreover have "A' ≠ B' ∧ B' ≠ C'"
        using assms(4) suma_distincts by auto
      moreover have "Per A B C"
      proof -
        have "Bet D E F"
          using P2 assms(4) per2_suma__bet by blast
        moreover have "A B C A B C SumA D E F"
          by (simp add: assms(3))
        ultimately show ?thesis
          using assms(3) bet_suma__per by blast
      qed
      ultimately show ?thesis
        using P2 l11_16 by blast
    qed
    hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'" by blast
  }
  {
    assume "Acute A' B' C'"
    hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
      using P1 assms(4) by blast
  }
  {
    assume "Obtuse A' B' C'"
    obtain A0' where "Bet A' B' A0' ∧ Cong B' A0' A' B'"
      using segment_construction by blast
    moreover
    have "Acute A0' B' C'"
      using ‹Obtuse A' B' C'› bet_obtuse__acute calculation cong_diff_3 
        obtuse_distincts by blast
    moreover have "A0' B' C' A0' B' C' SumA D E F"
      using acute_distincts assms(4) bet2_suma__suma calculation(1) 
        calculation(2) by blast
    ultimately
    have "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
      using P1 by (metis assms(1) assms(2) assms(3) assms(4) between_symmetry
          l11_13 suma_distincts)
  }
  thus ?thesis
    using ‹Acute A' B' C' ⟹ A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'› 
      ‹Per A' B' C' ⟹ A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'› 
      ‹Per A' B' C' ∨ Acute A' B' C' ∨ Obtuse A' B' C'› by blast
qed

lemma suma2__or_conga_suppa:
  assumes "A B C A B C SumA D E F" and
    "A' B' C' A' B' C' SumA D E F"
  shows "A B C CongA A' B' C' ∨ A B C SuppA A' B' C'"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ Cong B A0 A B"
    using segment_construction by blast
  hence "A0 ≠ B"
    using  assms(1) bet_cong_eq suma_distincts by blast
  hence "A B C CongA A' B' C' ∨ A0 B C CongA A' B' C'"
    using assms(1) assms(2) P1 bet_suma2__or_conga by blast
  thus ?thesis
    by (metis P1 SuppA_def cong_diff conga_right_comm conga_sym)
qed

lemma ex_trisuma:
  assumes "A ≠ B" and
    "B ≠ C" and
    "A ≠ C"
  shows "∃ D E F. A B C TriSumA D E F"
proof -
  obtain G H I where "A B C B C A SumA G H I"
    using assms(1) assms(2) assms(3) ex_suma by presburger
  moreover
  then obtain D E F where "G H I C A B SumA D E F"
    using ex_suma suma_distincts by presburger
  ultimately show ?thesis
    using TriSumA_def by blast
qed

lemma trisuma_perm_231:
  assumes "A B C TriSumA D E F"
  shows "B C A TriSumA D E F"
proof -
  obtain A1 B1 C1 where P1: "A B C B C A SumA A1 B1 C1 ∧ A1 B1 C1 C A B SumA D E F"
    using TriSumA_def assms(1) by auto
  obtain A2 B2 C2 where P2: "B C A C A B SumA B2 C2 A2"
    using P1 ex_suma suma_distincts by fastforce
  have "A B C B2 C2 A2 SumA D E F"
  proof -
    have "SAMS A B C B C A"
      using assms sams123231 trisuma_distincts by auto
    moreover have "SAMS B C A C A B"
      using P2 sams123231 suma_distincts by fastforce
    ultimately show ?thesis
      using P1 P2 suma_assoc by blast
  qed
  thus ?thesis
    using P2 TriSumA_def suma_sym by blast
qed

lemma trisuma_perm_312:
  assumes "A B C TriSumA D E F"
  shows "C A B TriSumA D E F"
  by (simp add: assms trisuma_perm_231)

lemma trisuma_perm_321:
  assumes "A B C TriSumA D E F"
  shows "C B A TriSumA D E F"
proof -
  obtain G H I where "A B C B C A SumA G H I ∧ G H I C A B SumA D E F"
    using TriSumA_def assms(1) by auto
  thus ?thesis
    by (meson TriSumA_def suma_comm suma_right_comm suma_sym trisuma_perm_231)
qed

lemma trisuma_perm_213:
  assumes "A B C TriSumA D E F"
  shows "B A C TriSumA D E F"
  using assms trisuma_perm_231 trisuma_perm_321 by blast

lemma trisuma_perm_132:
  assumes "A B C TriSumA D E F"
  shows "A C B TriSumA D E F"
  using assms trisuma_perm_312 trisuma_perm_321 by blast

lemma conga_trisuma__trisuma:
  assumes "A B C TriSumA D E F" and
    "D E F CongA D' E' F'"
  shows "A B C TriSumA D' E' F'"
proof -
  obtain G H I where P1: "A B C B C A SumA G H I ∧ G H I C A B SumA D E F"
    using TriSumA_def assms(1) by auto
  have "G H I C A B SumA D' E' F'"
  proof -
    have f1: "B ≠ A"
      by (metis P1 suma_distincts)
    have f2: "C ≠ A"
      using P1 suma_distincts by blast
    have "G H I CongA G H I"
      by (metis (full_types) P1 conga_refl suma_distincts)
    thus ?thesis
      using f2 f1 by (meson P1 assms(2) conga3_suma__suma conga_refl)
  qed
  thus ?thesis using P1 TriSumA_def by blast
qed

lemma trisuma2__conga:
  assumes "A B C TriSumA D E F" and
    "A B C TriSumA D' E' F'"
  shows "D E F CongA D' E' F'"
proof -
  obtain G H I where P1: "A B C B C A SumA G H I ∧ G H I C A B SumA D E F"
    using TriSumA_def assms(1) by auto
  hence P1A: "G H I C A B SumA D E F" by simp
  obtain G' H' I' where P2: "A B C B C A SumA G' H' I' ∧ G' H' I' C A B SumA D' E' F'"
    using TriSumA_def assms(2) by auto
  have "G' H' I' C A B SumA D E F"
  proof -
    have "G H I CongA G' H' I'" using P1 P2 suma2__conga by blast
    moreover have "D E F CongA D E F ∧ C A B CongA C A B"
      by (metis assms(1) conga_refl trisuma_distincts)
    ultimately show ?thesis
      by (meson P1 conga3_suma__suma)
  qed
  thus ?thesis
    using P2 suma2__conga by auto
qed

lemma conga3_trisuma__trisuma:
  assumes "A B C TriSumA D E F" and
    "A B C CongA A' B' C'" and
    "B C A CongA B' C' A'" and
    "C A B CongA C' A' B'"
  shows "A' B' C' TriSumA D E F"
proof -
  obtain G H I where P1: "A B C B C A SumA G H I ∧ G H I C A B SumA D E F"
    using TriSumA_def assms(1) by auto
  thus ?thesis
  proof -
    have "A' B' C' B' C' A' SumA G H I"
      using conga3_suma__suma P1 by (meson assms(2) assms(3) suma2__conga)
    moreover have "G H I C' A' B' SumA D E F"
      using conga3_suma__suma P1 by (meson P1 assms(4) suma2__conga)
    ultimately show ?thesis
      using TriSumA_def by blast
  qed
qed

lemma col_trisuma__bet:
  assumes "Col A B C" and
    "A B C TriSumA P Q R"
  shows "Bet P Q R"
proof -
  obtain D E F where P1: "A B C B C A SumA D E F ∧ D E F C A B SumA P Q R"
    using TriSumA_def assms(2) by auto
  {
    assume "Bet A B C"
    have "A B C CongA P Q R"
    proof -
      have "A B C CongA D E F"
      proof -
        have "C ≠ A ∧ C ≠ B"
          using assms(2) trisuma_distincts by blast
        hence "C Out B A"
          using ‹ Bet A B C› bet_out_1 by fastforce
        thus ?thesis
          using P1 out546_suma__conga by auto
      qed
      moreover have "D E F CongA P Q R"
      proof -
        have "A ≠ C ∧ A ≠ B"
          using assms(2) trisuma_distincts by blast
        hence "A Out C B"
          using Out_def ‹Bet A B C› by auto
        thus ?thesis
          using P1 out546_suma__conga by auto
      qed
      ultimately show ?thesis
        using conga_trans by blast
    qed
    hence "Bet P Q R"
      using ‹Bet A B C› bet_conga__bet by blast
  }
  {
    assume "Bet B C A"
    have "B C A CongA P Q R"
    proof -
      have "B C A CongA D E F"
      proof -
        have "B ≠ A ∧ B ≠ C"
          using assms(2) trisuma_distincts by blast
        hence "B Out A C"
          using Out_def ‹Bet B C A› by auto
        thus ?thesis
          using P1 out213_suma__conga by blast
      qed
      moreover have "D E F CongA P Q R"
      proof -
        have "A ≠ C ∧ A ≠ B"
          using assms(2) trisuma_distincts by auto
        hence "A Out C B"
          using ‹Bet B C A› bet_out_1 by auto
        thus ?thesis
          using P1 out546_suma__conga by blast
      qed
      ultimately show ?thesis
        using not_conga by blast
    qed
    hence "Bet P Q R"
      using ‹Bet B C A› bet_conga__bet by blast
  }
  {
    assume "Bet C A B"
    have "E Out D F"
    proof -
      have "C Out B A"
        using ‹Bet C A B› assms(2) bet_out l6_6 trisuma_distincts by blast
      moreover have "B C A CongA D E F"
      proof -
        have "B ≠ A ∧ B ≠ C"
          using P1 suma_distincts by blast
        hence "B Out A C"
          using ‹Bet C A B› bet_out_1 by auto
        thus ?thesis using out213_suma__conga P1 by blast
      qed
      ultimately show ?thesis
        using l11_21_a by blast
    qed
    hence "C A B CongA P Q R"
      using P1 out213_suma__conga by blast
    hence "Bet P Q R"
      using ‹Bet C A B› bet_conga__bet by blast
  }
  thus ?thesis
    using Col_def ‹Bet A B C ⟹ Bet P Q R› ‹Bet B C A ⟹ Bet P Q R› assms(1) by blast
qed

lemma suma_dec:
  "A B C D E F SumA G H I ∨ ¬ A B C D E F SumA G H I" 
  by simp

lemma sams_dec:
  "SAMS A B C D E F ∨ ¬ SAMS A B C D E F" 
  by simp

lemma trisuma_dec:
  "A B C TriSumA P Q R ∨ ¬ A B C TriSumA P Q R"
  by simp

lemma acute_not_bet:
  assumes "Acute A B C"
  shows "¬ Bet A B C"
  using acute_col__out assms bet_col not_bet_and_out by blast

lemma upper_dim_3_stab:
  assumes "¬ ¬ upper_dim_3_axiom"
  shows "upper_dim_3_axiom" 
  using assms by blast

lemma median_planes_implies_upper_dim: 
  assumes "median_planes_axiom"
  shows "upper_dim_3_axiom"
proof -
  {
    fix A B C P Q R
    assume "P ≠ Q" and "Q ≠ R" and "P ≠ R" and
      "Cong A P A Q" and "Cong B P B Q" and "Cong C P C Q" and
      "Cong A P A R" and "Cong B P B R" and "Cong C P C R" 
    have "Bet A B C ∨ Bet B C A ∨ Bet C A B"
    proof (cases "Col A B C")
      case True
      thus ?thesis
        by (simp add: Col_def upper_dim_3_axiom_def)
    next
      case False
      hence "¬ Col A B C" 
        by simp
      {
        obtain X where "X Midpoint P Q" 
          using midpoint_existence by blast
        obtain Y where "Y Midpoint P R" 
          using midpoint_existence by blast
        have "X = Y" 
        proof -
          have "Per X Y P"
          proof -
            have "¬ Col A B C"
              by (simp add: False)
            moreover have "Per A Y P" 
              using Per_def ‹Cong A P A R› ‹Y Midpoint P R› by blast
            moreover have "Per B Y P" 
              using Per_def ‹Cong B P B R› ‹Y Midpoint P R› by blast
            moreover have "Per C Y P"   
              using Per_def ‹Cong C P C R› ‹Y Midpoint P R› by blast
            moreover 
            have "Cong X P X Q" 
              using Cong_cases ‹X Midpoint P Q› midpoint_cong by blast
            hence "Coplanar A B C X"
              using ‹P ≠ Q› ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong C P C Q› assms 
                median_planes_axiom_def by blast
            ultimately show ?thesis
              using l11_60 by blast
          qed
          moreover have "Per Y X P" 
          proof -
            have "¬ Col A B C" 
              by (simp add: False)
            moreover have "Per A X P"     
              using Per_def ‹Cong A P A Q› ‹X Midpoint P Q› by blast
            moreover have "Per B X P" 
              using Per_def ‹Cong B P B Q› ‹X Midpoint P Q› by blast
            moreover have "Per C X P" 
              using Per_def ‹Cong C P C Q› ‹X Midpoint P Q› by blast
            moreover
            have "Cong Y P Y R" 
              using Cong_cases ‹Y Midpoint P R› midpoint_cong by blast
            hence "Coplanar A B C Y"
              using ‹P ≠ R› ‹Cong A P A R› ‹Cong B P B R› ‹Cong C P C R› 
                assms median_planes_axiom_def by blast
            ultimately show ?thesis
              using l11_60 by blast
          qed
          ultimately show ?thesis 
            using Per_cases l8_7 by blast
        qed
        hence "X Midpoint P R" 
          by (simp add: ‹Y Midpoint P R›)
        hence "Q = R" 
          using ‹X Midpoint P Q› symmetric_point_uniqueness by blast
        hence False 
          using ‹Q ≠ R› by blast
        hence "Bet A B C ∨ Bet B C A ∨ Bet C A B" 
          by simp
      }
      thus ?thesis 
        by (simp add: upper_dim_3_axiom_def)
    qed
  }
  thus ?thesis 
    using upper_dim_3_axiom_def by blast
qed

lemma median_planes_aux:
  assumes "∀ A B C P Q M. P ≠ Q ∧ Cong A P A Q ∧ Cong B P B Q ∧ 
                          Cong C P C Q ∧ M Midpoint P Q ⟶ Coplanar M A B C" 
  shows "median_planes_axiom"
proof -
  {
    fix A B C D P Q
    assume "P ≠ Q" and
      "Cong A P A Q" and
      "Cong B P B Q" and
      "Cong C P C Q" and
      "Cong D P D Q"
    have "Coplanar A B C D" 
    proof (cases "Col A B C")
      case True
      thus ?thesis 
        using ncop__ncols by blast
    next
      case False
      obtain M where "M Midpoint P Q" 
        using midpoint_existence by blast
      obtain A1 A2 where "Coplanar A B C A1" and "Coplanar A B C A2" and "¬ Col M A1 A2" 
        using ex_ncol_cop2 by blast
      have "Cong A1 P A1 Q" 
        using False l11_60_aux ‹Cong A P A Q› ‹Cong B P B Q› 
          ‹Cong C P C Q› ‹Coplanar A B C A1› by blast
      have "Cong A2 P A2 Q" 
        using False ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong C P C Q› ‹Coplanar A B C A2› 
          l11_60_aux by blast
      have "Coplanar M A B C" 
        using assms ‹M Midpoint P Q› ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong C P C Q› 
          ‹P ≠ Q› by presburger
      have "Coplanar M A B D" 
        using assms ‹M Midpoint P Q› ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong D P D Q› 
          ‹P ≠ Q› by blast
      have "Coplanar A B C D" 
      proof -
        have "Coplanar M A1 A2 A"
          by (meson False coplanar_pseudo_trans ‹Coplanar A B C A1› ‹Coplanar A B C A2› 
              ‹Coplanar M A B C› coplanar_perm_9 ncop_distincts) 
        moreover have "Coplanar M A1 A2 B" 
          by (meson False coplanar_pseudo_trans ‹Coplanar A B C A1› ‹Coplanar A B C A2› 
              ‹Coplanar M A B C› coplanar_perm_9 ncop_distincts) 
        moreover have "Coplanar M A1 A2 C" 
          by (meson False ‹Coplanar A B C A1› ‹Coplanar A B C A2› ‹Coplanar M A B C› 
              coplanar_perm_9 coplanar_pseudo_trans ncop_distincts)
        moreover 
        have "Coplanar M A1 A2 D" 
        proof (cases "Col A B M")
          case True
          hence "Col A B M" 
            by blast
          have "Coplanar P Q A B" 
            using Col_def Coplanar_def Midpoint_def True ‹M Midpoint P Q› 
              ncoplanar_perm_15 by blast
          show ?thesis
          proof (cases "Col P Q A")
            case True
            hence "Col P Q A"
              by blast
            thus ?thesis
              using ‹Cong A1 P A1 Q› ‹Cong A2 P A2 Q› ‹Cong D P D Q› ‹M Midpoint P Q› 
                ‹P ≠ Q› assms by blast
          next
            case False
            hence "¬ Col P Q A"
              by simp
            thus ?thesis 
              using ‹Cong A1 P A1 Q› ‹Cong A2 P A2 Q› ‹Cong D P D Q› ‹M Midpoint P Q› 
                ‹P ≠ Q› assms by blast
          qed
        next
          case False
          hence "¬ Col A B M" 
            by blast
          moreover have "Coplanar M A B M" 
            using ncop_distincts by blast
          moreover have "Coplanar M A B A1" 
            by (meson ‹Coplanar M A1 A2 A› ‹Coplanar M A1 A2 B› 
                ‹¬ Col M A1 A2› coplanar_pseudo_trans ncop_distincts)
          moreover have "Coplanar M A B A2" 
            by (meson ‹Coplanar M A1 A2 A› ‹Coplanar M A1 A2 B› 
                ‹¬ Col M A1 A2› coplanar_pseudo_trans ncop_distincts)
          ultimately
          show ?thesis 
            by (meson ‹Coplanar M A B D› coplanar_pseudo_trans not_col_permutation_2)
        qed
        ultimately show ?thesis 
          using ‹¬ Col M A1 A2› coplanar_pseudo_trans by blast
      qed
      thus ?thesis 
        by blast
    qed
  }
  thus ?thesis 
    using median_planes_axiom_def by blast
qed

lemma orthonormal_family_aux_1:
  assumes "orthonormal_family_axiom"
  shows "∀ A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ Per B X P ∧ Per B X Q ⟶ Col A B X" 
proof -
  {
    fix A B X P Q
    assume "¬ Col P Q X" and
      "Per A X P" and
      "Per A X Q" and
      "Per B X P" and "Per B X Q"
    {
      assume "¬ Col A B X"
      obtain P' where "Bet P X P'" and "Cong X P' P X" 
        using segment_construction by blast
      have "A ≠ X" 
        using ‹¬ Col A B X› not_col_distincts by blast
      have "X ≠ P" 
        using ‹¬ Col P Q X› not_col_distincts by blast
      have "X ≠ P'" 
        using ‹Cong X P' P X› ‹X ≠ P› cong_reverse_identity by blast
      obtain Q' where "Per Q' X P" and "Cong Q' X P' X" and "P X OS Q' Q" 
        using ex_per_cong ‹X ≠ P'› ‹X ≠ P› ‹¬ Col P Q X› col_trivial_2 
          not_col_permutation_5 by metis
      have "Per Q' X A" 
      proof (rule l11_60 [where ?A = "P" and ?B = "Q" and ?C = "X"], insert ‹¬ Col P Q X›)
        show "Per P X A" 
          using ‹Per A X P› l8_2 by blast
        show "Per Q X A" 
          by (simp add: ‹Per A X Q› l8_2)
        show "Per X X A" 
          by (simp add: l8_20_1_R1)
        show "Coplanar P Q X Q'" 
          using ‹P X OS Q' Q› coplanar_perm_4 os__coplanar by blast
      qed
      have "Per Q' X B" 
      proof (rule l11_60 [where ?A = "P" and ?B = "Q" and ?C = "X"], insert ‹¬ Col P Q X›)
        show "Per P X B" 
          by (simp add: ‹Per B X P› l8_2)
        show "Per Q X B" 
          using ‹Per B X Q› l8_2 by blast
        show "Per X X B" 
          by (simp add: l8_20_1_R1)
        show "Coplanar P Q X Q'" 
          using ‹P X OS Q' Q› coplanar_perm_4 os__coplanar by blast
      qed
      have "¬ Col P X Q'" 
        using ‹P X OS Q' Q› col123__nos by blast
      let ?Q = "Q'"
      obtain A' where "Bet A X A'" and "Cong X A' P' X" 
        using segment_construction by blast
      have "Per P X A'" 
        using Col_def Per_cases ‹A ≠ X› ‹Bet A X A'› ‹Per A X P› between_symmetry l8_3 by blast
      have "Per ?Q X A'" 
        by (metis Bet_cases Col_def ‹A ≠ X› ‹Bet A X A'› ‹Per Q' X A› per_col)
      have "¬ Col A' B X" 
        by (metis ‹Bet A X A'› ‹Cong X A' P' X› ‹X ≠ P'› ‹¬ Col A B X› 
            bet_col cong_diff_4 l6_16_1 not_col_permutation_2)
      let ?A = "A'"
      have "∃ B'. Per B' X ?A ∧ Cong B' X P' X ∧ ?A X OS B' B"
      proof (rule ex_per_cong)
        show "?A ≠ X" 
          using ‹¬ Col A' B X› col_trivial_3 by force
        show "P' ≠ X" 
          using ‹X ≠ P'› by blast
        show "Col ?A X X" 
          by (simp add: col_trivial_2)
        show "¬ Col ?A X B" 
          using ‹¬ Col A' B X› not_col_permutation_5 by blast
      qed
      then obtain B' where "Per B' X ?A" and "Cong B' X P' X" and "?A X OS B' B"
        by blast
      have "Per B' X P"
      proof (rule l11_60 [where ?A = "?A" and ?B = "B" and ?C = "X"], insert ‹¬ Col A' B X›)
        show "Per ?A X P" 
          by (simp add: ‹Per P X A'› l8_2)
        show "Per B X P" 
          by (simp add: ‹Per B X P›)
        show "Per X X P" 
          by (simp add: l8_20_1_R1)
        show "Coplanar ?A B X B'" 
          using ‹A' X OS B' B› coplanar_perm_4 os__coplanar by blast
      qed
      have "Per B' X ?Q" 
      proof (rule l11_60 [where ?A = "?A" and ?B = "B" and ?C = "X"], insert ‹¬ Col A' B X›)
        show "¬ Col A' B X ⟹ Per A' X ?Q" 
          by (simp add: ‹Per Q' X A'› l8_2) 
        show "¬ Col A' B X ⟹ Per B X ?Q" 
          using Per_cases ‹Per Q' X B› by auto
        show "¬ Col A' B X ⟹ Per X X ?Q" 
          by (simp add: l8_20_1_R1)
        show "¬ Col A' B X ⟹ Coplanar A' B X B'" 
          using ‹A' X OS B' B› coplanar_perm_4 os__coplanar by blast
      qed
      let ?B = "B'"
      have "Cong ?Q P ?Q P'" 
      proof (rule per_double_cong [where ?B = "X"])
        show "Per ?Q X P" 
          using ‹Per Q' X P› by blast
        show "X Midpoint P P'" 
          using Cong_perm Midpoint_def ‹Bet P X P'› ‹Cong X P' P X› by blast
      qed
      have False 
      proof -
        have "Cong X P X P'"
          using Cong_cases ‹Cong X P' P X› by blast
        moreover have "Cong X ?Q X P'" 
          using Cong_cases ‹Cong Q' X P' X› by blast
        moreover have "Cong X ?A X P'" 
          using Cong_cases ‹Cong X A' P' X› by blast
        moreover have "Cong X ?B X P'" 
          using Cong_cases ‹Cong B' X P' X› by blast
        moreover have "Cong P ?Q P' ?Q" 
          using Cong_cases ‹Cong Q' P Q' P'› by blast
        moreover 
        have "Cong P ?A P ?Q" 
          by (meson ‹Cong Q' X P' X› ‹Cong X P' P X› ‹Per P X A'› ‹Per Q' X P› 
              calculation(3) cong_4312 cong_inner_transitivity l10_12)
        hence "Cong P ?A P' ?Q"
          using cong_transitivity calculation(5) by blast
        moreover
        have "Cong P ?B P ?Q" 
        proof (rule l10_12 [where ?B = "X" and ?B' = "X"])
          show "Per P X B'" 
            by (simp add: ‹Per B' X P› l8_2)
          show "Per P X Q'" 
            by (simp add: ‹Per Q' X P› l8_2)
          show "Cong P X P X" 
            by (simp add: cong_reflexivity)
          show "Cong X B' X Q'" 
            by (meson calculation(2) calculation(4) cong_3421 cong_inner_transitivity)
        qed
        hence "Cong P ?B P' ?Q"
          using ‹Cong P Q' P' Q'› cong_transitivity by blast
        moreover have "Cong ?Q ?A P' ?Q" 
          using l10_12 
          by (metis Col_def not_cong_1243 ‹Bet P X P'› ‹Per Q' X A'› ‹Per Q' X P› 
              ‹X ≠ P› between_symmetry calculation(3) cong_reflexivity per_col)
        moreover have "Cong ?A ?B P' ?Q" 
          by (meson ‹Cong X P' P X› ‹Per B' X A'› ‹Per P X A'› calculation(4) calculation(6) 
              cong_pseudo_reflexivity cong_transitivity l10_12)
        moreover 
        have "Cong P ?Q ?Q ?B" 
        proof (rule l10_12 [where ?B = "X" and ?B' = "X"])
          show "Per P X Q'" 
            by (simp add: ‹Per Q' X P› l8_2)
          show "Per Q' X B'" 
            by (simp add: ‹Per B' X Q'› l8_2)
          show "Cong P X Q' X" 
            using ‹Cong X P' P X› calculation(2) cong_3421 cong_transitivity by blast
          show "Cong X Q' X B'" 
            by (meson calculation(2) calculation(4) cong_3421 cong_inner_transitivity)
        qed
        have "Cong P' ?Q P ?Q" 
          using ‹Cong P Q' P' Q'› Cong_cases by auto
        hence "Cong ?Q ?B P' ?Q" 
          using ‹Cong P Q' Q' B'› calculation(5) cong_inner_transitivity by blast
        ultimately show ?thesis 
          using assms ‹X ≠ P'› ‹Bet P X P'› orthonormal_family_axiom_def by blast
      qed
    }
    hence "Col A B X" 
      by blast
  }
  thus ?thesis 
    by blast
qed

lemma orthonormal_family_aux_2:
  assumes "∀ A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ 
                        Per B X P ∧ Per B X Q ⟶ Col A B X" 
  shows "orthonormal_family_axiom" 
proof -
  {
    fix S U1' U1 U2 U3 U4
    assume "S ≠ U1'" and 
      "Bet U1 S U1'" and
      "Cong S U1 S U1'" and
      "Cong S U2 S U1'" and
      "Cong S U3 S U1'" and
      "Cong S U4 S U1'" and
      "Cong U1 U2 U1' U2" and
      "Cong U1 U3 U1' U2" and
      "Cong U1 U4 U1' U2" and
      "Cong U2 U3 U1' U2"  and 
      "Cong U2 U4 U1' U2" and
      "Cong U3 U4 U1' U2"
    have "S Midpoint U1 U1'" 
      using Cong_cases ‹Bet U1 S U1'› ‹Cong S U1 S U1'› midpoint_def by blast
    hence "Per U2 S U1" 
      using Per_def ‹Cong U1 U2 U1' U2› ‹S Midpoint U1 U1'› not_cong_2143 by blast
    have "S ≠ U4" 
      using ‹Cong S U4 S U1'› ‹S ≠ U1'› cong_diff_3 by blast
    have "S ≠ U3" 
      using ‹Cong S U3 S U1'› ‹S ≠ U1'› cong_reverse_identity by auto
    have "S ≠ U2" 
      using ‹Cong S U2 S U1'› ‹S ≠ U1'› cong_diff_3 by blast
    have "S ≠ U1" 
      using ‹Cong S U1 S U1'› ‹S ≠ U1'› cong_diff_3 by blast
    have "U1 ≠ U2" 
      using ‹Per U2 S U1› ‹S ≠ U2› per_distinct_1 by blast
    have "Col U2 U1 S"
    proof -
      have "U2 S U1 CongA U4 S U3" 
        using l11_51 
        by (metis Tarski_neutral_dimensionless.cong_transitivity 
            Tarski_neutral_dimensionless_axioms ‹Cong S U1 S U1'› 
            ‹Cong S U2 S U1'› ‹Cong S U3 S U1'› ‹Cong S U4 S U1'› 
            ‹Cong U1 U2 U1' U2› ‹Cong U3 U4 U1' U2› ‹S ≠ U1› ‹S ≠ U2› ‹U1 ≠ U2› cong_3421)
      hence "Per U4 S U3" 
        using l8_10 l11_17 ‹Per U2 S U1› by blast
      hence "¬ Col U4 S U3" 
        using ‹S ≠ U3› ‹S ≠ U4› per_col_eq by blast
      hence "¬ Col U3 U4 S" 
        using Col_cases by blast
      moreover 
      have "U2 S U1 CongA U2 S U3" 
        by (metis cong_transitivity l11_51 midpoint_cong 
            ‹Cong S U3 S U1'› ‹Cong U1 U2 U1' U2› ‹Cong U2 U3 U1' U2› ‹S Midpoint U1 U1'› 
            ‹S ≠ U1› ‹S ≠ U2› ‹U1 ≠ U2› cong_3421 cong_pseudo_reflexivity)
      hence "Per U2 S U3" 
        using ‹Per U2 S U1› l11_17 by blast
      moreover 
      have "U2 S U1 CongA U2 S U4" 
        by (metis cong_reflexivity cong_transitivity l11_51 
            ‹Cong S U1 S U1'› ‹Cong S U4 S U1'› ‹Cong U1 U2 U1' U2› ‹Cong U2 U4 U1' U2› 
            ‹S ≠ U1› ‹S ≠ U2› ‹U1 ≠ U2› cong_left_commutativity cong_symmetry)
      hence "Per U2 S U4" 
        using ‹Per U2 S U1› l11_17 by blast
      moreover have "U2 S U1 CongA U1 S U3" 
        by (metis cong_transitivity ‹Cong S U1 S U1'› ‹Cong S U2 S U1'› 
            ‹Cong S U3 S U1'› ‹Cong U1 U2 U1' U2› ‹Cong U1 U3 U1' U2› ‹S ≠ U1› ‹S ≠ U2› 
            ‹U1 ≠ U2› cong_left_commutativity cong_symmetry l11_51)
      hence "Per U1 S U3" 
        using ‹Per U2 S U1› l11_17 by blast
      moreover have "U2 S U1 CongA U1 S U4" 
        by (metis cong_transitivity ‹Cong S U1 S U1'› ‹Cong S U2 S U1'› 
            ‹Cong S U4 S U1'› ‹Cong U1 U2 U1' U2› ‹Cong U1 U4 U1' U2› ‹S ≠ U1› 
            ‹S ≠ U2› ‹U1 ≠ U2› cong_left_commutativity cong_symmetry l11_51)
      hence "Per U1 S U4" 
        using ‹Per U2 S U1› l11_17 by blast
      ultimately show ?thesis 
        using assms by blast
    qed
    hence False 
      by (metis NCol_perm ‹Bet U1 S U1'› ‹Cong S U1 S U1'› ‹Cong S U2 S U1'› 
          ‹Cong U1 U2 U1' U2› ‹S ≠ U1'› bet_neq23__neq cong_3421 cong_diff_2 l4_18)
  }
  thus ?thesis 
    using orthonormal_family_axiom_def by blast
qed

lemma orthonormal_family_aux:
  shows "orthonormal_family_axiom ⟷
   (∀ A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ Per B X P ∧ Per B X Q ⟶ Col A B X)" 
  using orthonormal_family_aux_1 orthonormal_family_aux_2 by blast

lemma upper_dim_implies_orthonormal_family_axiom:
  assumes "upper_dim_3_axiom"
  shows "orthonormal_family_axiom" 
proof -
  {
    fix A B X P Q
    assume "¬ Col P Q X" and 
      "Per A X P" and
      "Per A X Q" and
      "Per B X P" and
      "Per B X Q"
    obtain Q' where "Bet Q X Q'" and "Cong X Q' X P" 
      using segment_construction by blast
    have "¬ Col P Q' X" 
      by (metis ‹Bet Q X Q'› ‹Cong X Q' X P› ‹¬ Col P Q X› bet_col bet_cong_eq 
          between_trivial2 col_permutation_2 l6_16_1)
    have "Per A X Q'"  
      by (metis Bet_cases Col_def ‹Bet Q X Q'› ‹Per A X Q› ‹¬ Col P Q X› col_trivial_2 per_col)
    have "Per B X Q'" 
      by (metis Bet_cases Col_def ‹Bet Q X Q'› ‹Per B X Q› ‹¬ Col P Q X› col_trivial_2 per_col)
    obtain R where "X Midpoint P R" 
      using symmetric_point_construction by blast
    have "P ≠ Q'" 
      using ‹¬ Col P Q' X› col_trivial_1 by blast
    have "P ≠ X" 
      using ‹¬ Col P Q X› not_col_distincts by blast
    hence "P ≠ R" 
      using ‹X Midpoint P R› l7_3 by auto
    have "Col A B X"  
    proof -
      have "Q' ≠ R" 
        using Bet_cases Col_def Midpoint_def ‹X Midpoint P R› ‹¬ Col P Q' X› by blast
      moreover have "Cong A P A Q'" 
        using ‹Cong X Q' X P› ‹Per A X P› ‹Per A X Q'› cong_reflexivity 
          l10_12 not_cong_3412 by blast
      moreover have "Cong B P B Q'" 
        using cong_reflexivity l10_12 ‹Cong X Q' X P› ‹Per B X P› 
          ‹Per B X Q'› cong_symmetry by blast
      moreover have "Cong X P X Q'" 
        using ‹Cong X Q' X P› not_cong_3412 by blast
      moreover have "Cong A P A R" 
        using ‹Per A X P› ‹X Midpoint P R› per_double_cong by auto
      moreover have "Cong B P B R" 
        using ‹Per B X P› ‹X Midpoint P R› per_double_cong by blast
      moreover have "Cong X P X R" 
        using Mid_cases ‹X Midpoint P R› l7_13 l7_3_2 by blast
      ultimately show ?thesis 
        using Col_def ‹P ≠ Q'› ‹P ≠ R› assms upper_dim_3_axiom_def by blast
    qed
  }
  thus ?thesis
    using orthonormal_family_aux by blast
qed

lemma orthonormal_family_axiom_implies_orth_at2__col:
  assumes "orthonormal_family_axiom"
  shows "∀ A B C P Q X. X OrthAt A B C X P ∧ X OrthAt A B C X Q ⟶ Col P Q X" 
proof -
  {
    assume "∀ A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ 
                         Per B X P ∧ Per B X Q ⟶ Col A B X" 
    {
      fix A B C P Q X
      assume "X OrthAt A B C X P" and 
        "X OrthAt A B C X Q"
      have 1: "¬ Col A B C ∧ X ≠ P ∧ Coplanar A B C X ∧ (∀ D.(Coplanar A B C D ⟶ Per D X P))" 
        using ‹X OrthAt A B C X P› orth_at_chara by blast
      have 2: "¬ Col A B C ∧ X ≠ Q ∧ Coplanar A B C X ∧ (∀ D.(Coplanar A B C D ⟶ Per D X Q))" 
        using ‹X OrthAt A B C X Q› orth_at_chara by blast
      obtain D E where "Coplanar A B C D" and "Coplanar A B C E" and "¬ Col X D E" 
        using ex_ncol_cop2 by blast
      have "¬ Col D E X" 
        using ‹¬ Col X D E› not_col_permutation_1 by blast
      moreover have "Per P X D" 
        using ‹Coplanar A B C D› 1 l8_2 by blast
      moreover have "Per P X E" 
        using ‹Coplanar A B C E› 1 l8_2 by blast
      moreover have "Per Q X D" 
        using ‹Coplanar A B C D› 2 l8_2 by blast
      moreover have "Per Q X E" 
        using ‹Coplanar A B C E› 2 l8_2 by blast
      ultimately have "Col P Q X" 
        using ‹∀A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ 
                           Per B X P ∧ Per B X Q ⟶ Col A B X› by blast
    }
    hence "∀ A B C P Q X. X OrthAt A B C X P ∧ X OrthAt A B C X Q ⟶ Col P Q X" 
      by blast
  }
  thus ?thesis 
    using assms orthonormal_family_aux by blast
qed

lemma orthonormal_family_axiom_implies_not_two_sides_one_side:
  assumes "orthonormal_family_axiom"
  shows "∀ A B C X Y. ¬ Coplanar A B C X ∧ ¬ Coplanar A B C Y ∧ 
                      ¬ A B C TSP X Y ⟶ A B C OSP X Y" 
proof -
  {
    fix A B C X Y
    assume "¬ Coplanar A B C X" and
      "¬ Coplanar A B C Y" and 
      "¬ A B C TSP X Y"
    obtain P where "P OrthAt A B C P X" 
      using ‹¬ Coplanar A B C X› l11_62_existence_bis by blast
    have "∀ A B X P Q. ¬ Col P Q X ∧ Per A X P ∧ Per A X Q ∧ Per B X P ∧ Per B X Q ⟶ Col A B X"
      using assms orthonormal_family_aux by blast 
    have "¬ Col A B C" 
      using ‹¬ Coplanar A B C Y› col__coplanar by auto
    have "P ≠ X" 
      using ‹P OrthAt A B C P X› orth_at_chara by auto
    have "Coplanar A B C P"  using ‹P OrthAt A B C P X› 
      using orth_at_chara by blast
    have "∀ D. Coplanar A B C D ⟶ Per D P X" 
      using orth_at_chara ‹P OrthAt A B C P X› by presburger
    obtain X' T where "A B C Orth P X'" and "Coplanar A B C T" and "Bet Y T X'" 
      using l8_21_3 ‹Coplanar A B C P› ‹¬ Coplanar A B C Y› by blast
    hence "P OrthAt A B C P X'" 
      using Col_def ‹Coplanar A B C P› col_cop_orth__orth_at not_bet_distincts by blast
    have "¬ Coplanar A B C X'"
      using orth_at__ncop [where ?X = "P"] ‹P OrthAt A B C P X'› by blast
    have "A B C TSP Y X'" 
      using TSP_def ‹Bet Y T X'› ‹Coplanar A B C T› ‹¬ Coplanar A B C X'› 
        ‹¬ Coplanar A B C Y› by auto
    moreover
    have "Bet X P X'" 
    proof -
      have "Col X' X P" 
        using  ‹P OrthAt A B C P X› ‹P OrthAt A B C P X'› 
          orthonormal_family_axiom_implies_orth_at2__col assms by blast
      hence "Col X P X'" 
        using col_permutation_1 by blast
      moreover
      {
        assume "P Out X X'"
        have "A B C TSP X' Y" 
          by (simp add: ‹A B C TSP Y X'› l9_38)
        moreover have "A B C OSP X' X" 
          using ‹Coplanar A B C P› ‹P Out X X'› ‹¬ Coplanar A B C X› 
            cop_out__osp osp_symmetry by blast
        ultimately have "A B C TSP X Y" 
          using l9_41_2 by blast
      }
      hence "¬ P Out X X'" 
        using  ‹¬ A B C TSP X Y›  by blast
      ultimately show ?thesis 
        using or_bet_out by blast
    qed
    hence "A B C TSP X X'"
      using TSP_def ‹Coplanar A B C P› ‹¬ Coplanar A B C X'› ‹¬ Coplanar A B C X› by blast
    ultimately
    have "A B C OSP X Y" 
      using OSP_def by blast
  }
  thus ?thesis 
    by blast
qed

lemma orthonormal_family_axiom_implies_space_separation:
  assumes "orthonormal_family_axiom"
  shows "space_separation_axiom" 
proof -
  {
    fix A B C P Q
    assume "¬ Coplanar A B C P" and 
      "¬ Coplanar A B C Q"
    {
      assume "¬ A B C TSP P Q"
      hence "A B C OSP P Q" 
        using orthonormal_family_axiom_implies_not_two_sides_one_side 
          ‹¬ Coplanar A B C P› ‹¬ Coplanar A B C Q› assms by blast
    }
    hence "A B C TSP P Q ∨ A B C OSP P Q" 
      by blast
  }
  thus ?thesis 
    using space_separation_axiom_def by blast
qed

lemma space_separation_implies_plane_intersection:
  assumes "space_separation_axiom"
  shows "plane_intersection_axiom" 
proof -
  {
    fix A B C D E P
    assume "Coplanar A B C P" and 
      "¬ Col D E P" 
    have "∃ Q. Coplanar A B C Q ∧ Coplanar D E P Q ∧ P ≠ Q" 
    proof (cases "Coplanar A B C D")
      case True
      thus ?thesis 
        using ‹¬ Col D E P› col_trivial_3 ncop_distincts by blast
    next
      case False
      hence "¬ Coplanar A B C D" 
        by blast
      show ?thesis 
      proof (cases "Coplanar A B C E")
        case True
        thus ?thesis 
          using ‹¬ Col D E P› col_trivial_2 ncop_distincts by blast
      next
        case False
        thus ?thesis 
          using ‹Coplanar A B C P› ‹¬ Coplanar A B C D› assms 
            cop_osp__ex_cop2 cop_tsp__ex_cop2 space_separation_axiom_def by fastforce
      qed
    qed
  }
  hence 1: "∀ A B C D E P. Coplanar A B C P ∧ ¬ Col D E P ⟶
    (∃ Q. Coplanar A B C Q ∧ Coplanar D E P Q ∧ P ≠ Q)" 
    by blast
  {
    fix A B C D E F P
    assume "Coplanar A B C P" 
      and "Coplanar D E F P"
    obtain D' E' where "Coplanar D E F D'" and "Coplanar D E F E'" and "¬ Col P D' E'" 
      using ex_ncol_cop2 by blast
    have "¬ Col D' E' P" 
      by (simp add: ‹¬ Col P D' E'› not_col_permutation_1)
    then obtain Q where "Coplanar A B C Q" and "Coplanar D' E' P Q" and "P ≠ Q" 
      using 1 ‹Coplanar A B C P› by blast
    hence "∃ Q. Coplanar A B C Q ∧ Coplanar D E F Q ∧ P ≠ Q" 
      by (meson ‹Coplanar D E F D'› ‹Coplanar D E F E'› ‹Coplanar D E F P› 
          ‹¬ Col D' E' P› l9_30 ncop_distincts)
  }
  thus ?thesis 
    using plane_intersection_axiom_def by blast
qed

lemma plane_intersection_implies_space_separation:
  assumes "plane_intersection_axiom"
  shows "space_separation_axiom" 
proof -
  {
    fix A B C P Q
    assume "¬ Coplanar A B C P" and "¬ Coplanar A B C Q"
    have "Coplanar A P Q A" 
      using ncop_distincts by blast
    then obtain D where "Coplanar A B C D" and "Coplanar A P Q D" and "A ≠ D"
      using assms plane_intersection_axiom_def coplanar_perm_5 coplanar_trivial by blast
    have "A D TS P Q ∨ A D OS P Q"
    proof (rule cop__one_or_two_sides)
      show "Coplanar A D P Q" 
        by (simp add: ‹Coplanar A P Q D› coplanar_perm_4)
      show "¬ Col P A D" 
        by (metis ‹A ≠ D› ‹Coplanar A B C D› ‹¬ Coplanar A B C P› 
            col_cop2__cop col_permutation_3 ncop_distincts)
      show "¬ Col Q A D" 
        by (meson ‹A ≠ D› ‹Coplanar A B C D› ‹¬ Coplanar A B C Q› 
            col_cop__cop col_permutation_1 ncoplanar_perm_8)
    qed
    moreover
    have "A D TS P Q ⟶ A B C TSP P Q"
      using ‹Coplanar A B C D› ‹¬ Coplanar A B C P› cop2_ts__tsp ncop_distincts by blast
    moreover have "A D OS P Q ⟶ A B C OSP P Q"
      using ‹Coplanar A B C D› ‹¬ Coplanar A B C P› cop2_os__osp ncop_distincts by blast
    ultimately have "A B C TSP P Q ∨ A B C OSP P Q" 
      by blast
  }
  thus ?thesis 
    using space_separation_axiom_def by blast
qed

lemma space_separation_implies_median_planes:
  assumes "space_separation_axiom"
  shows "median_planes_axiom" 
proof -
  {
    fix A B C P Q M
    assume "P ≠ Q" and 
      "Cong A P A Q" and
      "Cong B P B Q" and
      "Cong C P C Q" and
      "M Midpoint P Q"
    {
      fix X P Q M
      assume "P ≠ Q" and 
        "Cong A P A Q" and
        "Cong B P B Q" and
        "M Midpoint P Q" and
        "M A B TSP Q X" and
        "Cong X P X Q"
      have "¬ Coplanar M A B Q" 
        using ‹M A B TSP Q X› tsp__ncop1 by blast
      have "¬ Coplanar M A B X" 
        using ‹M A B TSP Q X› tsp__ncop2 by auto
      obtain T where "Coplanar M A B T" and "Bet Q T X" 
        using TSP_def ‹M A B TSP Q X› by blast
      {
        fix C
        assume "Coplanar M A B C"
        have "¬ Col M A B" 
          using ‹M A B TSP Q X› ncop__ncol tsp__ncop2 by blast
        moreover have "Cong M P M Q" 
          using midpoint_cong ‹M Midpoint P Q› cong_left_commutativity by blast
        ultimately have "Cong C P C Q" 
          using ‹Coplanar M A B C› ‹Cong A P A Q› ‹Cong B P B Q› l11_60_aux by blast
      }
      hence "∀ C. Coplanar M A B C ⟶ Cong C P C Q" 
        by blast
      {
        assume "Bet X T P" 
        have "¬ Coplanar M A B P" 
          by (metis ‹P ≠ Q› ‹∀C. Coplanar M A B C ⟶ Cong C P C Q› cong_diff_4)
        have "∀ Z. ¬ Coplanar M A B Z ⟶ Z ≠ T" 
          using ‹Coplanar M A B T› by blast
        have "X ≠ T" 
          using ‹Coplanar M A B T› ‹¬ Coplanar M A B X› by blast
        hence "M Out P Q" 
          by (metis ‹Bet Q T X› ‹Bet X T P› ‹Cong X P X Q› ‹P ≠ Q› 
              between_cong between_symmetry l5_1 not_cong_3412)
        moreover
        have "Bet P M Q" 
          using Midpoint_def ‹M Midpoint P Q› by auto
        ultimately have False 
          using not_bet_and_out by auto
      }
      moreover
      have "Cong T P T Q" 
        using ‹Coplanar M A B T› ‹∀C. Coplanar M A B C ⟶ Cong C P C Q› by blast
      ultimately have False         
        using triangle_strict_inequality ‹Bet Q T X› ‹Cong X P X Q›
          between_symmetry cong__nlt by blast
    }
    hence 1: "∀ X P Q M. P ≠ Q ∧ Cong A P A Q ∧ Cong B P B Q ∧ M Midpoint P Q ∧ 
M A B TSP Q X ∧ Cong X P X Q ⟶ False" 
      by blast
    {
      assume "¬ Coplanar M A B C" 
      have "¬ Col M A B" 
        using ‹¬ Coplanar M A B C› ncop__ncols by blast
      {
        assume "Coplanar M A B Q"
        have "Cong M P M Q" 
          using Cong_cases ‹M Midpoint P Q› midpoint_cong by blast
        hence False 
          using l11_60_aux ‹Cong A P A Q› ‹Cong B P B Q› ‹Coplanar M A B Q› 
            ‹P ≠ Q› ‹¬ Col M A B› cong_diff_2 by blast
      }
      hence "¬ Coplanar M A B Q"
        by blast
      {
        assume "M A B TSP Q C"
        hence False 
          using 1 ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong C P C Q› ‹M Midpoint P Q› ‹P ≠ Q› by blast
      }
      moreover
      {
        assume "M A B OSP Q C"
        have "M Midpoint Q P" 
          using Mid_cases ‹M Midpoint P Q› by auto
        have "M A B TSP P C" 
        proof -
          have "M A B TSP Q P" 
            by (metis Bet_cases Midpoint_def ‹Coplanar M A B Q ⟹ False› ‹M Midpoint P Q› 
                bet_cop__tsp midpoint_distinct_3 ncop_distincts)
          thus ?thesis
            using ‹M A B OSP Q C› l9_38 l9_41_2 by blast
        qed
        hence False 
          using 1 by (metis ‹Cong A P A Q› ‹Cong B P B Q› ‹Cong C P C Q› 
              ‹M Midpoint Q P› ‹P ≠ Q› not_cong_3412)
      }
      ultimately have False 
        using ‹¬ Coplanar M A B C› ‹¬ Coplanar M A B Q› assms 
          space_separation_axiom_def by blast
    }
    hence "Coplanar M A B C" 
      by blast
  }
  thus ?thesis 
    using median_planes_aux by blast
qed

theorem upper_dim_3_equivalent_axioms: 
  shows "(upper_dim_3_axiom        ⟷ orthonormal_family_axiom) ∧
         (orthonormal_family_axiom ⟷ space_separation_axiom)   ∧
         (space_separation_axiom   ⟷ plane_intersection_axiom) ∧
         (plane_intersection_axiom ⟷ median_planes_axiom)" 
  using median_planes_implies_upper_dim orthonormal_family_axiom_implies_space_separation 
    plane_intersection_implies_space_separation space_separation_implies_median_planes 
    space_separation_implies_plane_intersection 
    upper_dim_implies_orthonormal_family_axiom by fastforce

lemma par_reflexivity:
  assumes "A ≠ B"
  shows "A B Par A B"
  using Par_def assms not_col_distincts by blast

lemma par_strict_irreflexivity:
  "¬ A B ParStrict A B"
  using ParStrict_def col_trivial_3 by blast

lemma not_par_strict_id:
  "¬ A B ParStrict A C"
  using ParStrict_def col_trivial_1 by blast

lemma par_id:
  assumes "A B Par A C"
  shows "Col A B C"
  using Col_cases Par_def assms not_par_strict_id by auto

lemma par_strict_not_col_1:
  assumes "A B ParStrict C D"
  shows "¬ Col A B C"
  using Col_perm ParStrict_def assms col_trivial_1 by blast

lemma par_strict_not_col_2:
  assumes "A B ParStrict C D"
  shows "¬ Col B C D"
  using ParStrict_def assms col_trivial_3 by auto

lemma par_strict_not_col_3:
  assumes "A B ParStrict C D"
  shows "¬ Col C D A"
  using Col_perm ParStrict_def assms col_trivial_1 by blast

lemma par_strict_not_col_4:
  assumes "A B ParStrict C D"
  shows "¬ Col A B D"
  using Col_perm ParStrict_def assms col_trivial_3 by blast

lemma par_id_1:
  assumes "A B Par A C"
  shows "Col B A C"
  using Par_def assms not_par_strict_id by auto

lemma par_id_2:
  assumes "A B Par A C"
  shows "Col B C A"
  using Col_perm assms par_id_1 by blast

lemma par_id_3:
  assumes "A B Par A C"
  shows "Col A C B"
  using Col_perm assms par_id_2 by blast

lemma par_id_4:
  assumes "A B Par A C"
  shows "Col C B A"
  using Col_perm assms par_id_2 by blast

lemma par_id_5:
  assumes "A B Par A C"
  shows "Col C A B"
  using assms col_permutation_2 par_id by blast

lemma par_strict_symmetry:
  assumes "A B ParStrict C D"
  shows "C D ParStrict A B"
  using ParStrict_def assms coplanar_perm_16 by blast

lemma par_symmetry:
  assumes "A B Par C D"
  shows "C D Par A B"
proof -
  have "A B ParStrict C D ∨ (A ≠ B ∧ C ≠ D ∧ Col A C D ∧ Col B C D)" 
    using Par_def assms by auto
  thus ?thesis 
    by (metis (full_types) Col_cases Par_def col2__eq par_strict_symmetry)
qed

lemma par_left_comm:
  assumes "A B Par C D"
  shows "B A Par C D"
  by (metis ParStrict_def Par_def assms ncoplanar_perm_6 not_col_permutation_5)

lemma par_right_comm:
  assumes "A B Par C D"
  shows "A B Par D C"
  using assms par_left_comm par_symmetry by blast

lemma par_comm:
  assumes "A B Par C D"
  shows "B A Par D C"
  using assms par_left_comm par_right_comm by blast

lemma par_strict_left_comm:
  assumes "A B ParStrict C D"
  shows "B A ParStrict C D"
  using ParStrict_def assms ncoplanar_perm_6 not_col_permutation_5 by blast

lemma par_strict_right_comm:
  assumes "A B ParStrict C D"
  shows "A B ParStrict D C"
  using assms par_strict_left_comm par_strict_symmetry by blast

lemma par_strict_comm:
  assumes "A B ParStrict C D"
  shows "B A ParStrict D C"
  by (simp add: assms par_strict_left_comm par_strict_right_comm)

lemma par_strict_neq1:
  assumes "A B ParStrict C D"
  shows "A ≠ B"
  using assms col_trivial_1 par_strict_not_col_4 by blast

lemma par_strict_neq2:
  assumes "A B ParStrict C D"
  shows "C ≠ D"
  using assms col_trivial_2 par_strict_not_col_2 by blast

lemma par_neq1:
  assumes "A B Par C D"
  shows "A ≠ B"
  using Par_def assms par_strict_neq1 by blast

lemma par_neq2:
  assumes "A B Par C D"
  shows "C ≠ D"
  using assms par_neq1 par_symmetry by blast

lemma Par_cases:
  assumes "A B Par C D ∨ B A Par C D ∨ A B Par D C ∨ B A Par D C ∨ 
           C D Par A B ∨ C D Par B A ∨ D C Par A B ∨ D C Par B A"
  shows "A B Par C D"
  using assms par_right_comm par_symmetry by blast

lemma Par_perm:
  assumes "A B Par C D"
  shows "A B Par C D ∧ B A Par C D ∧ A B Par D C ∧ B A Par D C ∧ 
         C D Par A B ∧ C D Par B A ∧ D C Par A B ∧ D C Par B A"
  using Par_cases assms by blast

lemma Par_strict_cases:
  assumes "A B ParStrict C D ∨ B A ParStrict C D ∨ A B ParStrict D C ∨ 
           B A ParStrict D C ∨ C D ParStrict A B ∨ C D ParStrict B A ∨ 
           D C ParStrict A B ∨ D C ParStrict B A"
  shows "A B ParStrict C D"
  using assms par_strict_right_comm par_strict_symmetry by blast

lemma Par_strict_perm:
  assumes "A B ParStrict C D"
  shows "A B ParStrict C D ∧ B A ParStrict C D ∧ A B ParStrict D C ∧ 
         B A ParStrict D C ∧ C D ParStrict A B ∧ C D ParStrict B A ∧ 
         D C ParStrict A B ∧ D C ParStrict B A"
  using Par_strict_cases assms by blast

lemma l12_6:
  assumes "A B ParStrict C D"
  shows "A B OS C D"
  by (metis Col_def ParStrict_def Par_strict_perm TS_def assms cop_nts__os 
      par_strict_not_col_2)

lemma pars__os3412:
  assumes "A B ParStrict C D"
  shows "C D OS A B"
  by (simp add: assms l12_6 par_strict_symmetry)

lemma perp_dec:
  "A B Perp C D ∨ ¬ A B Perp C D"
  by simp

lemma col_cop2_perp2__col:
  assumes "X1 X2 Perp A B" and
    "Y1 Y2 Perp A B" and
    "Col X1 Y1 Y2" and
    "Coplanar A B X2 Y1" and
    "Coplanar A B X2 Y2"
  shows "Col X2 Y1 Y2"
proof cases
  assume "X1 = Y2"
  thus ?thesis
    using assms(1) assms(2) assms(4) cop_perp2__col not_col_permutation_2 
      perp_left_comm by blast
next
  assume "X1 ≠ Y2"
  hence "Y2 X1 Perp A B"
    by (metis Col_cases assms(2) assms(3) perp_col perp_comm perp_right_comm)
  hence P1: "X1 Y2 Perp A B"
    using Perp_perm by blast
  thus ?thesis
  proof cases
    assume "X1 = Y1"
    thus ?thesis
      using assms(1) assms(2) assms(5) cop_perp2__col not_col_permutation_4 by blast
  next
    assume "X1 ≠ Y1"
    hence "X1 Y1 Perp A B"
      using Col_cases P1 assms(3) perp_col by blast
    thus ?thesis
      using P1 assms(1) assms(4) assms(5) col_transitivity_2 cop_perp2__col 
        perp_not_eq_1 by blast
  qed
qed

lemma col_perp2_ncol_col:
  assumes "X1 X2 Perp A B" and
    "Y1 Y2 Perp A B" and
    "Col X1 Y1 Y2" and
    "¬ Col X1 A B"
  shows "Col X2 Y1 Y2"
proof (cases "Y1 = Y2")
  case True
  thus ?thesis 
    using col_trivial_2 by blast
next
  case False
  hence "Y1 ≠ Y2"
    by blast
  show ?thesis
  proof (cases "X2 = Y1")
    case True
    thus ?thesis 
      by (simp add: col_trivial_1)
  next 
    case False
    hence "X2 ≠ Y1"
      by blast
    show ?thesis 
    proof (cases "X1 = Y1")
      case True
      hence "Coplanar A B X2 Y1" 
        using assms(1) coplanar_perm_17 perp__coplanar by blast
      hence "Coplanar A B X2 Y2" 
        using True assms(2) assms(4) coplanar_perm_18 coplanar_perm_3 
          coplanar_trans_1 perp__coplanar by blast
      thus ?thesis 
        using True assms(1) assms(2) col_permutation_4 cop_perp2__col by blast
    next
      case False
      hence "X1 ≠ Y1" 
        by blast
      hence "Y1 X1 Perp A B"
        by (metis Col_cases assms(2) assms(3) perp_col)
      hence "Coplanar A B X2 Y1" 
        by (meson assms(1) assms(4) coplanar_perm_3 coplanar_trans_1 
            ncoplanar_perm_18 perp__coplanar)
      hence "Coplanar A B X2 Y2" 
        by (meson False assms(1) assms(3) col_cop2__cop ncoplanar_perm_22 perp__coplanar)
      thus ?thesis 
        by (metis ‹Coplanar A B X2 Y1› ‹Y1 X1 Perp A B› assms(1) assms(2) 
            col_permutation_2 cop_perp2__col not_col_distincts perp_col2)
    qed
  qed
qed

lemma l12_9:
  assumes
    "Coplanar C1 C2 A1 B1" and
    "Coplanar C1 C2 A1 B2" and
    "Coplanar C1 C2 A2 B1" and
    "Coplanar C1 C2 A2 B2" and
    "A1 A2 Perp C1 C2" and
    "B1 B2 Perp C1 C2"
  shows "A1 A2 Par B1 B2"
proof (cases)
  assume "Col A1 B1 B2"
  moreover have "A1 ≠ A2"
    using assms(5) perp_distinct by auto
  moreover have "B1 ≠ B2"
    using assms(6) perp_distinct by auto
  ultimately show ?thesis
    using Par_def assms(3) assms(4) assms(5) assms(6) col_cop2_perp2__col by blast
next
  assume "¬ Col A1 B1 B2"
  {
    assume "¬ Col C1 C2 A1"
    hence "Coplanar A1 A2 B1 B2" 
    proof -
      have "Coplanar C1 C2 A1 A1" 
        using ncop_distincts by blast
      moreover have "C1 C2 Perp A1 A2" 
        using Perp_perm assms(5) by blast
      hence "Coplanar C1 C2 A1 A2" 
        using perp__coplanar by auto
      ultimately show ?thesis 
        by (meson coplanar_pseudo_trans ‹¬ Col C1 C2 A1› assms(1) assms(2))
    qed
  }
  moreover
  {
    assume "¬ Col C1 C2 A2"
    have "Coplanar A1 A2 B1 B2"
    proof -
      have "C1 C2 Perp A2 A1" 
        using Perp_perm assms(5) by blast
      hence "Coplanar C1 C2 A2 A1" 
        using perp__coplanar by auto
      moreover have "Coplanar C1 C2 A2 A2" 
        using ncop_distincts by blast
      ultimately show ?thesis 
        by (meson ‹¬ Col C1 C2 A2› assms(3) assms(4) coplanar_perm_5 coplanar_pseudo_trans_lem1)
    qed
  }
  moreover
  {
    assume "∃ X. Col X A1 A2 ∧ Col X B1 B2"
    then obtain AB where "Col AB A1 A2" and "Col AB B1 B2" by auto
    have "False"
    proof cases
      assume "AB = A1"
      thus ?thesis
        using ‹¬ Col A1 B1 B2› ‹Col AB B1 B2› by blast
    next
      assume "AB ≠ A1"
      hence "A1 AB Perp C1 C2"
        using assms(5) not_col_permutation_2 perp_col by (metis ‹Col AB A1 A2›)
      hence "AB A1 Perp C1 C2"
        by (simp add: perp_left_comm)
      thus ?thesis
        using assms(1) assms(2) assms(6) col_cop2_perp2__col
          ‹Col AB B1 B2› ‹¬ Col A1 B1 B2› by blast
    qed
  }
  moreover
  have "C1 C2 Perp A1 A2"
    using Perp_cases assms(5) by blast
  hence "¬ Col C1 C2 A1 ∨ ¬ Col C1 C2 A2" 
    using perp_not_col2 by blast
  ultimately show ?thesis 
    using ParStrict_def Par_def by blast
qed

lemma parallel_existence:
  assumes "A ≠ B"
  shows "∃ C D. C ≠ D ∧ A B Par C D ∧ Col P C D"
proof cases
  assume "Col A B P"
  thus ?thesis
    using Col_perm assms par_reflexivity by blast
next
  assume "¬ Col A B P"
  then obtain P' where "Col A B P'" and "A B Perp P P'"
    using l8_18_existence by blast
  hence "P ≠ P'" 
    using ‹¬ Col A B P› by auto
  show ?thesis
  proof cases
    assume "P' = A"
    have "∃ Q. Per Q P A ∧ Cong Q P A B ∧ A P OS Q B"
    proof -
      have "Col A P P"
        using not_col_distincts by auto
      moreover have "¬ Col A P B" 
        using ‹¬ Col A B P› not_col_permutation_5 by blast
      ultimately show ?thesis 
        using ex_per_cong not_col_distincts by presburger
    qed
    then obtain Q where "Per Q P A" and "Cong Q P A B" and "A P OS Q B" by auto
    hence "P ≠ Q"
      using os_distincts by auto
    moreover have "A B Par P Q" 
    proof -
      have "P Q Perp P A" 
        by (metis Perp_cases ‹P ≠ P'› ‹P ≠ Q› ‹P' = A› ‹Per Q P A› per_perp)
      moreover have "Coplanar P A A P"
        using ncop_distincts by auto
      moreover have "Coplanar P A B P"
        using ncop_distincts by auto
      moreover have "Coplanar P A B Q" 
        using ‹A P OS Q B› coplanar_perm_7 os__coplanar by blast
      moreover have "A B Perp P A" 
        using ‹A B Perp P P'› ‹P' = A› by auto
      ultimately show ?thesis 
        using l12_9 ncop_distincts by blast
    qed
    ultimately show ?thesis 
      using col_trivial_1 by auto
  next
    assume "P' ≠ A"
    have "∃ Q. Per Q P P' ∧ Cong Q P A B ∧ P' P OS Q A" 
    proof -
      have "P' ≠ P" 
        using ‹P ≠ P'› by auto
      moreover have "A ≠ B"
        by (simp add: assms)
      moreover have "Col P' P P"
        using not_col_distincts by blast
      moreover have "¬ Col P' P A" 
        using Col_perm ‹Col A B P'› ‹¬ Col A B P› col_transitivity_2 ‹P' ≠ A› by blast
      ultimately show ?thesis
        using ex_per_cong by blast
    qed
    then obtain Q where "Per Q P P'" and "Cong Q P A B" and "P' P OS Q A" by blast
    hence "P ≠ Q"
      using os_distincts by blast
    moreover have "A B Par P Q"
    proof -
      have "Coplanar P P' A P"
        using ncop_distincts by auto
      moreover have "Coplanar P P' A Q"
        using ncoplanar_perm_7 os__coplanar ‹P' P OS Q A› by blast
      moreover 
      have "Coplanar A P B Q" 
        using ‹Coplanar P P' A Q› col_cop2__cop coplanar_perm_9 
          ncop_distincts ncoplanar_perm_17 not_col_permutation_5 
        by (metis ‹Col A B P'› ‹P' ≠ A›)
      hence "Coplanar P P' B Q"
        using assms col2_cop__cop col_trivial_2 coplanar_perm_10 coplanar_perm_5 
          calculation(1) by (meson ‹Col A B P'›)
      moreover have "Coplanar P P' B P"
        using ncop_distincts by auto
      moreover have "P Q Perp P P'"
        using Perp_perm per_perp by (metis ‹P ≠ P'› ‹P ≠ Q› ‹Per Q P P'›)
      ultimately show ?thesis
        using l12_9 ‹A B Perp P P'› by blast
    qed
    moreover have "Col P P Q"
      by (simp add: col_trivial_1)
    ultimately show ?thesis
      by blast
  qed
qed

lemma par_col_par:
  assumes "C ≠ D'" and
    "A B Par C D" and
    "Col C D D'"
  shows "A B Par C D'"
proof -
  {
    assume P1: "A B ParStrict C D"
    have "Coplanar A B C D'"
      using assms(2) assms(3) col2__eq col2_cop__cop par__coplanar par_neq2 by blast
    {
      assume "∃ X. Col X A B ∧ Col X C D'"
      then obtain X where "Col X A B" and "Col X C D'"
        by blast
      hence "Col X C D" 
        using Col_cases assms(1) assms(3) col2__eq by blast
      hence False 
        using P1 ParStrict_def ‹Col X A B› by auto
    }
    hence "A B Par C D'" 
      using ParStrict_def Par_def ‹Coplanar A B C D'› by blast
  }
  {
    assume "A ≠ B ∧ C ≠ D ∧ Col A C D ∧ Col B C D"
    hence "A B Par C D'"
      using Par_def assms(1) assms(3) col2__eq col_permutation_2 by blast
  }
  thus ?thesis
    using Par_def ‹A B ParStrict C D ⟹ A B Par C D'› assms(2) by auto
qed

lemma parallel_existence1:
  assumes "A ≠ B"
  shows "∃ Q. A B Par P Q"
proof -
  obtain C D where "C ≠ D ∧ A B Par C D ∧ Col P C D"
    using assms parallel_existence by blast
  thus ?thesis
    by (metis Col_cases Par_cases par_col_par)
qed

lemma par_not_col:
  assumes "A B ParStrict C D" and
    "Col X A B"
  shows "¬ Col X C D"
  using ParStrict_def assms(1) assms(2) by blast

lemma not_strict_par1:
  assumes "A B Par C D" and
    "Col A B X" and
    "Col C D X"
  shows "Col A B C"
proof -
  have "A B ParStrict C D ∨ (A ≠ B ∧ C ≠ D ∧ Col A C D ∧ Col B C D)" 
    using Par_def assms(1) by blast
  thus ?thesis 
    by (meson assms(2) assms(3) col2__eq col_permutation_2 par_not_col)
qed

lemma not_strict_par2:
  assumes "A B Par C D" and
    "Col A B X" and
    "Col C D X"
  shows "Col A B D"
  using Par_cases assms(1) assms(2) assms(3) not_col_permutation_4 
    not_strict_par1 by blast

lemma not_strict_par:
  assumes "A B Par C D" and
    "Col A B X" and      
    "Col C D X"
  shows "Col A B C ∧ Col A B D"
  using assms(1) assms(2) assms(3) not_strict_par1 not_strict_par2 by blast

lemma not_par_not_col:
  assumes "A ≠ B" and
    "A ≠ C" and
    "¬ A B Par A C"
  shows "¬ Col A B C"
  using Par_def assms(1) assms(2) assms(3) not_col_distincts 
    not_col_permutation_4 by blast

lemma not_par_inter_uniqueness:
  assumes "A ≠ B" and
    "C ≠ D" and
    "¬ A B Par C D" and
    "Col A B X" and
    "Col C D X" and
    "Col A B Y" and
    "Col C D Y"
  shows "X = Y"
proof cases
  assume P1: "C = Y"
  thus ?thesis
  proof cases
    assume P2: "C = X"
    thus ?thesis
      using P1 by auto
  next
    assume "C ≠ X"
    hence "¬ Col C D A" 
      by (metis P1 Par_def assms(1) assms(2) assms(3) assms(4) assms(5) 
          assms(6) col_permutation_1 col_transitivity_2)
    thus ?thesis 
      using assms(1) assms(4) assms(5) assms(6) assms(7) l6_21 by blast
  qed
next
  assume "C ≠ Y"
  hence "¬ Col A B C" 
    by (metis Par_def assms(1) assms(2) assms(3) assms(6) assms(7) 
        col_transitivity_1 col_transitivity_2 colx not_col_permutation_5)
  thus ?thesis 
    using assms(2) assms(4) assms(5) assms(6) assms(7) l6_21 by blast
qed

lemma inter_uniqueness_not_par:
  assumes  "¬ Col A B C" and
    "Col A B P" and
    "Col C D P"
  shows "¬ A B Par C D"
  using assms(1) assms(2) assms(3) not_strict_par1 by blast

lemma col_not_col_not_par:
  assumes "∃ P. Col A B P ∧ Col C D P" and
    "∃ Q. Col C D Q ∧ ¬Col A B Q"
  shows "¬ A B Par C D"
  using assms(1) assms(2) colx not_strict_par par_neq2 by blast

lemma par_distincts:
  assumes "A B Par C D"
  shows "A B Par C D ∧ A ≠ B ∧ C ≠ D"
  using assms par_neq1 par_neq2 by blast

lemma par_not_col_strict:
  assumes "A B Par C D" and
    "Col C D P" and
    "¬ Col A B P"
  shows "A B ParStrict C D"
  using Col_cases Par_def assms(1) assms(2) assms(3) col3 by blast

lemma col_cop_perp2__pars:
  assumes "¬ Col A B P" and
    "Col C D P" and
    "Coplanar A B C D" and
    "A B Perp P Q" and
    "C D Perp P Q"
  shows  "A B ParStrict C D"
proof -
  have P1: "C ≠ D"
    using assms(5) perp_not_eq_1 by auto
  hence P2: "Coplanar A B C P"
    using col_cop__cop assms(2) assms(3) by blast
  moreover have P3: "Coplanar A B D P" using col_cop__cop
    using P1 assms(2) assms(3) col2_cop__cop col_trivial_2 by blast
  have "A B Par C D"
  proof -
    have "Coplanar P A Q C"
    proof -
      have "¬ Col B P A"
        by (simp add: assms(1) not_col_permutation_1)
      moreover have "Coplanar B P A Q"
        by (meson assms(4) ncoplanar_perm_12 perp__coplanar)
      moreover have "Coplanar B P A C"
        using P2 ncoplanar_perm_13 by blast
      ultimately show ?thesis
        using coplanar_trans_1 by auto
    qed
    hence P4: "Coplanar P Q A C"
      using ncoplanar_perm_2 by blast
    have "Coplanar P A Q D"
    proof -
      have "¬ Col B P A"
        by (simp add: assms(1) not_col_permutation_1)
      moreover have "Coplanar B P A Q"
        by (meson assms(4) ncoplanar_perm_12 perp__coplanar)
      moreover have "Coplanar B P A D"
        using P3 ncoplanar_perm_13 by blast
      ultimately show ?thesis
        using coplanar_trans_1 by blast
    qed
    then moreover have "Coplanar P Q A D"
      using ncoplanar_perm_2 by blast
    moreover have "Coplanar P Q B C"
      using P2 assms(1) assms(4) coplanar_perm_1 coplanar_perm_10 coplanar_trans_1 
        perp__coplanar by blast
    moreover have "Coplanar P Q B D"
      by (meson P3 assms(1) assms(4) coplanar_trans_1 ncoplanar_perm_1 
          ncoplanar_perm_13 perp__coplanar)
    ultimately show ?thesis
      using assms(4) assms(5) l12_9 P4 by auto
  qed
  thus ?thesis
    using assms(1) assms(2) par_not_col_strict by auto
qed

lemma all_one_side_par_strict:
  assumes "C ≠ D" and
    "∀ P. Col C D P ⟶ A B OS C P"
  shows "A B ParStrict C D"
proof -
  have P1: "Coplanar A B C D"
    by (simp add: assms(2) col_trivial_2 os__coplanar)
  {
    assume "∃ X. Col X A B ∧ Col X C D"
    then obtain X where P2: "Col X A B ∧ Col X C D" by blast
    have "A B OS C X"
      by (simp add: P2 Col_perm assms(2))
    then obtain M where "A B TS C M ∧ A B TS X M"
      by (meson Col_cases P2 col124__nos)
    hence "False"
      using P2 TS_def by blast
  }
  thus ?thesis
    using P1 ParStrict_def by auto
qed

lemma par_col_par_2:
  assumes "A ≠ P" and                         
    "Col A B P" and
    "A B Par C D"
  shows "A P Par C D"
  using assms(1) assms(2) assms(3) par_col_par par_symmetry by blast

lemma par_col2_par:
  assumes "E ≠ F" and
    "A B Par C D" and
    "Col C D E" and
    "Col C D F"
  shows "A B Par E F"
  by (metis assms(1) assms(2) assms(3) assms(4) col_transitivity_2 not_col_permutation_4 
      par_col_par par_distincts par_right_comm)

lemma par_col2_par_bis:
  assumes "E ≠ F" and
    "A B Par C D" and
    "Col E F C" and
    "Col E F D"
  shows "A B Par E F"
  by (metis assms(1) assms(2) assms(3) assms(4) col_transitivity_1 not_col_permutation_2 
      par_col2_par)

lemma par_strict_col_par_strict:
  assumes "C ≠ E" and
    "A B ParStrict C D" and
    "Col C D E"
  shows "A B ParStrict C E"
proof -
  have P1: "C E Par A B"
    using Par_def Par_perm assms(1) assms(2) assms(3) par_col_par_2 by blast
  {
    assume "C E ParStrict A B"
    hence "A B ParStrict C E"
      by (metis par_strict_symmetry)
  }
  thus ?thesis
    using Col_cases Par_def P1 assms(2) par_strict_not_col_1 by blast
qed

lemma par_strict_col2_par_strict:
  assumes "E ≠ F" and
    "A B ParStrict C D" and
    "Col C D E" and
    "Col C D F"
  shows "A B ParStrict E F"
proof -
  have "Coplanar A B E F" 
    by (metis ParStrict_def Par_strict_perm col2_cop__cop assms(2) assms(3) 
        assms(4) par_strict_neq1)
  moreover 
  {
    assume "∃ X. Col X A B ∧ Col X E F"
    then obtain X where "Col X A B" and "Col X E F"
      by blast
    hence "Col X C D" 
      by (meson assms(1) assms(3) assms(4) colx not_col_permutation_2)
    hence False 
      using ParStrict_def ‹Col X A B› assms(2) by blast
  }
  ultimately show ?thesis 
    using ParStrict_def by blast
qed

lemma line_dec:
  "(Col C1 B1 B2 ∧ Col C2 B1 B2) ∨ ¬ (Col C1 B1 B2 ∧ Col C2 B1 B2)"
  by simp

lemma par_distinct:
  assumes "A B Par C D"
  shows "A ≠ B ∧ C ≠ D"
  using assms par_neq1 par_neq2 by auto

lemma par_col4__par:
  assumes "E ≠ F" and
    "G ≠ H" and
    "A B Par C D" and
    "Col A B E" and
    "Col A B F" and
    "Col C D G" and
    "Col C D H"
  shows "E F Par G H"
proof -
  have "C D Par E F"
    using Par_cases assms(1) assms(3) assms(4) assms(5) par_col2_par by blast
  hence "E F Par C D"
    by (simp add: ‹C D Par E F› par_symmetry)
  thus ?thesis
    using assms(2) assms(6) assms(7) par_col2_par by blast
qed

lemma par_strict_col4__par_strict:
  assumes "E ≠ F" and
    "G ≠ H" and
    "A B ParStrict C D" and
    "Col A B E" and
    "Col A B F" and
    "Col C D G" and
    "Col C D H"
  shows "E F ParStrict G H"
proof -
  have "C D ParStrict E F"
    using Par_strict_cases assms(1) assms(3) assms(4) assms(5) 
      par_strict_col2_par_strict by blast
  hence "E F ParStrict C D"
    by (simp add: ‹C D ParStrict E F› par_strict_symmetry)
  thus ?thesis
    using assms(2) assms(6) assms(7) par_strict_col2_par_strict by blast
qed

lemma par_strict_one_side:
  assumes "A B ParStrict C D" and
    "Col C D P"
  shows "A B OS C P"
proof cases
  assume "C = P"
  thus ?thesis
    using assms(1) assms(2) not_col_permutation_5 one_side_reflexivity 
      par_not_col by blast
next
  assume "C ≠ P"
  thus ?thesis
    using assms(1) assms(2) l12_6 par_strict_col_par_strict by blast
qed

lemma par_strict_all_one_side:
  assumes "A B ParStrict C D"
  shows "∀ P. Col C D P ⟶ A B OS C P"
  using assms par_strict_one_side by blast

lemma inter_trivial:
  assumes "¬ Col A B X"
  shows "X Inter A X B X"
  by (metis Col_perm Inter_def assms col_trivial_1)

lemma inter_sym:
  assumes "X Inter A B C D"
  shows "X Inter C D A B"
proof -
  obtain P where P1: "Col P C D ∧ ¬ Col P A B"
    using Inter_def assms by auto
  have P2: "A ≠ B"
    using P1 col_trivial_2 by blast
  thus ?thesis
  proof cases
    assume "A = X"
    have "Col B A B"
      by (simp add: col_trivial_3)
    {
      assume P3: "Col B C D"
      have "Col P A B"
      proof -
        have "C ≠ D"
          using Inter_def assms by blast
        moreover have "Col C D P"
          using P1 not_col_permutation_2 by blast
        moreover have "Col C D A"
          using Inter_def ‹A = X› assms by auto
        moreover have "Col C D B"
          using P3 not_col_permutation_2 by blast
        ultimately show ?thesis
          using col3 by blast
      qed
      hence "False"
        by (simp add: P1)
    }
    hence "¬ Col B C D" by auto
    thus ?thesis
      using Inter_def P2 assms by (meson col_trivial_3)
  next
    assume P5: "A ≠ X"
    have P6: "Col A A B"
      using not_col_distincts by blast
    {
      assume P7: "Col A C D"
      have "Col A P X"
      proof -
        have "C ≠ D"
          using Inter_def assms by auto
        moreover have "Col C D A"
          using Col_cases P7 by blast
        moreover have "Col C D P"
          using Col_cases P1 by auto
        moreover have "Col C D X"
          using Inter_def assms by auto
        ultimately show ?thesis
          using col3 by blast
      qed
      hence "Col P A B"
        by (metis Col_perm Inter_def P5 assms col_transitivity_2)
      hence "False"
        by (simp add: P1)
    }
    hence "¬ Col A C D" by auto
    thus ?thesis
      by (meson Inter_def P2 assms col_trivial_1)
  qed
qed

lemma inter_left_comm:
  assumes "X Inter A B C D"
  shows "X Inter B A C D"
  using Col_cases Inter_def assms by auto

lemma inter_right_comm:
  assumes "X Inter A B C D"
  shows "X Inter A B D C"
  by (metis assms inter_left_comm inter_sym)

lemma inter_comm:
  assumes "X Inter A B C D"
  shows "X Inter B A D C"
  using assms inter_left_comm inter_right_comm by blast

(** In the proof given by Tarski on page 125 the distinction of cases is explicit.
This is a good example on the significance of decidability. *)

lemma l12_17:
  assumes "A ≠ B" and
    "P Midpoint A C" and
    "P Midpoint B D"
  shows "A B Par C D"
proof cases
  assume P1: "Col A B P"
  thus ?thesis
  proof cases
    assume "A = P"
    thus ?thesis
      using assms(1) assms(2) assms(3) cong_diff_2 is_midpoint_id 
        midpoint_col midpoint_cong not_par_not_col by blast
  next
    assume P2: "A ≠ P"
    thus ?thesis
    proof cases
      assume "B = P"
      thus ?thesis
        by (metis assms(1) assms(2) assms(3) midpoint_col midpoint_distinct_2 
            midpoint_distinct_3 not_par_not_col par_comm)
    next
      assume P3: "B ≠ P"
      have P4: "Col B P D"
        using assms(3) midpoint_col not_col_permutation_4 by blast
      have P5: "Col A P C"
        using assms(2) midpoint_col not_col_permutation_4 by blast
      hence P6: "Col B C P"
        using P1 P2 col_transitivity_2 not_col_permutation_3 not_col_permutation_5 by blast
      have "C ≠ D"
        using assms(1) assms(2) assms(3) l7_9 by blast
      moreover have "Col A C D"
        using P1 P3 P4 P6 col3 not_col_permutation_3 not_col_permutation_5 by blast
      moreover have "Col B C D"
        using P3 P4 P6 col_trivial_3 colx by blast
      ultimately show ?thesis
        by (simp add: Par_def assms(1))
    qed
  qed
next
  assume T1: "¬ Col A B P"
  then obtain E where T2: "Col A B E ∧ A B Perp P E"
    using l8_18_existence by blast
  have T3: "A ≠ P"
    using T1 col_trivial_3 by blast
  thus ?thesis
  proof cases
    assume T4: "A = E"
    hence T5: "Per P A B"
      using T2 l8_2 perp_per_1 by blast
    obtain B' where T6: "Bet B A B' ∧ Cong A B' B A"
      using segment_construction by blast
    obtain D' where T7: "Bet B' P D' ∧ Cong P D' B' P"
      using segment_construction by blast
    have T8: "C Midpoint D D'"
      using T6 T7 assms(2) assms(3) midpoint_def not_cong_3412 
        symmetry_preserves_midpoint by blast
    have "Col A B B'"
      using Col_cases Col_def T6 by blast
    hence T9: "Per P A B'"
      using per_col T5 assms(1) by blast
    obtain B'' where T10: "A Midpoint B B'' ∧ Cong P B P B''"
      using Per_def T5 by auto
    hence "B' = B''"
      using T6 cong_symmetry midpoint_def symmetric_point_uniqueness by blast
    hence "Cong P D P D'"
      by (metis Cong_perm Midpoint_def T10 T7 assms(3) cong_inner_transitivity)
    hence T12: "Per P C D"
      using Per_def T8 by auto
    hence T13: "C PerpAt P C C D"
      by (metis T3 assms(1) assms(2) assms(3) l7_3_2 per_perp_in sym_preserve_diff)
    have T14: "P ≠ C"
      using T3 assms(2) is_midpoint_id_2 by auto
    have T15: "C ≠ D"
      using assms(1) assms(2) assms(3) l7_9 by auto
    have T15A: "C C Perp C D ∨ P C Perp C D"
      using T12 T14 T15 per_perp by auto
    {
      assume "C C Perp C D"
      hence "A B Par C D"
        using perp_distinct by auto
    }
    {
      assume "P C Perp C D"
      have "A B Par C D"
      proof -
        have "Coplanar P A A C"
          using ncop_distincts by blast
        moreover have "Coplanar P A A D"
          using ncop_distincts by blast
        moreover have "Coplanar P A B C"
          by (simp add: assms(2) coplanar_perm_1 midpoint__coplanar)
        moreover have "Coplanar P A B D"
          using assms(3) midpoint_col ncop__ncols by blast
        moreover have "A B Perp P A"
          using T2 T4 by auto
        moreover have "C D Perp P A"
        proof -
          have "P A Perp C D"
          proof -
            have "P ≠ A"
              using T3 by auto
            moreover have "P C Perp C D"
              using T14 T15 T12 per_perp by blast
            moreover have "Col P C A"
              by (simp add: assms(2) l7_2 midpoint_col)
            ultimately show ?thesis
              using perp_col by blast
          qed
          thus ?thesis
            using Perp_perm by blast
        qed
        ultimately show ?thesis using l12_9 by blast
      qed
    }
    thus ?thesis using T15A
      using ‹C C Perp C D ⟹ A B Par C D› by blast
  next
    assume S1B: "A ≠ E"
    obtain F where S2: "Bet E P F ∧ Cong P F E P"
      using segment_construction by blast
    hence S2A: "P Midpoint E F"
      using midpoint_def not_cong_3412 by blast
    hence S3: "Col C D F"
      using T2 assms(2) assms(3) mid_preserves_col by blast
    obtain A' where S4: "Bet A E A' ∧ Cong E A' A E"
      using segment_construction by blast
    obtain C' where S5: "Bet A' P C' ∧ Cong P C' A' P"
      using segment_construction by blast
    have S6: "F Midpoint C C'"
      using S4 S5 S2A assms(2) midpoint_def not_cong_3412 
        symmetry_preserves_midpoint by blast
    have S7: "Per P E A"
      using T2 col_trivial_3 l8_16_1 by blast
    have S8: "Cong P C P C'"
    proof -
      have "Cong P C P A"
        using Cong_perm Midpoint_def assms(2) by blast
      moreover have "Cong P A P C'"
      proof -
        obtain A'' where S9: "E Midpoint A A'' ∧ Cong P A P A''"
          using Per_def S7 by blast
        have S10: "A' = A''"
          using Cong_perm Midpoint_def S4 S9 symmetric_point_uniqueness by blast
        hence "Cong P A P A'" using S9 by auto
        moreover have "Cong P A' P C'"
          using Cong_perm S5 by blast
        ultimately show ?thesis
          using cong_transitivity by blast
      qed
      ultimately show ?thesis
        using cong_transitivity by blast
    qed
    hence S9: "Per P F C"
      using S6 Per_def by blast
    hence "F PerpAt P F F C"
      by (metis S2 S2A T1 T2 S1B assms(2) cong_diff_3 l7_9 per_perp_in)
    hence "F PerpAt F P C F"
      using Perp_in_perm by blast
    hence S10: "F P Perp C F ∨ F F Perp C F"
      using l8_15_2 perp_in_col by blast
    {
      assume S11: "F P Perp C F"
      have "Coplanar P E A C"
      proof -
        have "Col P E P ∧ Col A C P"
          using assms(2) col_trivial_3 midpoint_col not_col_permutation_2 by blast
        thus ?thesis
          using Coplanar_def by blast
      qed
      moreover have "Coplanar P E A D"
      proof -
        have "Col P D B ∧ Col E A B"
          using Mid_cases T2 assms(3) midpoint_col not_col_permutation_1 by blast
        thus ?thesis
          using Coplanar_def by blast
      qed
      moreover have "Coplanar P E B C"
        by (metis S1B T2 calculation(1) col2_cop__cop col_transitivity_1 
            ncoplanar_perm_5 not_col_permutation_5)
      moreover have "Coplanar P E B D"
        by (metis S1B T2 calculation(2) col2_cop__cop col_transitivity_1 
            ncoplanar_perm_5 not_col_permutation_5)
      moreover have "P E Perp C D"
      proof -
        have "P ≠ E" 
          using T2 perp_distinct by blast
        moreover have "C ≠ D"
          using assms(1) assms(2) assms(3) sym_preserve_diff by blast
        moreover have "P F Perp C F"
          using Perp_perm S11 by blast
        hence "F P Perp C F"
          by (simp add: S11)
        moreover have "Col P F E"
          by (simp add: Col_def S2)
        moreover have "Col C F D"
          using Col_perm S3 by blast     
        ultimately show ?thesis 
          using T1 perp_col4 ‹P F Perp C F› col_trivial_3 by meson
      qed
      moreover hence "C D Perp P E" 
        using Perp_cases by blast
      ultimately have "A B Par C D"
        using T2 l12_9 by blast
    }
    {
      assume "F F Perp C F"
      hence "A B Par C D"
        using perp_distinct by blast
    }
    thus ?thesis
      using S10 ‹F P Perp C F ⟹ A B Par C D› by blast
  qed
qed

lemma l12_18_a:
  assumes "Cong A B C D" and
    "Cong B C D A" and
    "¬ Col A B C" and
    "B ≠ D" and
    "Col A P C" and
    "Col B P D"
  shows "A B Par C D"
proof -
  have "P Midpoint A C ∧ P Midpoint B D"
    using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l7_21 by blast
  thus ?thesis
    using assms(3) l12_17 not_col_distincts by blast
qed

lemma l12_18_b:
  assumes "Cong A B C D" and
    "Cong B C D A" and
    "¬ Col A B C" and
    "B ≠ D" and
    "Col A P C" and
    "Col B P D"
  shows "B C Par D A"
proof -
  have "P Midpoint A C" 
    using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l7_21_R1 by blast
  have "Cong B C D A" 
    by (simp add: assms(2))
  moreover have "Cong C D A B" 
    using Cong_cases assms(1) by auto
  moreover 
  {
    assume "Col B C D"
    hence "Col B C P" 
      using NCol_perm assms(4) assms(6) col_trivial_3 colx by blast
    hence "Col C A B" 
    proof -
      {
        assume "C = P"
        hence False 
          using ‹P Midpoint A C› assms(3) col_trivial_3 is_midpoint_id_2 by blast
      }
      moreover have "Col C P A" 
        using Col_cases assms(5) by blast
      moreover have "Col C P B" 
        using Col_cases ‹Col B C P› by blast
      ultimately show ?thesis 
        using col_transitivity_1 by blast
    qed
    hence False 
      using NCol_cases assms(3) by blast
  }
  moreover have "C ≠ A" 
    using assms(3) not_col_distincts by blast
  moreover have "Col B P D" 
    by (simp add: assms(6))
  moreover have "Col C P A" 
    using Col_cases assms(5) by blast
  ultimately show ?thesis 
    using l12_18_a by blast
qed

lemma l12_18_c:
  assumes "Cong A B C D" and
    "Cong B C D A" and
    "¬ Col A B C" and
    "B ≠ D" and
    "Col A P C" and
    "Col B P D"
  shows "B D TS A C"
proof -
  have "P Midpoint A C ∧ P Midpoint B D"
    using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) l7_21 by blast
  thus ?thesis
  proof -
    have "A C TS B D"
      by (metis Col_cases mid_two_sides ‹P Midpoint A C ∧ P Midpoint B D› assms(3))
    hence "¬ Col B D A"
      by (meson Col_cases mid_preserves_col ts__ncol ‹P Midpoint A C ∧ P Midpoint B D› l7_2)
    thus ?thesis
      by (meson mid_two_sides ‹P Midpoint A C ∧ P Midpoint B D›)
  qed
qed

lemma l12_18_d:
  assumes "Cong A B C D" and
    "Cong B C D A" and
    "¬ Col A B C" and
    "B ≠ D" and
    "Col A P C" and
    "Col B P D"
  shows "A C TS B D"
  by (metis Col_cases TS_def assms(1) assms(2) assms(3)
      assms(4) assms(5) assms(6) l12_18_c not_col_distincts not_cong_2143 not_cong_4321)

lemma l12_18:
  assumes "Cong A B C D" and
    "Cong B C D A" and
    "¬ Col A B C" and
    "B ≠ D" and
    "Col A P C" and
    "Col B P D"
  shows "A B Par C D ∧ B C Par D A ∧ B D TS A C ∧ A C TS B D"
  using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
    l12_18_a l12_18_b l12_18_c l12_18_d by auto

lemma par_two_sides_two_sides:
  assumes "A B Par C D" and
    "B D TS A C"
  shows "A C TS B D"
  by (metis Par_def TS_def assms(1) assms(2) invert_one_side invert_two_sides 
      l12_6 l9_31 not_col_permutation_4 one_side_symmetry os_ts1324__os pars__os3412)

lemma par_one_or_two_sides:
  assumes "A B ParStrict C D"
  shows "(A C TS B D ∧ B D TS A C) ∨ (A C OS B D ∧ B D OS A C)"
proof (cases)
  assume "A C TS B D"
  hence "B D TS A C" 
    by (metis Par_strict_cases assms invert_one_side invert_two_sides l12_6 
        l9_31 os_ts1324__os)
  thus ?thesis
    using ‹A C TS B D› by blast
next
  assume "¬ A C TS B D"
  hence "A C OS B D" 
    by (metis Col_perm ParStrict_def assms cop_nos__ts l9_2 ncoplanar_perm_4 
        one_side_symmetry par_strict_not_col_1 par_strict_not_col_3)
  hence "B D OS A C" 
    by (meson assms invert_one_side invert_two_sides l12_6 l9_31 one_side_symmetry 
        os_ts1324__os pars__os3412)
  thus ?thesis 
    using ‹A C OS B D› by auto
qed

lemma l12_21_b:
  assumes "A C TS B D" and
    "B A C CongA D C A"
  shows "A B Par C D"
proof -
  have P1: "¬ Col A B C"
    using TS_def assms(1) not_col_permutation_4 by blast
  hence P2: "A ≠ B"
    using col_trivial_1 by auto
  have P3: "C ≠ D"
    using assms(1) ts_distincts by blast
  then obtain D' where P4: "C Out D D' ∧ Cong C D' A B"
    using P2 segment_construction_3 by blast
  have P5: "B A C CongA D' C A"
  proof -
    have "A Out B B"
      using P2 out_trivial by auto
    moreover have "A Out C C"
      using P1 col_trivial_3 out_trivial by force
    moreover have "C Out D' D"
      by (simp add: P4 l6_6)
    moreover have "C Out A A"
      using P1 not_col_distincts out_trivial by auto
    ultimately show ?thesis
      using assms(2) l11_10 by blast
  qed
  hence P6: "Cong D' A B C"
    using Cong_perm P4 cong_pseudo_reflexivity l11_49 by blast
  have P7: "A C TS D' B"
  proof -
    have "A C TS D B"
      by (simp add: assms(1) l9_2)
    moreover have "Col C A C"
      using col_trivial_3 by auto
    ultimately show ?thesis
      using P4 l9_5 by blast
  qed
  then obtain M where P8: "Col M A C ∧ Bet D' M B"
    using TS_def by blast
  have "B ≠ D'"
    using P7 not_two_sides_id by blast
  hence "M Midpoint A C ∧ M Midpoint B D'"
    by (metis Col_cases P1 P4 P6 P8 bet_col l7_21 not_cong_3412)
  hence "A B Par C D'"
    using P2 l12_17 by blast
  thus ?thesis
    by (meson P3 P4 par_col_par l6_6 out_col)
qed

lemma l12_22_aux:
  assumes "P ≠ A" and
    "A ≠ C" and
    "Bet P A C" and
    "P A OS B D" and
    "B A P CongA D C P"
  shows "A B Par C D"
proof -
  have P1: "P ≠ C"
    using CongA_def assms(5) by blast
  obtain B' where P2: "Bet B A B' ∧ Cong A B' B A"
    using segment_construction by blast
  have P3: "P A B CongA C A B'"
    by (metis CongA_def P2 assms(2) assms(3) assms(5) cong_reverse_identity l11_14)
  have P4: "D C A CongA D C P"
    by (metis Col_def assms(2) assms(3) assms(4) bet_out_1 col124__nos l6_6 
        out2__conga out_trivial)
  have P5: "A B' Par C D"
  proof -
    have "¬ Col B P A"
      using assms(4) col123__nos not_col_permutation_2 by blast
    hence "P A TS B B'"
      by (metis P2 assms(4) bet__ts cong_reverse_identity invert_two_sides 
          not_col_permutation_3 os_distincts)
    hence "A C TS B' D"
      by (meson assms(2) assms(3) assms(4) bet_col bet_col1 col_preserves_two_sides 
          l9_2 l9_8_2)
    moreover have "B' A C CongA D C A"
    proof -
      have "B' A C CongA B A P"
        by (simp add: P3 conga_comm conga_sym)
      moreover have "B A P CongA D C A"
        using P4 assms(5) not_conga not_conga_sym by blast
      ultimately show ?thesis
        using not_conga by blast
    qed
    ultimately show ?thesis
      using l12_21_b by blast
  qed
  have "C D Par A B"
  proof -
    have "A ≠ B"
      using assms(4) os_distincts by blast
    moreover have "C D Par A B'"
      using P5 par_symmetry by blast
    moreover have "Col A B' B"
      by (simp add: Col_def P2)
    ultimately show ?thesis
      using par_col_par by blast
  qed
  thus ?thesis
    using Par_cases by blast
qed

lemma l12_22_b:
  assumes "P Out A C" and
    "P A OS B D" and
    "B A P CongA D C P"
  shows "A B Par C D"
proof cases
  assume "A = C"
  thus ?thesis
    using assms(2) assms(3) conga_comm conga_os__out not_par_not_col 
      os_distincts out_col by blast
next
  assume P1: "A ≠ C"
  {
    assume "Bet P A C"
    hence "A B Par C D"
      using P1 assms(2) assms(3) conga_diff2 l12_22_aux by blast
  }
  {
    assume P2: "Bet P C A"
    have "C D Par A B"
    proof -
      have "P C OS D B"
        using assms(1) assms(2) col_one_side one_side_symmetry 
          out_col out_diff2 by blast
      moreover have "D C P CongA B A P"
        using assms(3) not_conga_sym by blast
      thus ?thesis
        by (metis P1 P2 assms(1) calculation l12_22_aux out_distinct)
    qed
    hence "A B Par C D"
      using Par_cases by auto
  }
  thus ?thesis
    using Out_def ‹Bet P A C ⟹ A B Par C D› assms(1) by blast
qed

lemma par_strict_par:
  assumes "A B ParStrict C D"
  shows "A B Par C D"
  using Par_def assms by auto

lemma par_strict_distinct:
  assumes "A B ParStrict C D"
  shows " A ≠ B ∧ C ≠ D"
  using assms par_strict_neq1 par_strict_neq2 by auto

lemma col_par:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Col A B C"
  shows "A B Par B C"
  by (simp add: Par_def assms(1) assms(2) assms(3) col_trivial_1)

lemma acute_col_perp__out:
  assumes "Acute A B C" and
    "Col B C A'" and
    "B C Perp A A'"
  shows "B Out A' C"
proof -
  {
    assume P1: "¬ Col B C A"
    then obtain B' where P2: "B C Perp B' B ∧ B C OS A B'"
      using assms(2) l10_15 os_distincts by blast
    have P3: "¬ Col B' B C"
      using P2 col124__nos col_permutation_1 by blast
    {
      assume "Col B B' A"
      hence "A B C LtA A B C"
        using P2 acute_one_side_aux acute_sym assms(1) one_side_not_col124 by blast
      hence "False"
        by (simp add: nlta)
    }
    hence P4: "¬ Col B B' A" by auto
    have P5: "B B' ParStrict A A'"
    proof -
      have "B B' Par A A'"
      proof -
        have "Coplanar B C B A"
          using ncop_distincts by blast
        moreover have "Coplanar B C B A'"
          using ncop_distincts by blast
        moreover have "Coplanar B C B' A"
          using P2 coplanar_perm_1 os__coplanar by blast
        moreover have "Coplanar B C B' A'"
          using assms(2) ncop__ncols by auto
        moreover have "B B' Perp B C"
          using P2 Perp_perm by blast
        moreover have "A A' Perp B C"
          using Perp_perm assms(3) by blast
        ultimately show ?thesis
          using l12_9 by auto
      qed
      moreover have "Col A A' A"
        by (simp add: col_trivial_3)
      moreover have "¬ Col B B' A"
        by (simp add: P4)
      ultimately show ?thesis
        using par_not_col_strict by auto
    qed
    hence P6: "¬ Col B B' A'"
      using P5 par_strict_not_col_4 by auto
    hence "B B' OS A' C"
    proof -
      have "B B' OS A' A"
        using P5 l12_6 one_side_symmetry by blast
      moreover have "B B' OS A C"
        using P2 acute_one_side_aux acute_sym assms(1) one_side_symmetry by blast
      ultimately show ?thesis
        using one_side_transitivity by blast
    qed
    hence "B Out A' C"
      using Col_cases assms(2) col_one_side_out by blast
  }
  thus ?thesis
    using assms(2) assms(3) perp_not_col2 by blast
qed

lemma acute_col_perp__out_1:
  assumes "Acute A B C" and
    "Col B C A'" and
    "B A Perp A A'"
  shows "B Out A' C"
proof -
  obtain A0 where P1: "Bet A B A0 ∧ Cong B A0 A B"
    using segment_construction by blast
  obtain C0 where P2: "Bet C B C0 ∧ Cong B C0 C B"
    using segment_construction by blast
  have P3: "¬ Col B A A'"
    using assms(3) col_trivial_2 perp_not_col2 by blast
  have "Bet A' B C0"
  proof -
    have P4: "Col A' B C0"
      using P2 acute_distincts assms(1) assms(2) bet_col col_transitivity_2 
        not_col_permutation_4 by blast
    {
      assume P5: "B Out A' C0"
      have "B Out A A0"
      proof -
        have "Bet C B A'"
          using Bet_perm Col_def P2 P5 assms(2) between_exchange3 
            not_bet_and_out outer_transitivity_between2 by metis
        hence "A B C CongA A0 B A'"
          using P1 P3 acute_distincts assms(1) cong_diff_4 l11_14 not_col_distincts by blast
        hence "Acute A' B A0"
          using acute_conga__acute acute_sym assms(1) by blast
        moreover have "B A0 Perp A' A"
        proof -
          have "B ≠ A0"
            using P1 P3 col_trivial_1 cong_reverse_identity by blast
          moreover have "B A Perp A' A"
            using Perp_perm assms(3) by blast
          moreover have "Col B A A0"
            using P1 bet_col not_col_permutation_4 by blast
          ultimately show ?thesis
            using perp_col by blast
        qed
        ultimately show ?thesis
          using Col_cases P1 acute_col_perp__out bet_col by blast
      qed
      hence "False"
        using P1 not_bet_and_out by blast
    }
    thus ?thesis
      using l6_4_2 P4 by blast
  qed
  thus ?thesis
    by (metis P2 P3 acute_distincts assms(1) cong_diff_3 l6_2 not_col_distincts)
qed

lemma conga_inangle_per2__inangle:
  assumes "Per A B C" and
    "T InAngle A B C" and
    "P B A CongA P B C" and
    "Per B P T" and
    "Coplanar A B C P"
  shows "P InAngle A B C"
proof cases
  assume "P = T"
  thus ?thesis
    by (simp add: assms(2))
next
  assume P1: "P ≠ T"
  obtain P' where P2: "P' InAngle A B C ∧ P' B A CongA P' B C"
    using CongA_def angle_bisector assms(3) by presburger
  have P3: "Acute P' B A"
    using P2 acute_sym assms(1) conga_inangle_per__acute by blast
  have P4: "¬ Col A B C"
    using assms(1) assms(3) conga_diff2 conga_diff56 l8_9 by blast
  have P5: "Col B P P'"
  proof -
    have "¬ B Out A C"
      using Col_cases P4 out_col by blast
    moreover have "Coplanar A B P P'"
    proof -
      have T1: "¬ Col C A B"
        using Col_perm P4 by blast
      moreover have "Coplanar C A B P"
        using assms(5) ncoplanar_perm_8 by blast
      moreover have "Coplanar C A B P'"
        using P2 inangle__coplanar ncoplanar_perm_21 by blast
      ultimately show ?thesis
        using coplanar_trans_1 by blast
    qed
    moreover have "Coplanar B C P P'"
    proof -
      have "Coplanar A B C P"
        by (meson P2 bet__coplanar calculation(1) calculation(2) col_in_angle_out 
            coplanar_perm_18 coplanar_trans_1 inangle__coplanar l11_21_a l6_6 l6_7 
            not_col_permutation_4 not_col_permutation_5)
      have "Coplanar A B C P'"
        using P2 inangle__coplanar ncoplanar_perm_18 by blast
      thus ?thesis
        using P4 ‹Coplanar A B C P› coplanar_trans_1 by blast
    qed
    ultimately show ?thesis using conga2_cop2__col P2 assms(3) by blast
  qed
  have "B Out P P'"
  proof -
    have "Acute T B P'"
      using P2 acute_sym assms(1) assms(2) conga_inangle2_per__acute by blast
    moreover have "B P' Perp T P"
      by (metis P1 P5 acute_distincts assms(3) assms(4) calculation 
          col_per_perp conga_distinct l8_2 not_col_permutation_4)
    ultimately show ?thesis
      using Col_cases P5 acute_col_perp__out by blast
  qed
  thus ?thesis
    using Out_cases P2 in_angle_trans inangle_distincts out341__inangle by blast
qed

lemma perp_not_par:
  assumes "A B Perp X Y"
  shows "¬ A B Par X Y"
proof -
  obtain P where P1: "P PerpAt A B X Y"
    using Perp_def assms by blast
  {
    assume P2: "A B Par X Y"
    {
      assume P3: "A B ParStrict X Y"
      hence "False"
      proof -
        have "Col P A B"
          using Col_perm P1 perp_in_col by blast
        moreover have "Col P X Y"
          using P1 col_permutation_2 perp_in_col by blast
        ultimately show ?thesis
          using P3 par_not_col by blast
      qed
    }
    {
      assume P4: "A ≠ B ∧ X ≠ Y ∧ Col A X Y ∧ Col B X Y"
      hence "False"
      proof cases
        assume "A = Y"
        thus ?thesis
          using P4 assms not_col_permutation_1 perp_not_col by blast
      next
        assume "A ≠ Y"
        thus ?thesis
          using Col_perm P4 Perp_perm assms perp_not_col2 by blast
      qed
    }
    hence "False"
      using Par_def P2 ‹A B ParStrict X Y ⟹ False› by auto
  }
  thus ?thesis by auto
qed

lemma cong_conga_perp:
  assumes "B P TS A C" and
    "Cong A B C B" and
    "A B P CongA C B P"
  shows "A C Perp B P"
proof -
  have P1: " ¬ Col A B P"
    using TS_def assms(1) by blast
  hence P2: "B ≠ P"
    using col_trivial_2 by blast
  have P3: "A ≠ B"
    using assms(1) ts_distincts by blast
  have P4: "C ≠ B"
    using assms(1) ts_distincts by auto
  have P5: "A ≠ C"
    using assms(1) not_two_sides_id by auto
  show ?thesis
  proof cases
    assume P6: "Bet A B C"
    hence "Per P B A"
      by (meson conga_comm Tarski_neutral_dimensionless_axioms assms(3) l11_18_2)
    thus ?thesis
      using P2 P3 P5 Per_perm P6 bet_col per_perp perp_col by blast
  next
    assume P7: "¬ Bet A B C"
    obtain T where P7A: "Col T B P ∧ Bet A T C"
      using TS_def assms(1) by auto
    hence P8: "B ≠ T"
      using P7 by blast
    hence P9: "T B A CongA T B C"
      by (meson Col_cases P7A col_conga__conga conga_comm assms(3))
    hence P10: "Cong T A T C"
      using assms(2) cong2_conga_cong cong_reflexivity not_cong_2143 by blast
    hence P11: "T Midpoint A C"
      using P7A midpoint_def not_cong_2134 by blast
    have P12: "Per B T A"
      using P11 Per_def assms(2) not_cong_2143 by blast
    thus ?thesis
    proof -
      have "A C Perp B T"
        by (metis P11 P12 P5 P8 col_per_perp midpoint_col midpoint_distinct_1)
      moreover have "B ≠ T"
        by (simp add: P8)
      moreover have "T ≠ A"
        using P1 P7A by blast
      moreover have "C ≠ T"
        using P10 P5 cong_identity by blast
      moreover have "C ≠ A"
        using P5 by auto
      moreover have "Col T A C"
        by (meson P7A bet_col not_col_permutation_4)
      ultimately show ?thesis
        using P2 P7A not_col_permutation_4 perp_col1 by blast
    qed
  qed
qed

lemma perp_inter_exists:
  assumes "A B Perp C D"
  shows "∃ P. Col A B P ∧ Col C D P"
proof -
  obtain P where "P PerpAt A B C D"
    using Perp_def assms by auto
  thus ?thesis
    using perp_in_col by blast
qed

lemma perp_inter_perp_in:
  assumes "A B Perp C D"
  shows "∃ P. Col A B P ∧ Col C D P ∧ P PerpAt A B C D"
  by (meson Perp_def perp_in_col Tarski_neutral_dimensionless_axioms assms)

lemma cop_npars__inter_exists:
  assumes "Coplanar A1 B1 A2 B2" and
    "¬ A1 B1 ParStrict A2 B2"
  shows "∃ X. Col X A1 B1 ∧ Col X A2 B2" 
  using ParStrict_def assms(1) assms(2) by blast

lemma cop_npar__inter_exists:
  assumes "Coplanar A1 B1 A2 B2" and
    "¬ A1 B1 Par A2 B2"
  shows "∃ X. Col X A1 B1 ∧ Col X A2 B2" 
proof -
  have "¬ A1 A2 ParStrict A2 B2" 
    using not_par_strict_id par_strict_left_comm by blast
  thus ?thesis 
    using assms(1) assms(2) cop_npars__inter_exists par_strict_par by blast
qed

lemma cop_npar__inter:
  assumes "A1 ≠ B1" and
    "A2 ≠ B2" and
    "Coplanar A1 B1 A2 B2" and
    "¬ A1 B1 Par A2 B2"
  shows "∃ X. X Inter A1 B1 A2 B2" 
proof -
  obtain X where "Col X A1 B1" and "Col X A2 B2"
    using cop_npar__inter_exists assms(3) assms(4) by blast
  have "∃ P. Col P A2 B2 ∧ ¬ Col P A1 B1" 
  proof (cases "Col A2 A1 B1")
    case True
    have "Col B2 A2 B2" 
      by (simp add: col_trivial_3)
    moreover
    have "¬ Col B2 A1 B1" 
      using Par_cases True assms(1) assms(2) assms(4) calculation col_par 
        not_col_permutation_3 par_col2_par_bis by metis
    ultimately
    show ?thesis 
      by blast
  next
    case False
    thus ?thesis 
      using col_trivial_1 by blast
  qed
  moreover
  have "Col A1 B1 X ∧ Col A2 B2 X" 
    using Col_cases ‹Col X A1 B1› ‹Col X A2 B2› by blast
  ultimately
  show ?thesis 
    using assms(2) Inter_def by auto
qed

lemma inter__npar: 
  assumes "X Inter A1 A2 B1 B2"
  shows "¬ A1 A2 Par B1 B2" 
proof -
  {
    assume "A1 A2 ParStrict B1 B2"
    hence False 
      by (meson Inter_def assms not_strict_par par_strict_not_col_1 par_strict_par)
  }
  moreover
  {
    assume "A1 ≠ A2 ∧ B1 ≠ B2 ∧ Col A1 B1 B2 ∧ Col A2 B1 B2"
    hence "A1 A2 Par B1 B2" 
      using Par_def by auto
    hence False 
      by (meson Inter_def assms col_not_col_not_par not_col_permutation_2)
  }
  ultimately
  show ?thesis 
    using Par_def by presburger
qed

lemma cong_identity_inv:
  assumes "A ≠ B"  
  shows "¬ Cong A B C C"
  using assms cong_diff by blast

lemma midpoint_midpoint_col:
  assumes "A ≠ B" and
    "M Midpoint A A'" and
    "M Midpoint B B'" and
    "Col A B B'"
  shows "A' ≠ B' ∧ Col A A' B' ∧ Col B A' B'"
proof -
  have f1: "∀p. p Midpoint p p"
    by (metis l7_3_2)
  hence f2: "B = B' ∨ Col B' A M"
    by (metis (no_types) Col_perm assms(3) assms(4) col_transitivity_2 
        mid_two_sides not_two_sides_id)
  have f3: "∀p. (M = A ∨ Col A p A') ∨ ¬ Col M A p"
    using f1 by (metis (no_types) Col_perm assms(2) col_transitivity_2 
        mid_two_sides not_two_sides_id)
  hence "(M = A ∨ B = B') ∨ Col B A' B'"
    using f1 by (metis Col_perm assms(3) assms(4) col_transitivity_2 
        mid_two_sides not_two_sides_id)
  thus ?thesis
    using f3 f2 f1 by (metis (full_types) Col_perm Mid_perm assms(1) assms(2) 
        assms(3) assms(4) col_transitivity_2 l7_17_bis mid_two_sides not_two_sides_id 
        symmetric_point_uniqueness)
qed

lemma midpoint_par_strict:
  assumes "¬ Col A B B'" and
    "M Midpoint A A'" and
    "M Midpoint B B'" 
  shows "A B ParStrict A' B'"
  by (metis assms(1) assms(2) assms(3) col_trivial_1 col_trivial_2 l12_17 par_not_col_strict) 

lemma bet3_cong3_bet:
  assumes "A ≠ B" and
    "A ≠ C" and
    "A ≠ D" and
    "Bet D A C" and
    "Bet A C B" and
    "Bet D C D'" and
    "Cong A B C D" and
    "Cong A D B C" and
    "Cong D C C D'"
  shows "Bet C B D'"
proof -
  have "Bet D C B" 
    using assms(2) assms(4) assms(5) outer_transitivity_between2 by blast
  have "B ≠ C" 
    using assms(3) assms(8) cong_identity_inv by auto
  have "D' ≠ C" 
    using assms(2) assms(4) assms(9) bet_neq23__neq cong_diff by blast
  have "D ≠ C" 
    using ‹D' ≠ C› assms(9) cong_reverse_identity by blast
  have "C Out B D'" 
    using Out_def ‹B ≠ C› ‹Bet D C B› ‹D ≠ C› ‹D' ≠ C› assms(6) l5_2 by auto
  hence "D Out B D'" 
    using ‹Bet D C B› out_bet__out by blast
  have "D A Le D C" 
    using assms(4) cong_reflexivity l5_5_2 by blast
  hence "D B Le D D'" 
    by (meson ‹Bet D C B› assms(6) assms(8) assms(9) bet2_le2__le 
        cong_commutativity l5_6 le_reflexivity)
  thus ?thesis 
    by (metis l6_13_1 ‹Bet D C B› ‹D Out B D'› between_exchange3)
qed

lemma bet_double_bet:
  assumes "B' Midpoint A B" and 
    "C' Midpoint A C" and
    "Bet A B' C'" 
  shows "Bet A B C" 
proof -
  have "A B' Le A C'"
    by (simp add: assms(3) bet__le1213)
  hence "B' B Le C' C"
    using assms(1) assms(2) l5_6 midpoint_cong by blast 
  have "A B Le A C"
    using ‹A B' Le A C'› assms(1) assms(2) le_mid2__le13 by auto
  thus ?thesis 
  proof cases
    assume "A = B'"
    thus ?thesis
      using assms(1) between_trivial2 is_midpoint_id by blast 
  next
    assume "A ≠ B'"
    thus ?thesis
      by (metis Midpoint_def ‹A B Le A C› assms(1) assms(2) assms(3) bet_out 
          l6_13_1 l6_6 l6_7 out_diff1) 
  qed
qed

lemma bet_half_bet:
  assumes "Bet A B C" and
    "B' Midpoint A B" and
    "C' Midpoint A C" 
  shows "Bet A B' C'"
proof cases
  assume "A = B"
  thus ?thesis 
    using assms(2) l8_20_2 not_bet_distincts by blast
next
  assume "A ≠ B"
  thus ?thesis 
    by (metis midpoint_bet assms(1) assms(2) assms(3) bet_double_bet 
        between_equality_2 between_exchange4 l5_3 l7_17)
qed

lemma midpoint_preserves_bet:
  assumes "B' Midpoint A B" and 
    "C' Midpoint A C"
  shows "Bet A B C ⟷ Bet A B' C'"
  using assms(1) assms(2) bet_double_bet bet_half_bet by blast 

lemma symmetry_preseves_bet1:
  assumes "M Midpoint A A'" and 
    "M Midpoint B B'" and 
    "Bet M A B"
  shows "Bet M A' B'"
  using assms(1) assms(2) assms(3) l7_15 l7_3_2 by blast

lemma symmetry_preseves_bet2:
  assumes "M Midpoint A A'" and 
    "M Midpoint B B'" and
    "Bet M A' B'"
  shows "Bet M A B"
  using Mid_cases assms(1) assms(2) assms(3) symmetry_preseves_bet1 by blast 

lemma symmetry_preserves_bet:
  assumes "M Midpoint A A'" and 
    "M Midpoint B B'" 
  shows "Bet M A' B' ⟷ Bet M A B"
  using assms(1) assms(2) symmetry_preseves_bet1 symmetry_preseves_bet2 by blast 

lemma bet_cong_bet:
  assumes "A ≠ B" and
    "Bet A B C" and
    "Bet A B D" and
    "Cong A C B D"
  shows "Bet B C D"
  by (meson assms(1) assms(2) assms(3) assms(4) bet_col between_equality 
      col_cong_bet col_transitivity_1) 

lemma col_cong_mid :
  assumes "A B Par A' B'" and 
    "¬  A B ParStrict A' B'" and 
    "Cong A B A' B'"
  shows "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
(M Midpoint A B' ∧ M Midpoint B A'))" 
proof cases
  assume "A = A'"
  thus ?thesis
    by (metis Mid_perm Par_def midpoint_existence assms(1) assms(2) assms(3) l7_20 l7_3_2) 
next
  assume "A ≠ A'"
  thus ?thesis 
  proof cases
    assume "B = B'"
    thus ?thesis
      by (metis ‹A ≠ A'› assms(1) assms(3) bet_cong_eq between_trivial 
          l7_3_2 midpoint_def not_cong_1243 not_cong_3412 par_comm par_id_1 third_point) 
  next
    assume "B ≠ B'"
    thus ?thesis 
    proof cases
      assume "A = B'"
      thus ?thesis
        by (metis Cong_perm Mid_perm Midpoint_def Par_perm assms(1) assms(3) 
            between_cong_2 between_trivial l7_3_2 midpoint_existence par_id third_point) 
    next
      assume "A ≠ B'"
      thus ?thesis 
      proof cases
        assume "A' = B"
        thus ?thesis
          using Par_def ‹A ≠ B'› assms(1) assms(2) assms(3) cong_col_mid l7_3_2 by blast 
      next
        assume "A' ≠ B"
        have "Col A B A'"
          using Par_def assms(1) assms(2) col2__eq col_permutation_5 by blast 
        have "Col A B B'"
          using assms(1) assms(2) l8_18_existence not_strict_par2 par_not_col_strict by blast
        {
          assume "Bet A B B'" 
          {
            assume "Bet B A' B'"
            obtain M where "M Midpoint A' B"
              using midpoint_existence by blast
            hence "Cong A' M B M"
              using cong_right_commutativity midpoint_cong by blast 
            have "Bet B M B'"
              using Mid_cases ‹Bet B A' B'› ‹M Midpoint A' B› between_exchange4 
                midpoint_bet by blast 
            hence "Bet A M B'"
              using ‹Bet A B B'› between_exchange2 by blast 
            have "Cong A M B' M" using l2_11
              by (meson Midpoint_def ‹Bet A B B'› ‹Bet B A' B'› ‹M Midpoint A' B› 
                  assms(3) between_inner_transitivity between_symmetry not_cong_3412 
                  not_cong_3421)  
            hence "M Midpoint A B'"
              using ‹Bet A M B'› midpoint_def not_cong_1243 by blast 
            hence "M Midpoint A B' ∧ M Midpoint B A'"
              using Mid_perm ‹M Midpoint A' B› by blast 
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))" by auto
          }
          {
            assume "Bet A' B' B"
            obtain M where P2: "M Midpoint B B'"
              using midpoint_existence by blast
            hence "Bet A' M B"
              using ‹Bet A' B' B› between_exchange4 between_symmetry midpoint_bet by blast 
            hence "Bet M B A"
              using ‹B ≠ B'› ‹Bet A B B'› ‹Bet A' B' B› between_inner_transitivity 
                between_symmetry outer_transitivity_between by blast 
            hence "Bet A' M A"
              using ‹B ≠ B'› ‹Bet A B B'› ‹Bet A' B' B› ‹Bet A' M B› between_symmetry 
                outer_transitivity_between by blast 
            have "Cong B M B' M"
              using Cong_perm P2 midpoint_cong by blast 
            hence "Cong A M A' M" 
              using l2_11 by (meson P2 ‹Bet A' B' B› ‹Bet M B A› assms(3) 
                  between_exchange3 between_symmetry midpoint_bet) 
            hence "M Midpoint A A'"
              using ‹Bet A' M A› between_symmetry midpoint_def not_cong_1243 by blast 
            hence "M Midpoint A A' ∧ M Midpoint B B'"
              using ‹M Midpoint B B'› by blast 
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))" by auto
          }
          {
            assume "Bet B' B A'"
            hence "Bet B A' A"
              by (metis ‹B ≠ B'› ‹Bet A B B'› assms(3) bet_cong_eq between_symmetry l5_2) 
            obtain M where "M Midpoint A' B"
              using midpoint_existence by blast 
            hence "Bet A' M B"
              by (simp add: midpoint_bet) 
            have "Cong A' M B M"
              using Cong_perm ‹M Midpoint A' B› midpoint_cong by blast 
            have "M Midpoint A B'" 
            proof -
              have "Bet B M A"
                using Mid_cases ‹Bet B A' A› ‹M Midpoint A' B› between_exchange4 
                  midpoint_bet by blast 
              hence "Bet B' B M"
                using ‹Bet A B B'› between_inner_transitivity between_symmetry by blast 
              have "Bet M A' A"
                using ‹Bet A' M B› ‹Bet B A' A› between_inner_transitivity 
                  between_symmetry by blast 
              have "Bet B' M A'"
                using ‹Bet A' M B› ‹Bet B' B A'› bet3__bet between_trivial by blast 
              have "Cong A M B' M"
                by (meson ‹Bet B A' A› ‹Bet B' B A'› ‹Bet B' B M› ‹Bet M A' A› 
                    ‹Col A B B'› ‹Cong A' M B M› assms(3) between_symmetry 
                    col_bet2_cong1 l2_11_b) 
              thus ?thesis
                by (metis Bet_cases midpoint_distinct_1 ‹A' ≠ B› ‹Bet B' M A'› 
                    ‹Bet M A' A› ‹M Midpoint A' B› midpoint_def not_cong_1243 
                    outer_transitivity_between) 
            qed
            hence "M Midpoint A B' ∧ M Midpoint B A'"
              by (simp add: ‹M Midpoint A B'› Mid_perm ‹M Midpoint A' B›) 
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))" by auto
          }
          have "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
  (M Midpoint A B' ∧ M Midpoint B A'))"
            using Par_def ‹Bet A' B' B ⟹ 
    ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› 
              ‹Bet B A' B' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› 
              ‹Bet B' B A' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› 
              assms(1) assms(2) between_symmetry third_point by blast 
        }
        {
          assume "Bet B B' A" 
          have P3: "Col A A' B'"
            using Par_def assms(1) assms(2) by blast 
          {
            assume "Bet A A' B'"
            hence "A = A' ∧ B = B'"
              using ‹Bet B B' A› assms(3) bet_cong_eq between_symmetry cong_symmetry by blast 
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))"
              using ‹B ≠ B'› by linarith 
          }
          {
            assume "Bet A' B' A"
            hence "Bet B' B A'"
              by (metis Bet_perm Cong_perm ‹A ≠ B'› ‹Bet B B' A› assms(3) 
                  bet_cong_eq between_inner_transitivity l5_1) 
            obtain M where "M Midpoint B B'"
              using midpoint_existence by blast
            hence "Bet B M B'"
              using midpoint_bet by blast
            have "M Midpoint A A' ∧ M Midpoint B B'" 
            proof -
              have "Bet A M A'"
                by (meson Bet_perm ‹Bet A' B' A› ‹Bet B M B'› ‹Bet B' B A'› between_exchange4) 
              moreover
              have "Cong M B M B'"
                using Midpoint_def ‹M Midpoint B B'› not_cong_2134 by blast 
              hence "Cong A M A' M"
                using Bet_cases between_inner_transitivity ‹Bet B B' A› ‹Bet B M B'›
                  assms(3) between_exchange2 calculation l4_3 by meson
              ultimately
              show ?thesis
                using Cong_cases ‹M Midpoint B B'› midpoint_def by blast 
            qed
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))" by auto
          }
          {
            assume "Bet B' A A'"
            obtain M where "M Midpoint A B'"
              using midpoint_existence by blast
            hence "Bet A M B'"
              by (simp add: midpoint_bet)
            have "Cong A M B' M"
              using Cong_perm ‹M Midpoint A B'› midpoint_cong by blast
            have "M Midpoint A B' ∧ M Midpoint B A'"
            proof -
              have "Bet A' A M"
                using ‹Bet A M B'› ‹Bet B' A A'› between_inner_transitivity 
                  between_symmetry by blast 
              have "Bet B M A'"
                using ‹A ≠ B'› ‹Bet A M B'› ‹Bet B B' A› ‹Bet B' A A'› 
                  bet3__bet outer_transitivity_between outer_transitivity_between2 by blast 
              moreover
              have "Cong B M A' M" 
              proof -
                let ?C  = "A"
                let ?C' = "B'"
                have "Bet B M ?C" 
                  by (meson ‹B ≠ B'› ‹Bet A M B'› ‹Bet B B' A› bet3__bet l5_1)
                moreover have "Bet A' M ?C'" 
                  using Bet_cases ‹Bet A M B'› ‹Bet A' A M› ‹Bet B' A A'› outer_transitivity_between2 by blast
                moreover have "Cong B ?C A' ?C'" 
                  using assms(3) not_cong_2134 by blast
                moreover have "Cong M ?C M ?C'" 
                  using ‹Cong A M B' M› not_cong_2143 by blast
                ultimately show ?thesis 
                  using l4_3 by force
              qed
              ultimately
              show ?thesis
                by (simp add: ‹M Midpoint A B'› cong_right_commutativity midpoint_def) 
            qed
            have "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))"
              using ‹M Midpoint A B' ∧ M Midpoint B A'› by blast 
          }
          hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
  (M Midpoint A B' ∧ M Midpoint B A'))"
            using Col_def P3 ‹Bet A A' B' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› 
              ‹Bet A' B' A ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› by blast 
        }
        {
          assume "Bet B' A B" 
          {
            assume "Bet A B A'" 
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))"
              using ‹A' ≠ B› ‹Bet B' A B› assms(1) assms(3) bet_cong_eq 
                not_cong_1243 outer_transitivity_between2 par_distincts by blast 
          }
          {
            assume "Bet B A' A" 
            obtain M where "M Midpoint A A'"
              using midpoint_existence by blast
            hence "Bet A M A'"
              by (simp add: midpoint_bet)
            have "Cong A M A' M"
              using Cong_perm ‹M Midpoint A A'› midpoint_cong by blast 
            have "M Midpoint B B'" 
            proof -
              have "Bet B M B'"
                by (meson Bet_perm ‹Bet A M A'› ‹Bet B A' A› ‹Bet B' A B› between_exchange4) 
              moreover
              have "Cong B M B' M"
              proof -
                let ?C  = "A"
                let ?C' = "A'"
                have "Bet B M ?C" 
                  using Bet_cases ‹Bet A M A'› ‹Bet B A' A› between_exchange2 by blast
                moreover have "Bet B' M ?C'" 
                  by (metis ‹Bet A M A'› ‹Bet B' A B› ‹M Midpoint A A'› 
                      between_inner_transitivity between_symmetry calculation 
                      midpoint_distinct_3 outer_transitivity_between2)
                moreover have "Cong B ?C B' ?C'" 
                  using assms(3) not_cong_2143 by blast
                moreover have "Cong M ?C M ?C'" 
                  using ‹Cong A M A' M› cong_commutativity by blast
                ultimately show ?thesis 
                  using l4_3 by blast
              qed
              ultimately
              show ?thesis
                using midpoint_def not_cong_1243 by blast
            qed
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))"
              using ‹M Midpoint A A'› by blast 
          }
          {
            assume "Bet A' A B" 
            have "Bet A B' A' ∨ Bet A A' B'"
              by (metis ‹Bet A' A B› ‹Bet B' A B› assms(1) between_symmetry l5_2 par_distincts)
            { 
              assume "Bet A B' A'"
              obtain M where "M Midpoint A B'"
                using midpoint_existence by presburger
              have "M Midpoint B A'" 
              proof -
                have "Bet B M A'" 
                  using ‹A ≠ B'› ‹Bet A B' A'› ‹Bet B' A B› ‹M Midpoint A B'› 
                    bet3__bet between_symmetry midpoint_bet 
                    outer_transitivity_between by metis
                moreover
                have "Cong A M B' M"
                  using Midpoint_def ‹M Midpoint A B'› cong_right_commutativity by blast 
                hence "Cong B M A' M"
                  by (meson ‹A ≠ B'› ‹Bet A B' A'› ‹Bet B' A B› assms(3) cong_4312 
                      cong_reflexivity cong_symmetry five_segment) 
                ultimately
                show ?thesis
                  using midpoint_def not_cong_1243 by blast 
              qed
              hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
      (M Midpoint A B' ∧ M Midpoint B A'))"
                using ‹M Midpoint A B'› by blast 
            }
            { 
              assume "Bet A A' B'"
              obtain M where "M Midpoint A A'"
                using midpoint_existence by blast
              have "M Midpoint B B'" 
              proof -
                have "Bet B M B'"
                proof -
                  have "Bet B A B'" 
                    using Bet_cases ‹Bet B' A B› by blast
                  moreover have "Bet A M B'" 
                    using Midpoint_def ‹Bet A A' B'› ‹M Midpoint A A'› between_exchange4 
                    by blast
                  ultimately show ?thesis 
                    using between_exchange2 by blast
                qed
                moreover
                have "Cong A M A' M"
                  using Cong_perm ‹M Midpoint A A'› midpoint_cong by blast 
                hence "Cong B M B' M"
                  using Cong_cases ‹A ≠ A'› ‹Bet A A' B'› ‹Bet A' A B› assms(3) 
                    cong_reflexivity five_segment by blast 
                ultimately
                show ?thesis
                  using midpoint_def not_cong_1243 by blast
              qed
              hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
      (M Midpoint A B' ∧ M Midpoint B A'))"
                using ‹M Midpoint A A'› by blast 
            }
            hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
    (M Midpoint A B' ∧ M Midpoint B A'))"
              using ‹Bet A B' A' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
      M Midpoint A B' ∧ M Midpoint B A'› 
                ‹Bet A B' A' ∨ Bet A A' B'› by blast 
          }
          hence "∃ M. ((M Midpoint A A' ∧ M Midpoint B B') ∨
  (M Midpoint A B' ∧ M Midpoint B A'))"
            using Col_def ‹Bet A B A' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› 
              ‹Bet B A' A ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
    M Midpoint A B' ∧ M Midpoint B A'› ‹Col A B A'› by blast 
        }
        thus ?thesis
          using Col_def ‹Bet A B B' ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
  M Midpoint A B' ∧ M Midpoint B A'› 
            ‹Bet B B' A ⟹ ∃M. M Midpoint A A' ∧ M Midpoint B B' ∨ 
  M Midpoint A B' ∧ M Midpoint B A'› ‹Col A B B'› by blast 
      qed
    qed
  qed
qed

lemma mid_par_cong1:
  assumes "A ≠ B" and
    "M Midpoint A A'" and 
    "M Midpoint B B'" 
  shows "Cong A B A' B' ∧ A B Par A' B'"
  by (metis assms(1) assms(2) assms(3) cong_4321 cong_right_commutativity l12_17 
      l7_13_R1 midpoint_distinct_2)

lemma mid_par_cong2:
  assumes "A ≠ B'" and 
    "M Midpoint A A'" and
    "M Midpoint B B'" 
  shows "Cong A B' A' B ∧ A B' Par A' B"
  using assms(1) assms(2) assms(3) l7_2 mid_par_cong1 by blast

lemma mid_par_cong:
  assumes "A ≠ B" and 
    "A ≠ B'" and
    "M Midpoint A A'" and
    "M Midpoint B B'" 
  shows "Cong A B A' B' ∧ Cong A B' A' B ∧ A B Par A' B' ∧ A B' Par A' B"
  using assms(1) assms(2) assms(3) assms(4) mid_par_cong1 mid_par_cong2 by auto

lemma Parallelogram_strict_Parallelogram:
  assumes "ParallelogramStrict A B C D" 
  shows "Parallelogram A B C D"
  by (simp add: Parallelogram_def assms) 

lemma plgf_permut:
  assumes "ParallelogramFlat A B C D"
  shows "ParallelogramFlat B C D A" 
proof cases
  assume "A = B"
  thus ?thesis 
    by (metis ParallelogramFlat_def assms cong_diff_3 not_col_distincts)
next
  assume "A ≠ B"
  thus ?thesis
  proof -
    have f1: "A ≠ B"
      using ‹A ≠ B› by force
    have f2: "∀p pa pb pc. ¬ Cong p pa pb pc ∨ Cong pc pb pa p"
      using not_cong_4321 by blast
    have "ParallelogramFlat A B C D"
      using assms by force
    then show ?thesis
      using f2 f1 by (smt (z3) NCol_cases ParallelogramFlat_def col_transitivity_2 not_cong_3412)
  qed 
qed

lemma plgf_sym:
  assumes "ParallelogramFlat A B C D"
  shows "ParallelogramFlat C D A B"
  by (simp add: assms plgf_permut) 

lemma plgf_irreflexive:
  shows "¬ ParallelogramFlat A B A B"
  by (simp add: ParallelogramFlat_def) 

lemma plgs_irreflexive:
  shows "¬ ParallelogramStrict A B A B"   
proof -
  {
    assume "ParallelogramStrict A B A B"
    hence "A A TS B B ∧ A B Par A B ∧ Cong A B A B" 
      using ParallelogramStrict_def by auto
    hence "False"
      using not_two_sides_id by blast 
  }
  thus ?thesis by blast
qed

lemma plg_irreflexive:
  shows "¬ Parallelogram A B A B" 
proof -
  {
    assume "Parallelogram A B A B"
    hence "ParallelogramStrict A B A B ∨ ParallelogramFlat A B A B"
      by (simp add: Parallelogram_def) 
    hence "False"
      using plgf_irreflexive plgs_irreflexive by blast 
  }
  thus ?thesis by auto
qed

lemma plgf_mid:
  assumes "ParallelogramFlat A B C D"
  shows "∃ M. M Midpoint A C ∧ M Midpoint B D"
proof -
  have P1: "Col A B C ∧ Col A B D ∧ Cong A B C D ∧ Cong A D C B ∧ (A ≠ C ∨ B ≠ D)"
    using ParallelogramFlat_def assms by blast  
  have "∃ M. M Midpoint A C ∧ M Midpoint B D"
  proof cases
    assume "A = B"
    obtain M where "M Midpoint A C"
      using midpoint_existence by blast
    moreover
    have "M Midpoint B D" 
    proof -
      have "Bet A M C"
        by (simp add: calculation midpoint_bet) 
      hence "Bet B M D"
        using P1 ‹A = B› cong_reverse_identity by blast 
      moreover
      have "Cong B M D M"
        using P1 ‹A = B› ‹M Midpoint A C› cong_reverse_identity l7_13 l7_3_2 
          not_cong_4321 by blast 
      ultimately
      show ?thesis
        using Cong_perm midpoint_def by blast 
    qed
    ultimately
    show ?thesis by auto 
  next
    assume "A ≠ B"
    hence "C ≠ D"
      using P1 cong_identity by blast
    hence "A B Par C D"
      using P1 ‹A ≠ B› par_col2_par par_reflexivity by blast 
    have "¬ A B ParStrict C D"
      using P1 par_strict_not_col_1 by blast
    then obtain M where P2: "M Midpoint A C ∧ M Midpoint B D  ∨ 
  M Midpoint A D ∧ M Midpoint B C"
      using P1 ‹A B Par C D› col_cong_mid by blast
    {
      assume "M Midpoint A D" and "M Midpoint B C" and "B ≠ C"
      have "Col A B M" 
      proof -
        have "A ≠ D" 
          using P1 ‹B ≠ C› cong_reverse_identity by blast
        have "Col A D B" 
          using P1 col_permutation_5 by blast
        moreover have "Col A D M" 
          by (metis Col_def Midpoint_def P2 between_equality_2 calculation 
              col2__eq not_bet_distincts)
        ultimately show ?thesis 
          using ‹A ≠ D› col_transitivity_1 by blast
      qed
      hence False
        by (metis (full_types) Cong_perm Mid_cases P1 ‹A ≠ B› ‹Col A B M› 
            ‹M Midpoint A D› ‹M Midpoint B C› 
            cong_col_mid cong_cong_half_1 l7_9 not_col_permutation_2)
    }
    moreover
    {
      assume "M Midpoint A D" and "M Midpoint B C" and "B = C"
      hence  "∃ M. M Midpoint A C ∧ M Midpoint B D" 
        using P1 P2 cong_identity l7_3 by blast 
    }
    ultimately show ?thesis 
      using P2 by auto
  qed
  thus ?thesis 
    by simp
qed

lemma mid_plgs:
  assumes "¬ Col A B C" and
    "M Midpoint A C" and
    "M Midpoint B D" 
  shows "ParallelogramStrict A B C D" 
proof -
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto
  hence "M ≠ A"
    using assms(2) is_midpoint_id by auto 
  have "B ≠ D"
    using assms(1) assms(2) assms(3) bet_col l8_20_2 midpoint_bet by blast
  hence "M ≠ D"
    using assms(3) is_midpoint_id_2 by auto 
  have "Bet A M C"
    by (simp add: assms(2) midpoint_bet)
  have "Bet B M D"
    by (simp add: assms(3) midpoint_bet) 
  thus ?thesis 
  proof -
    have "A C TS B D"
      using NCol_perm assms(1) assms(2) assms(3) mid_two_sides by blast 
    moreover
    have "A B Par C D"
      using assms(1) assms(2) assms(3) mid_par_cong1 not_col_distincts by blast 
    moreover
    have "Cong A B C D"
      using assms(1) assms(2) assms(3) mid_par_cong1 not_col_distincts by blast 
    ultimately
    show ?thesis
      using ParallelogramStrict_def by blast 
  qed
qed

lemma mid_plgf_aux:
  assumes "A ≠ C" and
    "Col A B C" and
    "M Midpoint A C" and 
    "M Midpoint B D" 
  shows "ParallelogramFlat A B C D"
proof cases
  assume "B = D"
  thus ?thesis 
    by (metis ParallelogramFlat_def Cong_perm col_trivial_2 midpoint_cong 
        assms(1) assms(2) assms(3) assms(4) l8_20_2)
next
  assume "B ≠ D"
  thus ?thesis
  proof -
    have "M Midpoint C A"
      by (simp add: assms(3) l7_2)
    then have "Cong A D C B"
      by (simp add: assms(4) l7_13)
    then show ?thesis
      by (metis Col_cases ParallelogramFlat_def ‹B ≠ D› assms(2,3,4) col_trivial_1 l7_13 l7_2 midpoint_midpoint_col)
  qed 
qed

lemma mid_plgf_1:
  assumes "A ≠ C"
    (*"B ≠ D" and*)
    "Col A B C" and
    "M Midpoint A C" and 
    "M Midpoint B D"
  shows "ParallelogramFlat A B C D"
  using assms(1) assms(2) assms(3) assms(4) mid_plgf_aux by auto 

lemma mid_plgf_2:
  assumes "B ≠ D" 
    "Col A B C" and
    "M Midpoint A C" and 
    "M Midpoint B D"
  shows "ParallelogramFlat A B C D"
  by (metis Col_def assms(1) assms(2) assms(3) assms(4) l7_3 mid_plgf_aux 
      midpoint_bet plgf_permut) 

lemma mid_plgf:
  assumes "A ≠ C ∨ B ≠ D" 
    "Col A B C" and
    "M Midpoint A C" and 
    "M Midpoint B D"
  shows "ParallelogramFlat A B C D"
  using assms(1) assms(2) assms(3) assms(4) mid_plgf_2 mid_plgf_aux by blast 

lemma mid_plg:
  assumes "A ≠ C ∨ B ≠ D" and
    "M Midpoint A C" and 
    "M Midpoint B D" 
  shows "Parallelogram A B C D"
  using Parallelogram_def assms(1) assms(2) assms(3) mid_plgf_2 mid_plgf_aux mid_plgs by blast 

lemma midpoint_cong_uniqueness:
  assumes "Col A B C" and
    "M Midpoint A B" and
    "M Midpoint C D" and
    "Cong A B C D" 
  shows "A = C ∧ B = D ∨ A = D ∧ B = C"
proof cases
  assume "A = B"
  thus ?thesis 
    using assms(2) assms(3) assms(4) cong_reverse_identity l7_3 by blast
next
  assume "A ≠ B"
  thus ?thesis 
  proof cases
    assume "A = C"
    thus ?thesis 
      using assms(2) assms(3) symmetric_point_uniqueness by blast
  next
    assume "A ≠ C"
    have "M Midpoint A C" 
    proof -
      have "Cong A M C M" 
        using assms(2) assms(3) assms(4) cong_cong_half_1 by blast
      moreover have "Col A M C" 
        by (meson l6_16_1 midpoint_col ‹A ≠ B› assms(1) assms(2) col_permutation_2) 
      hence "Bet A M C" 
        by (metis col_trivial_2 cong_right_commutativity ‹A ≠ C› bet_cong_eq 
            calculation col_cong2_bet2 not_bet_distincts third_point)
      ultimately show ?thesis 
        using Cong_cases midpoint_def by blast
    qed
    thus ?thesis 
      by (metis assms(2) assms(3) l7_9_bis)
  qed
qed

lemma plgf_not_comm1:
  assumes "A ≠ B" and
    "ParallelogramFlat A B C D" 
  shows  "¬ ParallelogramFlat A B D C" 
proof -
  obtain M where P1: "M Midpoint A C ∧ M Midpoint B D"
    using assms(2) plgf_mid by blast
  thus ?thesis
    by (metis ParallelogramFlat_def assms(1) l7_2 midpoint_cong_uniqueness 
        midpoint_midpoint_col)
qed

lemma plgf_not_comm2:
  assumes "A ≠ B" and
    "ParallelogramFlat A B C D" 
  shows "¬ ParallelogramFlat B A C D" 
proof -
  have "ParallelogramFlat C D A B"
    by (metis assms(2) plgf_sym)
  thus ?thesis
    by (metis assms(1) plgf_not_comm1 plgf_sym) 
qed

lemma plgf_not_comm:
  assumes "A ≠ B" and
    "ParallelogramFlat A B C D" 
  shows "¬ ParallelogramFlat A B D C ∧ ¬ ParallelogramFlat B A C D"
  by (simp add: assms(1) assms(2) plgf_not_comm1 plgf_not_comm2)

lemma plgf_cong:
  assumes "ParallelogramFlat A B C D"
  shows "Cong A B C D ∧ Cong A D B C"
  using Cong_perm ParallelogramFlat_def assms by blast 

lemma plg_to_parallelogram:
  assumes "Plg A B C D" 
  shows "Parallelogram A B C D"
proof -
  obtain M where "M Midpoint A C ∧ M Midpoint B D"
    using Plg_def assms by auto
  thus ?thesis
    using Plg_def assms mid_plg by auto
qed

lemma plgs_one_side:
  assumes "ParallelogramStrict A B C D"
  shows "A B OS C D ∧ C D OS A B" 
proof -
  have "A C TS B D ∧ A B Par C D ∧ Cong A B C D"
    using ParallelogramStrict_def assms by auto
  show ?thesis using l12_6
    by (simp add: ‹A C TS B D ∧ A B Par C D ∧ Cong A B C D› 
        ‹⋀D C Ba A. A Ba ParStrict C D ⟹ A Ba OS C D› 
        Par_perm invert_two_sides l9_2 par_two_sides_two_sides ts_ts_os)
qed

lemma parallelogram_strict_not_col:
  assumes "ParallelogramStrict A B C D"
  shows "¬ Col A B C"
  by (metis assms one_side_not_col123 plgs_one_side) 

lemma parallelogram_strict_not_col_2: 
  assumes "ParallelogramStrict A B C D"
  shows "¬ Col B C D"
  using Col_perm assms col124__nos plgs_one_side by blast 

lemma parallelogram_strict_not_col_3:
  assumes "ParallelogramStrict A B C D"
  shows "¬ Col C D A"
  using assms col123__nos plgs_one_side by blast 

lemma parallelogram_strict_not_col_4:
  assumes "ParallelogramStrict A B C D"
  shows "¬ Col A B D"
  by (metis (no_types) assms col124__nos plgs_one_side) 

lemma plgs__pars:
  assumes "ParallelogramStrict A B C D" 
  shows "A B ParStrict C D" 
proof -
  have "A C TS B D ∧ A B Par C D ∧ Cong A B C D"
    using ParallelogramStrict_def assms by auto
  thus ?thesis
    using Par_def assms parallelogram_strict_not_col_2 by auto
qed

lemma plgs_sym:
  assumes "ParallelogramStrict A B C D"
  shows "ParallelogramStrict C D A B" 
proof -
  have "A C TS B D ∧ A B Par C D ∧ Cong A B C D"
    using ParallelogramStrict_def assms by auto
  thus ?thesis
    by (simp add: ‹A C TS B D ∧ A B Par C D ∧ Cong A B C D› 
        Cong_perm Par_perm ParallelogramStrict_def invert_two_sides l9_2) 
qed

lemma plg_sym:
  assumes "Parallelogram A B C D"
  shows "Parallelogram C D A B"
  using Parallelogram_def assms plgf_sym plgs_sym by blast 

lemma Rhombus_Plg:
  assumes "Rhombus A B C D" 
  shows "Plg A B C D"
  using Rhombus_def assms by auto 

lemma Rectangle_Plg:
  assumes "Rectangle A B C D"
  shows "Plg A B C D"
  using Rectangle_def assms by auto 

lemma Rectangle_Parallelogram:
  assumes "Rectangle A B C D" 
  shows "Parallelogram A B C D"
  using Rectangle_def assms plg_to_parallelogram by auto 

lemma plg_cong_rectangle:
  assumes "Plg A B C D" and
    "Cong A C B D" 
  shows "Rectangle A B C D"
  by (simp add: Rectangle_def assms(1) assms(2))

lemma plg_trivial:
  assumes "A ≠ B" 
  shows "Parallelogram A B B A"
  by (simp add: ParallelogramFlat_def Parallelogram_def assms col_trivial_2 
      col_trivial_3 cong_pseudo_reflexivity cong_trivial_identity) 

lemma plg_trivial1: 
  assumes "A ≠ B" 
  shows "Parallelogram A A B B"
  by (simp add: ParallelogramFlat_def Parallelogram_def assms col_trivial_1 
      cong_pseudo_reflexivity cong_trivial_identity) 

lemma col_not_plgs:
  assumes "Col A B C" 
  shows "¬ParallelogramStrict A B C D"
  using assms parallelogram_strict_not_col by auto 

lemma plg_col_plgf: 
  assumes "Col A B C" and
    "Parallelogram A B C D" 
  shows "ParallelogramFlat A B C D"
  using Parallelogram_def assms(1) assms(2) parallelogram_strict_not_col by blast 

lemma plg_bet1: 
  assumes "Parallelogram A B C D" and
    "Bet A C B" 
  shows "Bet D A C" 
proof -
  have "Col A B C"
    by (meson Bet_perm assms(2) bet_col1 between_exchange2 point_construction_different)
  moreover
  have " ParallelogramStrict A B C D ∨ ParallelogramFlat A B C D"
    using Parallelogram_def assms(1) by auto 
  ultimately 
  show ?thesis
    by (metis (no_types) Bet_perm ParallelogramFlat_def assms(2) col_cong2_bet2 
        col_not_plgs plgf_cong)
qed

lemma plgf_trivial1: 
  assumes "A ≠ B"
  shows "ParallelogramFlat A B B A"
  by (meson ParallelogramFlat_def not_col_distincts assms cong_pseudo_reflexivity 
      cong_trivial_identity) 

lemma plgf_trivial2:
  assumes "A ≠ B" 
  shows "ParallelogramFlat A A B B"
  by (meson assms plgf_permut plgf_trivial1) 

lemma plgf_not_point: 
  assumes "ParallelogramFlat A A B B"
  shows "A ≠ B"
  using assms plgf_irreflexive by blast 

lemma plgf_trivial_neq:
  assumes "ParallelogramFlat A A C D"
  shows "C = D ∧ A ≠ C"
  using assms cong_reverse_identity plgf_cong plgf_irreflexive by blast 

lemma plgf_trivial_trans: 
  assumes "ParallelogramFlat A A B B" and
    "ParallelogramFlat B B C C" 
  shows "ParallelogramFlat A A C C ∨ A = C"
  using plgf_trivial2 by auto 

lemma plgf_trivial:
  assumes "A ≠ B" 
  shows "ParallelogramFlat A B B A"
  using assms plgf_trivial1 by auto 

lemma plgf3_mid:
  assumes "ParallelogramFlat A B A C"
  shows "A Midpoint B C"
  by (metis assms midpoint_distinct_3 plgf_mid) 

lemma cong3_id: 
  assumes "A ≠ B" and
    "Col A B C" and 
    "Col A B D" and 
    "Cong A B C D" and
    "Cong A D B C" and 
    "Cong A C B D" 
  shows "A = D ∧ B = C ∨ A = C ∧ B = D"
proof cases
  assume "A = C"
  thus ?thesis 
    using assms(6) cong_reverse_identity by presburger
next
  assume "A ≠ C"
  have "∃ M. M Midpoint A B ∧ M Midpoint C D ∨ M Midpoint A D ∧ M Midpoint C B" 
  proof -
    have "A C Par B D" 
      by (metis col3 col_trivial_3 cong_identity par_col2_par par_reflexivity 
          ‹A ≠ C› assms(1) assms(2) assms(3) assms(6) not_col_permutation_5)
    moreover have "¬ A C ParStrict B D" 
      using Col_cases assms(3) par_strict_not_col_3 by blast
    ultimately show ?thesis 
      using assms(6) col_cong_mid by blast
  qed
  then obtain M where "M Midpoint A B ∧ M Midpoint C D ∨ 
  M Midpoint A D ∧ M Midpoint C B"
    by blast
  {
    assume "M Midpoint A B ∧ M Midpoint C D"
    hence "A = D ∧ B = C ∨ A = C ∧ B = D" 
      using assms(2) assms(4) midpoint_cong_uniqueness by blast
  }
  moreover
  {
    assume "M Midpoint A D ∧ M Midpoint C B"
    hence "A = D ∧ B = C ∨ A = C ∧ B = D" 
      by (metis assms(1) assms(3) assms(5) l7_2 midpoint_cong_uniqueness 
          not_col_permutation_5)
  }
  ultimately show ?thesis 
    using ‹M Midpoint A B ∧ M Midpoint C D ∨ M Midpoint A D ∧ M Midpoint C B› 
    by fastforce
qed

lemma col_cong_mid1:
  assumes "A ≠ D" and 
    "Col A B C" and
    "Col A B D" and
    "Cong A B C D" and
    "Cong A C B D"
  shows "∃ M. M Midpoint A D ∧ M Midpoint B C" 
proof -
  have "∃ M.(M Midpoint A C ∧ M Midpoint B D ∨ 
  M Midpoint A D ∧ M Midpoint B C)" 
  proof cases
    assume "A = B"
    thus ?thesis
      using assms(4) cong_reverse_identity midpoint_existence by blast 
  next
    assume "A ≠ B"
    have "C ≠ D" 
      using ‹A ≠ B› assms(4) cong_identity by blast
    hence "A B Par C D" 
      by (meson ‹A ≠ B› assms(2) assms(3) not_col_distincts not_par_inter_uniqueness)
    moreover have "¬ A B ParStrict C D" 
      using assms(3) par_strict_not_col_4 by blast
    ultimately show ?thesis 
      using assms(4) col_cong_mid by auto
  qed
  then obtain M where P3: "(M Midpoint A C ∧ M Midpoint B D) ∨
  (M Midpoint A D ∧ M Midpoint B C)" by auto
  {
    assume "M Midpoint A C ∧ M Midpoint B D"
    hence "M Midpoint A D ∧ M Midpoint B C"
      using assms(1) assms(2) assms(5) col_permutation_5 midpoint_cong_uniqueness by blast 
  }
  thus ?thesis
    using P3 by blast 
qed

lemma col_cong_mid2: 
  assumes "A ≠ C" and
    "Col A B C" and
    "Col A B D" and
    "Cong A B C D" and
    "Cong A D B C" 
  shows "∃ M. M Midpoint A C ∧ M Midpoint B D"
  by (simp add: assms(1) assms(2) assms(3) assms(4) assms(5) col_cong_mid1 
      cong_right_commutativity) 

lemma plgs_not_col:
  assumes "ParallelogramStrict A B C D"
  shows "¬ Col A B C ∧ ¬ Col B C D ∧ ¬ Col C D A ∧ ¬ Col A B D"
  using assms col_not_plgs parallelogram_strict_not_col_2 parallelogram_strict_not_col_3 
    parallelogram_strict_not_col_4 by blast 

lemma not_col_sym_not_col:
  assumes "¬ Col A B C" and
    "A Midpoint B B'"
  shows "¬ Col A B' C"
  by (metis assms(1) assms(2) col_transitivity_1 midpoint_col midpoint_distinct_2
      not_col_permutation_5) 

lemma plg_existence:
  assumes "A ≠ B" 
  shows "∃ D. Parallelogram A B C D" 
proof -
  obtain M where "M Midpoint A C"
    using midpoint_existence by auto
  thus ?thesis
    by (metis assms l7_17_bis l7_3_2 mid_plg symmetric_point_construction)
qed

lemma plgs_diff:
  assumes "ParallelogramStrict A B C D" 
  shows "ParallelogramStrict A B C D ∧ A ≠ B ∧ B ≠ C ∧ C ≠ D ∧ D ≠ A ∧ A ≠ C ∧ B ≠ D"
  using assms not_col_distincts parallelogram_strict_not_col_2 
    parallelogram_strict_not_col_3 parallelogram_strict_not_col_4 by blast 

lemma sym_par:
  assumes "A ≠ B" and
    "M Midpoint A A'" and 
    "M Midpoint B B'" 
  shows "A B Par A' B'" 
  using l12_17 assms(1) assms(2) assms(3) by auto 

lemma symmetry_preserves_two_sides:
  assumes "Col X Y M" and
    "X Y TS A B" and
    "M Midpoint A A'" and
    "M Midpoint B B'"
  shows "X Y TS A' B'" 
proof -
  have "Bet A M A'"
    by (simp add: assms(3) midpoint_bet) 
  have "Bet B M B'"
    by (simp add: assms(4) midpoint_bet)
  have "X ≠ Y"
    using assms(2) ts_distincts by blast 
  have "¬ Col A X Y"
    using TS_def assms(2) by blast 
  have "¬ Col B X Y"
    using TS_def assms(2) by blast 
  have "A ≠ M"
    using Col_perm ‹¬ Col A X Y› assms(1) by blast
  hence "A' ≠ M"
    using assms(3) cong_identity midpoint_cong by blast 
  have "B ≠ M"
    using Col_perm ‹¬ Col B X Y› assms(1) by blast
  hence "B' ≠ M"
    using assms(4) midpoint_not_midpoint by blast 
  have "X Y TS A A'"
    using NCol_cases ‹A' ≠ M› ‹¬ Col A X Y› assms(1) assms(3) colx 
      l9_18_R2 midpoint_bet midpoint_col by meson
  have "¬ Col B' X Y"
    using ‹B' ≠ M› ‹Bet B M B'› assms(1) bet_col bet_col1 ‹¬ Col B X Y› 
      l6_21 not_col_permutation_3 not_col_permutation_4 by metis
  hence "X Y TS B B'"
    using TS_def ‹¬ Col B X Y› ‹Bet B M B'› assms(1) not_col_permutation_1 by blast 
  moreover
  have "X Y OS A' B"
    by (meson ‹X Y TS A A'› assms(2) l9_2 l9_8_1) 
  ultimately
  show ?thesis
    using l9_8_2 one_side_symmetry by blast 
qed

lemma symmetry_preserves_one_side:
  assumes "Col X Y M" and
    "X Y OS A B" and
    "M Midpoint A A'" and
    "M Midpoint B B'"
  shows "X Y OS A' B'" 
proof -
  obtain P where "X Y TS A P" and "X Y TS B P"
    using OS_def assms(2) by blast
  have "X ≠ Y"
    using assms(2) os_distincts by blast 
  have "¬ Col A X Y" 
    using TS_def ‹X Y TS A P› by blast
  have "¬ Col B X Y"
    using assms(2) between_trivial one_side_chara by blast 
  have "¬ Col P X Y" 
    using TS_def ‹X Y TS A P› by blast
  have "A ≠ M"
    using assms(1) assms(2) col123__nos by blast
  hence "A' ≠ M"
    using assms(3) midpoint_not_midpoint by blast 
  have "B ≠ M"
    using assms(1) assms(2) col124__nos by blast
  hence "B' ≠ M"
    using assms(4) midpoint_not_midpoint by blast
  have "X Y TS A A'"
  proof -
    {
      assume "Col A' X Y" 
      have "Col A M A'" 
        using Col_def Midpoint_def assms(3) by auto
      have "Col M A' X" 
        using ‹Col A' X Y› ‹X ≠ Y› assms(1) col_permutation_2 col_trivial_2 colx by blast
      hence "Col A X Y" 
        by (metis ‹A' ≠ M› ‹Col A M A'› ‹Col A' X Y› assms(1) col_permutation_3 
            col_permutation_4 col_trivial_2 l6_21)
      hence False 
        using ‹¬ Col A X Y› by auto
    }
    moreover have "∃ T. Col T X Y ∧ Bet A T A'" 
    proof -
      have "Col M X Y" 
        using assms(1) not_col_permutation_1 by blast
      moreover have "Bet A M A'" 
        by (simp add: assms(3) midpoint_bet)
      ultimately show ?thesis 
        by blast
    qed
    ultimately show ?thesis 
      using TS_def ‹¬ Col A X Y› by blast
  qed
  moreover
  have "X Y TS B B'"
    by (meson ‹B' ≠ M› ‹¬ Col B X Y› assms(1) assms(4) colx l9_18_R2 
        midpoint_bet midpoint_col not_col_permutation_1)
  ultimately
  show ?thesis
    by (meson assms(2) l9_2 l9_8_1 l9_8_2) 
qed

lemma plgf_bet:
  assumes "ParallelogramFlat A B B' A'"
  shows "Bet A' B' A ∧ Bet B' A B 
  ∨ Bet A' A B' ∧ Bet A B' B
  ∨ Bet A A' B ∧ Bet A' B B'
  ∨ Bet A B A' ∧ Bet B A' B'" 
proof -
  let ?t = "Bet A' B' A ∧ Bet B' A B 
  ∨ Bet A' A B' ∧ Bet A B' B
  ∨ Bet A A' B ∧ Bet A' B B'
  ∨ Bet A B A' ∧ Bet B A' B'" 
  have "Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')"
    using ParallelogramFlat_def assms by blast
  show ?thesis
  proof cases
    assume "A = B"
    thus ?thesis
      using ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ 
    (A ≠ B' ∨ B ≠ A')› between_trivial between_trivial2 
        cong_reverse_identity by blast 
  next
    assume "A ≠ B"
    have "A' ≠ B'" 
      using ‹A ≠ B› assms plgf_not_comm1 by blast
    have "Col A' B' A" 
      by (meson ‹A ≠ B› 
          ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
          col_transitivity_1 not_col_permutation_3)
    have "Col A' B' B" 
      by (meson ‹A ≠ B› 
          ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
          col_transitivity_2 not_col_permutation_3)
    {
      assume "Bet A B A'"
      hence ?t 
        using ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
          col_cong2_bet4 cong_right_commutativity by blast
    }
    moreover
    {
      assume "Bet B A' A"
      hence ?t 
        by (metis Bet_cases 
            ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
            ‹Col A' B' A› col_cong2_bet4 cong_right_commutativity not_col_permutation_1)
    }
    moreover
    {
      assume "Bet A' A B"
      {
        assume "Bet A B B'"
        hence ?t 
          by (metis bet_cong_eq outer_transitivity_between2 ‹A ≠ B› ‹Bet A' A B› 
              ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
              cong_right_commutativity)
      }
      moreover
      {
        assume "Bet B B' A"
        hence ?t 
          by (metis between_symmetry ‹Bet A' A B› between_inner_transitivity)
      }
      moreover
      {
        assume "Bet B' A B"
        {
          assume "A = A'"
          hence ?t 
            using ‹Bet B A' A ⟹ 
          Bet A' B' A ∧ Bet B' A B ∨ 
          Bet A' A B' ∧ Bet A B' B ∨ 
          Bet A A' B ∧ Bet A' B B' ∨ Bet A B A' ∧ Bet B A' B'› 
              not_bet_distincts by blast
        }
        moreover
        {
          assume "A ≠ A'"
          have "Bet A B' A' ∨ Bet A A' B'" 
            by (metis ‹A ≠ B› ‹Bet A' A B› ‹Bet B' A B› between_symmetry l5_2)
          hence "Bet A' B' A" 
            by (metis Cong_cases ‹A ≠ B› ‹Bet A' A B› ‹Bet B' A B› 
                ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
                bet_cong_bet between_symmetry)
          hence ?t 
            using ‹Bet B' A B› by blast
        }
        hence ?t 
          using calculation by fastforce
      }
      moreover
      have ?t 
        using Col_def 
          ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
          calculation(1) calculation(2) calculation(3) by force
    }
    ultimately show ?thesis 
      using Col_def 
        ‹Col A B B' ∧ Col A B A' ∧ Cong A B B' A' ∧ Cong A A' B' B ∧ (A ≠ B' ∨ B ≠ A')› 
      by blast
  qed
qed

lemma plgs_existence:
  assumes "A ≠ B"
  shows "∃ C. ∃ D. ParallelogramStrict A B C D" 
proof -
  obtain C where "¬ Col A B C"
    using assms not_col_exists by presburger
  obtain D where "Parallelogram A B C D"
    using assms plg_existence by blast
  {
    assume "ParallelogramFlat A B C D"
    have "False"
      using ParallelogramFlat_def ‹ParallelogramFlat A B C D› ‹¬ Col A B C› by force 
  }
  thus ?thesis
    using Parallelogram_def ‹Parallelogram A B C D› by blast 
qed

lemma Rectangle_not_triv:
  shows "¬ Rectangle A A A A"
  using Rectangle_Parallelogram plg_irreflexive by blast

lemma Plg_triv:
  assumes "A ≠ B"
  shows "Plg A A B B" 
proof -
  have "∃ M. M Midpoint A B ∧ M Midpoint A B"
    by (simp add: midpoint_existence) 
  thus ?thesis
    by (simp add: Plg_def assms)
qed

lemma Rectangle_triv:
  assumes "A ≠ B"
  shows "Rectangle A A B B" 
proof -
  have "Plg A A B B"
    by (simp add: Plg_triv assms) 
  moreover
  have "Cong A B A B"
    by (simp add: cong_reflexivity) 
  ultimately
  show ?thesis
    by (simp add: plg_cong_rectangle)
qed

lemma Rectangle_not_triv_2:
  shows "¬ Rectangle A B A B"
  using Rectangle_Parallelogram plg_irreflexive by blast 

lemma Square_not_triv:
  shows "¬ Square A A A A"
  by (simp add: Rectangle_not_triv_2 Square_def Tarski_neutral_dimensionless_axioms) 

lemma Square_not_triv_2:
  shows "¬ Square A A B B"
  by (metis Square_def Square_not_triv cong_diff_3) 

lemma Square_not_triv_3:
  shows "¬ Square A B A B"
  by (simp add: Rectangle_not_triv_2 Square_def) 

lemma Square_Rectangle:
  assumes "Square A B C D"
  shows "Rectangle A B C D"
  using Square_def assms by blast 

lemma Square_Parallelogram:
  assumes "Square A B C D"
  shows "Parallelogram A B C D"
  by (simp add: Rectangle_Parallelogram Square_Rectangle assms) 

lemma Rhombus_Rectangle_Square:
  assumes "Rhombus A B C D" and
    "Rectangle A B C D"
  shows "Square A B C D"
  using Rhombus_def Square_def assms(1) assms(2) by blast

lemma rhombus_cong_square:
  assumes "Rhombus A B C D" and
    "Cong A C B D" 
  shows "Square A B C D"
  by (simp add: Rhombus_Plg Rhombus_Rectangle_Square assms(1) assms(2) plg_cong_rectangle) 

lemma Kite_comm:
  assumes "Kite A B C D"
  shows "Kite C D A B"
  using Kite_def assms by auto 

lemma per2_col_eq:
  assumes "A ≠ P" and
    "A ≠ P'" and
    "Per A P B" and
    "Per A P' B" and
    "Col P A P'"
  shows "P = P'"
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) col_per2_cases 
      l6_16_1 l8_2 not_col_permutation_3)

lemma per2_preserves_diff:
  assumes "PO ≠ A'" and
    "PO ≠ B'" and
    "Col PO A' B'" and
    "Per PO A' A" and
    "Per PO B' B" and
    "A' ≠ B'"
  shows "A ≠ B"
  using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) not_col_permutation_4 
    per2_col_eq by blast

lemma per23_preserves_bet:
  assumes "Bet A B C" and
    "A ≠ B'" and "A ≠ C'" and
    "Col A B' C'" and
    "Per A B' B" and
    "Per A C' C"
  shows "Bet A B' C'"
proof -
  have P1: "Col A B C"
    by (simp add: assms(1) bet_col)
  show ?thesis
  proof cases
    assume P2: "B = B'"
    hence "Col A C' C"
      using P1 assms(2) assms(4) col_transitivity_1 by blast
    hence P4: "A = C' ∨ C = C'"
      by (simp add: assms(6) l8_9)
    {
      assume "A = C'"
      hence "Bet A B' C'"
        using assms(3) by auto
    }
    {
      assume "C = C'"
      hence "Bet A B' C'"
        using P2 assms(1) by auto
    }
    thus ?thesis
      using P4 assms(3) by auto
  next
    assume T1: "B ≠ B'"
    have T2: "A ≠ C"
      using assms(3) assms(6) l8_8 by auto
    have T3: "C ≠ C'"
      using P1 T1 assms(2) assms(3) assms(4) assms(5) col_trivial_3 colx l8_9 
        not_col_permutation_5 by blast
    have T3A: "A B' Perp B' B"
      using T1 assms(2) assms(5) per_perp by auto
    have T3B: "A C' Perp C' C"
      using T3 assms(3) assms(6) per_perp by auto
    have T4: "B B' Par C C'"
    proof -
      have "Coplanar A B' B C"
        using P1 ncop__ncols by blast
      moreover have "Coplanar A B' B C'"
        using assms(4) ncop__ncols by blast
      moreover have "Coplanar A B' B' C"
        using ncop_distincts by blast
      moreover have "B B' Perp A B'"
        using Perp_perm ‹A B' Perp B' B› by blast
      moreover have "C C' Perp A B'"
        using Col_cases Perp_cases T3B assms(2) assms(4) perp_col1 by blast
      ultimately show ?thesis
        using l12_9 bet__coplanar between_trivial by auto
    qed
    moreover have "Bet A B' C'"
    proof cases
      assume "B = C"
      thus ?thesis
        by (metis T1 per_col_eq assms(4) assms(5) calculation l6_16_1 l6_6 
            or_bet_out out_diff1 par_id)
    next
      assume T6: "B ≠ C"
      have T7: "¬ Col A B' B"
        using T1 assms(2) assms(5) l8_9 by blast
      have T8: "¬ Col A C' C"
        using T3 assms(3) assms(6) l8_9 by blast
      have T9: "B' ≠ C'"
        using P1 T6 assms(2) assms(5) assms(6) col_per2__per col_permutation_1 
          l8_2 l8_8 by blast
      have T10: "B B' ParStrict C C' ∨ (B ≠ B' ∧ C ≠ C' ∧ Col B C C' ∧ Col B' C C')"
        using Par_def calculation by blast
      {
        assume T11: "B B' ParStrict C C'"
        hence T12: "B B' OS C' C"
          using l12_6 one_side_symmetry by blast
        have "B B' TS A C"
          using Col_cases T6 T7 assms(1) bet__ts by blast
        hence "Bet A B' C'"
          using T12 assms(4) l9_5 l9_9 not_col_distincts or_bet_out by blast
      }
      {
        assume "B ≠ B' ∧ C ≠ C' ∧ Col B C C' ∧ Col B' C C'"
        hence "Bet A B' C'"
          using Col_def T6 T8 assms(1) col_transitivity_2 by blast
      }
      thus ?thesis
        using T10 ‹B B' ParStrict C C' ⟹ Bet A B' C'› by blast
    qed
    ultimately show ?thesis
      using P1 Par_def T1 T2 assms(4) col_transitivity_2 not_col_permutation_1 
        par_strict_not_col_2 by blast
  qed
qed

lemma per23_preserves_bet_inv:
  assumes "Bet A B' C'" and
    "A ≠ B'" and
    "Col A B C" and
    "Per A B' B" and
    "Per A C' C"
  shows "Bet A B C"
proof cases
  assume T1: "B = B'"
  hence "Col A C' C"
    using Col_def assms(1) assms(2) assms(3) col_transitivity_1 by blast
  hence T2: "A = C' ∨ C = C'"
    by (simp add: assms(5) l8_9)
  {
    assume "A = C'"
    hence "Bet A B C"
      using assms(1) assms(2) between_identity by blast
  }
  {
    assume "C = C'"
    hence "Bet A B C"
      by (simp add: T1 assms(1))
  }
  thus ?thesis
    using T2 ‹A = C' ⟹ Bet A B C› by auto
next
  assume P1: "B ≠ B'"
  hence P2: "A B' Perp B' B"
    using assms(2) assms(4) per_perp by auto
  have "Per A C' C"
    by (simp add: assms(5))
  hence P2: "C' PerpAt A C' C' C"
    by (metis (mono_tags, lifting) Col_cases P1 assms(1) assms(2) assms(3) assms(4) 
        bet_col bet_neq12__neq col_transitivity_1 l8_9 per_perp_in)
  hence P3: "A C' Perp C' C"
    using perp_in_perp by auto
  hence "C' ≠ C"
    using ‹A C' Perp C' C› perp_not_eq_2 by auto
  have "C' PerpAt C' A C C'"
    by (simp add: Perp_in_perm P2)
  hence "(C' A Perp C C') ∨ (C' C' Perp C C')"
    using Perp_def by blast
  have "A ≠ C'"
    using assms(1) assms(2) between_identity by blast
  {
    assume "C' A Perp C C'"
    have "Col A B' C'" using assms(1)
      by (simp add: Col_def)
    have "A B' Perp C' C"
      using Col_cases ‹A C' Perp C' C› ‹Col A B' C'› assms(2) perp_col by blast
    have P7: "B' B Par C' C"
    proof -
      have "Coplanar A B' B' C'"
        using ncop_distincts by blast
      moreover have "Coplanar A B' B' C"
        using ncop_distincts by auto
      moreover have "Coplanar A B' B C'"
        using Bet_perm assms(1) bet__coplanar ncoplanar_perm_20 by blast
      moreover have "Coplanar A B' B C"
        using assms(3) ncop__ncols by auto
      moreover have "B' B Perp A B'"
        by (metis P1 Perp_perm assms(2) assms(4) per_perp)
      moreover have "C' C Perp A B'"
        using Perp_cases ‹A B' Perp C' C› by auto
      ultimately show ?thesis using l12_9 by blast
    qed
    have "Bet A B C"
    proof cases
      assume "B = C"
      thus ?thesis
        by (simp add: between_trivial)
    next
      assume T1: "B ≠ C"
      have T2: "B' B ParStrict C' C ∨ (B' ≠ B ∧ C' ≠ C ∧ Col B' C' C ∧ Col B C' C)"
        using P7 Par_def by auto
      {
        assume T3: "B' B ParStrict C' C"
        hence "B' ≠ C'"
          using not_par_strict_id by auto
        have "∃ X. Col X B' B ∧ Col X B' C"
          using col_trivial_1 by blast
        have "B' B OS C' C"
          by (simp add: T3 l12_6)
        have "B' B TS A C'"
          by (metis Bet_cases T3 assms(1) assms(2) bet__ts l9_2 par_strict_not_col_1)
        hence T8: "B' B TS C A"
          using ‹B' B OS C' C› l9_2 l9_8_2 by blast
        then obtain T where T9: "Col T B' B ∧ Bet C T A"
          using TS_def by auto
        have "¬ Col A C B'"
          using T8 assms(3) not_col_permutation_2 not_col_permutation_3 ts__ncol by blast
        hence "T = B"
          by (metis Col_def Col_perm T9 assms(3) colx)
        hence "Bet A B C"
          using Bet_cases T9 by auto
      }
      {
        assume "B' ≠ B ∧ C' ≠ C ∧ Col B' C' C ∧ Col B C' C"
        hence "Col A B' B"
          by (metis Col_perm T1 assms(3) l6_16_1)
        hence "A = B' ∨ B = B'"
          using assms(4) l8_9 by auto
        hence "Bet A B C"
          by (simp add: P1 assms(2))
      }
      thus ?thesis
        using T2 ‹B' B ParStrict C' C ⟹ Bet A B C› by auto
    qed
  }
  thus ?thesis
    by (simp add: P3 perp_comm)
qed

lemma per13_preserves_bet:
  assumes "Bet A B C" and
    "B ≠ A'" and
    "B ≠ C'" and
    "Col A' B C'" and
    "Per B A' A" and
    "Per B C' C"
  shows "Bet A' B C'"
  by (smt (verit, ccfv_SIG) NCol_perm assms(1,3,4,5,6) bet_col1 bet_out_1 
      between_exchange2 l8_20_1_R1
      l8_7 not_bet_and_out per23_preserves_bet_inv point_construction_different third_point)

lemma per13_preserves_bet_inv:
  assumes "Bet A' B C'" and
    "B ≠ A'" and
    "B ≠ C'" and
    "Col A B C" and
    "Per B A' A" and
    "Per B C' C"
  shows "Bet A B C"
  by (meson Col_def assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
      between_equality between_symmetry per23_preserves_bet)

lemma per3_preserves_bet1:
  assumes "Col PO A B" and
    "Bet A B C" and
    "PO ≠ A'" and
    "PO ≠ B'" and
    "PO ≠ C'" and
    "Per PO A' A" and
    "Per PO B' B" and
    "Per PO C' C" and
    "Col A' B' C'" and
    "Col PO A' B'"
  shows "Bet A' B' C'"
proof cases
  assume "A = B"
  thus ?thesis
    using assms(10) assms(3) assms(4) assms(6) assms(7) between_trivial2 
      per2_preserves_diff by blast
next
  assume P1: "A ≠ B"
  show ?thesis
  proof cases
    assume P2: "A = A'"
    show ?thesis
    proof cases
      assume P3: "B = B'"
      hence "Col PO C C'" 
        using P1 P2 assms(10) assms(2) assms(9) bet_col col3 col_permutation_1 by blast
      hence "C = C'"
        using assms(5) assms(8) l8_9 not_col_permutation_5 by blast
      thus ?thesis
        using P2 P3 assms(2) by blast
    next
      assume P4: "B ≠ B'"
      show ?thesis
      proof cases
        assume "A = B'"
        thus ?thesis
          using P2 between_trivial2 by auto
      next
        assume "A ≠ B'"
        have "A ≠ C"
          using P1 assms(2) between_identity by blast
        have P7: "¬ Col PO B' B"
          using P4 assms(4) assms(7) l8_9 by blast
        show ?thesis
          using P2 P7 assms(1) assms(10) assms(3) col_transitivity_1 by blast
      qed
    qed
  next
    assume R1: "A ≠ A'"
    show ?thesis
    proof cases
      assume R2: "A' = B'"
      thus ?thesis
        by (simp add: between_trivial2)
    next
      assume R3: "A' ≠ B'"
      show ?thesis
      proof cases
        assume "B = C"
        have "B' = C'"
          by (metis per2_col_eq ‹A' ≠ B'› ‹B = C› assms(10) assms(4) assms(5) 
              assms(7) assms(8) assms(9) col_transitivity_2 not_col_permutation_2)
        thus ?thesis
          by (simp add: between_trivial)
      next
        assume R4: "B ≠ C"
        show ?thesis
        proof cases
          assume "B = B'"
          thus ?thesis
            by (metis R1 assms(1) assms(10) assms(3) assms(4) assms(6) 
                l6_16_1 l8_9 not_col_permutation_2)
        next
          assume R5: "B ≠ B'"
          show ?thesis
          proof cases
            assume "A' = B"
            thus ?thesis
              using R5 assms(10) assms(4) assms(7) col_permutation_5 l8_9 by blast
          next
            assume R5A: "A' ≠ B"
            have R6: "C ≠ C'"
              by (metis P1 R1 R3 assms(1) assms(10) assms(2) assms(3) 
                  assms(5) assms(6) assms(9) bet_col col_permutation_1 
                  col_trivial_2 l6_21 l8_9)
            have R7: "A A' Perp PO A'"
              by (metis Perp_cases R1 assms(3) assms(6) per_perp)
            have R8: "C C' Perp PO A'"
            proof -
              have "C' C' Perp C' C ∨ PO C' Perp C' C" 
                using R6 assms(5) assms(8) per_perp by auto
              moreover
              {
                assume "C' C' Perp C' C"
                hence "C C' Perp PO A'" 
                  using ‹C' C' Perp C' C› perp_not_eq_1 by blast
              }
              moreover
              {
                assume "PO C' Perp C' C"
                hence "C C' Perp PO A'" 
                  by (metis Col_cases R3 Perp_cases assms(10) assms(3) assms(9) col3 
                      col_trivial_3 perp_col1)
              }
              ultimately show ?thesis 
                by blast
            qed
            have "A A' Par C C'"
            proof -
              have "Coplanar PO A' A C"
                using P1 assms(1) assms(2) bet_col col_trivial_2 colx ncop__ncols by blast
              moreover have "Coplanar PO A' A C'"
                using R3 assms(10) assms(9) col_trivial_2 colx ncop__ncols by blast
              moreover have "Coplanar PO A' A' C"
                using ncop_distincts by blast
              moreover have "Coplanar PO A' A' C'"
                using ncop_distincts by blast
              ultimately show ?thesis using l12_9 R7 R8 by blast
            qed
            have S1: "B B' Perp PO A'"
              by (metis Col_cases Per_cases Perp_perm R5 assms(10) assms(3) 
                  assms(4) assms(7) col_per_perp)
            have "A A' Par B B'"
            proof -
              have "Coplanar PO A' A B"
                using assms(1) ncop__ncols by auto
              moreover have "Coplanar PO A' A B'"
                using assms(10) ncop__ncols by auto
              moreover have "Coplanar PO A' A' B"
                using ncop_distincts by auto
              moreover have "Coplanar PO A' A' B'"
                using ncop_distincts by auto
              moreover have "A A' Perp PO A'"
                by (simp add: R7)
              moreover have "B B' Perp PO A'"
                by (simp add: S1)
              ultimately show ?thesis
                using l12_9 by blast
            qed
            {
              assume "A A' ParStrict B B'"
              hence "A A' OS B B'"
                by (simp add: l12_6)
              have "B B' TS A C"
                using R4 ‹A A' ParStrict B B'› assms(2) bet__ts par_strict_not_col_3 by auto
              have "B B' OS A A'"
                using ‹A A' ParStrict B B'› pars__os3412 by auto
              have "B B' TS A' C"
                using ‹B B' OS A A'› ‹B B' TS A C› l9_8_2 by blast
              have "Bet A' B' C'"
              proof cases
                assume "C = C'"
                thus ?thesis
                  using R6 by auto
              next
                assume "C ≠ C'"
                have "C C' Perp PO A'"
                  by (simp add: R8)
                have Q2: "B B' Par C C'"
                proof -
                  have "Coplanar PO A' B C"
                    by (metis P1 assms(1) assms(2) bet_col col_transitivity_1 
                        colx ncop__ncols not_col_permutation_5)
                  moreover have "Coplanar PO A' B C'"
                    using R3 assms(10) assms(9) col_trivial_2 colx ncop__ncols by blast
                  moreover have "Coplanar PO A' B' C"
                    by (simp add: assms(10) col__coplanar)
                  moreover have "Coplanar PO A' B' C'"
                    using assms(10) col__coplanar by auto
                  moreover have "B B' Perp PO A'"
                    by (simp add: S1)
                  moreover have "C C' Perp PO A'"
                    by (simp add: R8)
                  ultimately show ?thesis
                    using l12_9 by auto
                qed
                hence Q3: "(B B' ParStrict C C') ∨ (B ≠ B' ∧ C ≠ C' ∧ Col B C C' ∧ Col B' C C')"
                  by (simp add: Par_def)
                {
                  assume "B B' ParStrict C C'"
                  hence "B B' OS C C'"
                    using l12_6 by auto
                  hence "B B' TS C' A'"
                    using ‹B B' TS A' C› l9_2 l9_8_2 by blast
                  then obtain T where Q4: "Col T B B' ∧ Bet C' T A'"
                    using TS_def by blast
                  have "T = B'"
                  proof -
                    have "¬ Col B B' A'"
                      using ‹B B' OS A A'› col124__nos by auto
                    moreover have "A' ≠ C'"
                      using ‹B B' TS C' A'› not_two_sides_id by auto
                    moreover have "Col B B' T"
                      using Col_cases Q4 by auto
                    moreover have "Col B B' B'"
                      using not_col_distincts by blast
                    moreover have "Col A' C' T"
                      by (simp add: Col_def Q4)
                    ultimately show ?thesis
                      by (meson assms(9) col_permutation_5 l6_21)
                  qed
                  hence "Bet A' B' C'"
                    using Q4 between_symmetry by blast
                }
                {
                  assume "B ≠ B' ∧ C ≠ C' ∧ Col B C C' ∧ Col B' C C'"
                  hence "Bet A' B' C'"
                    using TS_def ‹B B' TS A C› l6_16_1 not_col_permutation_2 by blast
                }
                thus ?thesis
                  using Q3 ‹B B' ParStrict C C' ⟹ Bet A' B' C'› by blast
              qed
            }
            {
              assume R8: "A ≠ A' ∧ B ≠ B' ∧ Col A B B' ∧ Col A' B B'"
              have "A' A Perp PO A'"
                by (simp add: R7 perp_left_comm)
              have "¬ Col A' A PO"
                using Col_cases R8 assms(3) assms(6) l8_9 by blast
              hence "Bet A' B' C'"
                using Col_perm P1 R8 assms(1) l6_16_1 by blast
            }
            thus ?thesis
              using Par_def ‹A A' Par B B'› ‹A A' ParStrict B B' ⟹ Bet A' B' C'› by auto
          qed
        qed
      qed
    qed
  qed
qed

lemma per3_preserves_bet2_aux:
  assumes "Col PO A C" and
    "A ≠ C'" and
    "Bet A B' C'" and
    "PO ≠ A" and
    "PO ≠ B'" and
    "PO ≠ C'" and
    "Per PO B' B" and
    "Per PO C' C" and
    "Col A B C" and
    "Col PO A C'"
  shows "Bet A B C"
proof cases
  assume "A = B"
  thus ?thesis
    by (simp add: between_trivial2)
next
  assume P1: "A ≠ B"
  show ?thesis
  proof cases
    assume "B = C"
    thus ?thesis
      by (simp add: between_trivial)
  next
    assume P2: "B ≠ C"
    have P3: "Col PO A B'"
      by (metis Col_def assms(10) assms(2) assms(3) l6_16_1)
    hence P4: "Col PO B' C'"
      using assms(10) assms(4) col_transitivity_1 by blast
    show ?thesis
    proof cases
      assume "B = B'"
      thus ?thesis
        by (metis per_col_eq assms(1) assms(10) assms(3) assms(4) assms(6) 
            assms(8) col_transitivity_1)
    next
      assume P5: "B ≠ B'"
      have P6: "C = C'"
        using assms(1) assms(10) assms(4) assms(6) assms(8) col_transitivity_1 l8_9 by blast
      hence "False"
        by (metis P3 P5 P6 per_col_eq assms(1) assms(2) assms(4) assms(5) 
            assms(7) assms(9) col_transitivity_1 l6_16_1 not_col_permutation_4)
      thus ?thesis by blast
    qed
  qed
qed

lemma per3_preserves_bet2:
  assumes "Col PO A C" and
    "A' ≠ C'" and
    "Bet A' B' C'" and
    "PO ≠ A'" and
    "PO ≠ B'" and
    "PO ≠ C'" and
    "Per PO A' A" and
    "Per PO B' B" and
    "Per PO C' C" and
    "Col A B C" and
    "Col PO A' C'"
  shows "Bet A B C"
proof cases
  assume "A = A'"
  thus ?thesis
    using assms(1) assms(10) assms(11) assms(2) assms(3) assms(4) assms(5) 
      assms(6) assms(8) assms(9) per3_preserves_bet2_aux by blast
next
  assume P1: "A ≠ A'"
  show ?thesis
  proof cases
    assume "C = C'"
    thus ?thesis
      by (metis P1 assms(1) assms(11) assms(4) assms(6) assms(7) col_trivial_3 
          l6_21 l8_9 not_col_permutation_2)
  next
    assume P2: "C ≠ C'"
    hence P3: "PO A' Perp C C'"
      by (metis assms(11) assms(4) assms(6) assms(9) col_per_perp l8_2 not_col_permutation_1)
    have P4: "PO A' Perp A A'"
      using P1 assms(4) assms(7) per_perp perp_right_comm by auto
    have "A A' Par C C'"
    proof -
      have "Coplanar PO A' A C"
        using assms(1) ncop__ncols by blast
      moreover have "Coplanar PO A' A C'"
        by (meson assms(11) ncop__ncols)
      moreover have "Coplanar PO A' A' C"
        using ncop_distincts by blast
      moreover have "Coplanar PO A' A' C'"
        using ncop_distincts by blast
      moreover have "A A' Perp PO A'"
        using P4 Perp_cases by blast
      moreover have "C C' Perp PO A'"
        using P3 Perp_cases by auto
      ultimately show ?thesis
        using l12_9 by blast
    qed
    {
      assume P5: "A A' ParStrict C C'"
      hence P6: "A A' OS C C'"
        by (simp add: l12_6)
      have P7: "C C' OS A A'"
        by (simp add: P5 pars__os3412)
      have "Bet A B C"
      proof cases
        assume P8: "B = B'"
        hence "A' A OS B C'"
          by (metis P6 assms(10) assms(3) bet_out col123__nos col124__nos 
              invert_one_side out_one_side)
        hence "A A' OS B C'"
          by (simp add: invert_one_side)
        hence "A A' OS B C"
          using P6 one_side_symmetry one_side_transitivity by blast
        hence P12: "A Out B C"
          using assms(10) col_one_side_out by blast
        have "C' C OS B A'"
          by (metis Col_perm P5 P7 P8 assms(10) assms(3) bet_out_1 col123__nos 
              out_one_side par_strict_not_col_2)
        hence "C C' OS B A"
          by (meson P7 invert_one_side one_side_symmetry one_side_transitivity)
        hence "C C' OS A B"
          using one_side_symmetry by blast
        hence "C Out A B"
          using assms(10) col_one_side_out col_permutation_2 by blast
        thus ?thesis
          by (simp add: P12 out2__bet)
      next
        assume T1: "B ≠ B'"
        have T2: "PO A' Perp B B'"
        proof -
          have "Per PO B' B"
            by (simp add: assms(8))
          hence "B' PerpAt PO B' B' B"
            using T1 assms(5) per_perp_in by auto
          hence "B' PerpAt B' PO B B'"
            by (simp add: perp_in_comm)
          hence T4: "B' PO Perp B B' ∨ B' B' Perp B B'"
            using Perp_def by auto
          {
            assume T5: "B' PO Perp B B'"
            have "Col A' B' C'"
              by (simp add: assms(3) bet_col)
            hence "Col PO B' A'"
              using assms(11) assms(2) col2__eq col_permutation_4 
                col_permutation_5 by blast
            hence "PO A' Perp B B'"
              by (metis T5 assms(4) col_trivial_3 perp_col2 perp_comm)
          }
          {
            assume "B' B' Perp B B'"
            hence "PO A' Perp B B'"
              using perp_distinct by auto
          }
          thus ?thesis
            using T4 ‹B' PO Perp B B' ⟹ PO A' Perp B B'› by linarith
        qed
        have T6: "B B' Par A A'"
        proof -
          have "Coplanar PO A' B A"
            by (metis Col_cases P7 assms(1) assms(10) col_transitivity_2 
                ncop__ncols os_distincts)
          moreover have "Coplanar PO A' B A'"
            using ncop_distincts by blast
          moreover have "Coplanar PO A' B' A"
          proof -
            have "(Bet PO A' C' ∨ Bet PO C' A') ∨ Bet C' PO A'"
              by (meson assms(11) third_point)
            thus ?thesis
              by (meson Bet_perm assms(3) bet__coplanar between_exchange2 
                  l5_3 ncoplanar_perm_8)
          qed
          moreover have "Coplanar PO A' B' A'"
            using ncop_distincts by auto
          moreover have "B B' Perp PO A'"
            using Perp_cases T2 by blast
          moreover have "A A' Perp PO A'"
            using P4 Perp_cases by blast
          ultimately show ?thesis
            using l12_9 by blast
        qed
        {
          assume "B B' ParStrict A A'"
          hence "B B' OS A A'"
            by (simp add: l12_6)
          have "B B' Par C C'"
          proof -
            have "Coplanar PO A' B C"
              by (metis Col_cases P7 assms(1) assms(10) col2__eq ncop__ncols os_distincts)
            moreover have "Coplanar PO A' B C'"
              using assms(11) ncop__ncols by auto
            moreover have "Coplanar PO A' B' C"
              by (metis Out_def assms(11) assms(2) assms(3) col_trivial_2 
                  l6_16_1 ncop__ncols not_col_permutation_1 out_col)
            moreover have "Coplanar PO A' B' C'"
              using assms(11) ncop__ncols by blast
            moreover have "B B' Perp PO A'"
              using Perp_cases T2 by blast
            moreover have "C C' Perp PO A'"
              using P3 Perp_cases by auto
            ultimately show ?thesis
              using l12_9 by blast
          qed
          {
            assume T9: "B B' ParStrict C C'"
            hence T10: "B B' OS C C'"
              by (simp add: l12_6)
            have T11: "B B' TS A' C'"
              by (metis Col_cases T10 ‹B B' ParStrict A A'› assms(3) bet__ts 
                  invert_two_sides os_distincts par_strict_not_col_4)
            have T12: "B B' TS A C'"
              using ‹B B' OS A A'› ‹B B' TS A' C'› l9_8_2 
                one_side_symmetry by blast
            hence T12A: "B B' TS C A"
              using T10 l9_2 l9_8_2 one_side_symmetry by blast
            then obtain T where T13: "Col T B B' ∧ Bet C T A"
              using TS_def by auto
            hence "B = T"
              by (metis Col_perm TS_def T12A assms(10) bet_col1 col_transitivity_2 
                  col_two_sides_bet)
            hence "Bet A B C"
              using Bet_perm T13 by blast
          }
          {
            assume "B ≠ B' ∧ C ≠ C' ∧ Col B C C' ∧ Col B' C C'"
            hence "Bet A B C"
              by (metis Col_cases P5 assms(10) col3 col_trivial_2 
                  not_bet_distincts par_strict_not_col_3)
          }
          hence "Bet A B C"
            using Par_def ‹B B' Par C C'› ‹B B' ParStrict C C' ⟹ Bet A B C› by auto
        }
        {
          assume "B ≠ B' ∧ A ≠ A' ∧ Col B A A' ∧ Col B' A A'"
          hence "Bet A B C"
          proof cases
            assume "A = B"
            thus ?thesis 
              using between_trivial2 by auto
          next
            assume "A ≠ B"
            thus ?thesis 
              by (metis Col_cases P5 
                  ‹B ≠ B' ∧ A ≠ A' ∧ Col B A A' ∧ Col B' A A'› assms(10) 
                  col_transitivity_2 par_strict_not_col_1)
          qed
        }
        thus ?thesis
          using Par_def T6 ‹B B' ParStrict A A' ⟹ Bet A B C› by auto
      qed
    }
    {
      assume "A ≠ A' ∧ C ≠ C' ∧ Col A C C' ∧ Col A' C C'"
      hence "Bet A B C"
        by (metis Col_perm P3 Par_def assms(11) assms(2) assms(4) 
            col_transitivity_1 perp_not_par)
    }
    thus ?thesis
      using Par_def ‹A A' Par C C'› ‹A A' ParStrict C C' ⟹ Bet A B C› by auto
  qed
qed

lemma symmetry_preserves_per:
  assumes "Per B P A" and
    "B Midpoint A A'" and
    "B Midpoint P P'"
  shows "Per B P' A'"
proof -
  obtain C where P1: "P Midpoint A C"
    using symmetric_point_construction by blast
  obtain C' where P2: "B Midpoint C C'"
    using symmetric_point_construction by blast
  have P3: "P' Midpoint A' C'"
    using P1 P2 assms(2) assms(3) symmetry_preserves_midpoint by blast
  have "Cong B A' B C'"
    by (meson P1 P2 assms(1) assms(2) l7_16 l7_3_2 per_double_cong)
  thus ?thesis
    using P3 Per_def by blast
qed

lemma l13_1_aux:
  assumes "¬ Col A B C" and
    "P Midpoint B C" and
    "Q Midpoint A C" and
    "R Midpoint A B"
  shows
    "∃ X Y. (R PerpAt X Y A B ∧ X Y Perp P Q ∧ Coplanar A B C X ∧ Coplanar A B C Y)"
proof -
  have P1: "Q ≠ C"
    using assms(1) assms(3) midpoint_not_midpoint not_col_distincts by blast
  have P2: "P ≠ C"
    using assms(1) assms(2) is_midpoint_id_2 not_col_distincts by blast
  hence "Q ≠ R"
    using assms(2) assms(3) assms(4) l7_3 symmetric_point_uniqueness by blast
  have "R ≠ B"
    using assms(1) assms(4) midpoint_not_midpoint not_col_distincts by blast
  {
    assume V1: "Col P Q C"
    have V2: "Col B P C"
      by (simp add: assms(2) bet_col midpoint_bet)
    have V3: "Col A Q C"
      by (simp add: assms(3) bet_col midpoint_bet)
    have "Col A R B"
      using assms(4) midpoint_col not_col_permutation_4 by blast
    hence "Col A B C" using V1 V2 V3
      by (metis P1 P2 col2__eq col_permutation_5)
    hence "False"
      using assms(1) by auto
  }
  hence P2A: "¬ Col P Q C" by auto
  then obtain C' where P3: "Col P Q C' ∧ P Q Perp C C'"
    using l8_18_existence by blast
  obtain A' where P4: "Q Midpoint C' A'"
    using symmetric_point_construction by auto
  obtain B' where P5: "P Midpoint C' B'"
    using symmetric_point_construction by auto
  have P6: "Cong C C' B B'"
    using Mid_cases P5 assms(2) l7_13 by blast
  have P7: "Cong C C' A A'"
    using P4 assms(3) l7_13 l7_2 by blast
  have P8: "Per P B' B"
  proof cases
    assume "P = C'"
    thus ?thesis
      using P5 Per_cases is_midpoint_id l8_5 by blast
  next
    assume "P ≠ C'"
    hence "P C' Perp C C'"
      using P3 perp_col by blast
    hence "Per P C' C"
      using Perp_perm perp_per_2 by blast
    thus ?thesis
      using symmetry_preserves_per Mid_perm P5 assms(2) by blast
  qed
  have P8A: "Per Q A' A"
  proof cases
    assume "Q = C'"
    thus ?thesis
      using P4 Per_cases is_midpoint_id l8_5 by blast
  next
    assume "Q ≠ C'"
    hence "C' Q Perp C C'"
      using P3 col_trivial_2 perp_col2 by auto
    hence "Per Q C' C"
      by (simp add: perp_per_1)
    thus ?thesis
      by (meson Mid_cases P4 assms(3) l7_3_2 midpoint_preserves_per)
  qed
  have P9: "Col A' C' Q"
    using P4 midpoint_col not_col_permutation_3 by blast
  have P10: "Col B' C' P"
    using P5 midpoint_col not_col_permutation_3 by blast
  have P11: "P ≠ Q"
    using P2A col_trivial_1 by auto
  hence P12: "A' ≠ B'"
    using P4 P5 l7_17 by blast
  have P13: "Col A' B' P"
    by (metis P10 P3 P4 P5 P9 col2__eq col_permutation_5 
        midpoint_distinct_1 not_col_distincts)
  have P14: "Col A' B' Q" 
    using P10 P3 P4 P5 P9 col2__eq col_permutation_5 midpoint_distinct_1 
      not_col_distincts by metis
  have P15: "Col A' B' C'"
    using P11 P13 P14 P3 colx by blast
  have P16: "C ≠ C'"
    using P2A P3 by blast
  hence P17: "A ≠ A'"
    using P7 cong_diff by blast
  have P18: "B ≠ B'"
    using P16 P6 cong_diff by blast
  have P19: "Per P A' A"
  proof cases
    assume P20: "A' = Q"
    hence "A' P Perp C A'"
      by (metis P3 P4 Perp_cases midpoint_not_midpoint)
    hence "Per P A' C"
      by (simp add: perp_per_1)
    thus ?thesis
      using P20 assms(3) l7_2 l8_4 by blast
  next
    assume "A' ≠ Q"
    thus ?thesis
      by (meson P12 P13 P14 P8A col_transitivity_1 l8_2 per_col)
  qed
  have "Per Q B' B"
  proof cases
    assume P21: "P = B'"
    hence P22: "C' = B'"
      using P5 is_midpoint_id_2 by auto
    hence "Per Q B' C"
      using P3 P21 perp_per_1 by auto
    thus ?thesis
      by (metis Col_perm P16 P21 P22 assms(2) midpoint_col per_col)
  next
    assume P23: "P ≠ B'"
    have "Col B' P Q"
      using P12 P13 P14 col_transitivity_2 by blast
    hence "Per B B' Q"
      using P8 P23 l8_2 l8_3 by blast
    thus ?thesis
      using Per_perm by blast
  qed
  hence P24: "Per A' B' B"
    using P11 P13 P14 P8 l8_3 not_col_permutation_2 by blast
  have P25: "Per A A' B'"
    using P11 P13 P14 P19 P8A l8_2 l8_3 not_col_permutation_5 by blast
  hence "Per B' A' A"
    using Per_perm by blast
  hence "¬ Col B' A' A"
    using P12 P17 P25 per_not_col by auto
  hence P26: "¬ Col A' B' A"
    using Col_cases by auto
  have "¬ Col A' B' B"
    using P12 P18 P24 l8_9 by auto
  obtain X where P28: "X Midpoint A' B'"
    using midpoint_existence by blast
  hence P28A: "Col A' B' X"
    using midpoint_col not_col_permutation_2 by blast
  hence "∃ Q. A' B' Perp Q X ∧ A' B' OS A Q"
    by (simp add: P26 l10_15)
  then obtain y where P29: "A' B' Perp y X ∧ A' B' OS A y" by blast
  then obtain B'' where P30: "(X y Perp A B'' ∨ A = B'') ∧ 
  (∃ M. (Col X y M ∧ M Midpoint A B''))"
    using ex_sym by blast
  hence P31: "B'' A ReflectL X y"
    using P30 ReflectL_def by blast
  have P32: "X ≠ y"
    using P29 P28A col124__nos by blast
  hence "X ≠ y ∧ B'' A ReflectL X y ∨ X = y ∧ X Midpoint A B''"
    using P31 by auto
  hence P33: "B'' A Reflect X y"
    by (simp add: Reflect_def)
  have P33A: "X ≠ y ∧ A' B' ReflectL X y"
    using P28 P29 Perp_cases ReflectL_def P32 col_trivial_3 l10_4_spec by blast
  hence P34: "A' B' Reflect X y"
    using Reflect_def by blast
  have P34A: "A B'' Reflect X y"
    using P33 l10_4 by blast
  hence P35: "Cong B'' B' A A'"
    using P34 l10_10 by auto
  have "Per A' B' B''"
  proof -
    have R1: "X ≠ y ∧ A B'' ReflectL X y ∨ X = y ∧ X Midpoint B'' A"
      by (simp add: P31 P32 l10_4_spec)
    have R2: "X ≠ y ∧ A' B' ReflectL X y ∨ X = y ∧ X Midpoint B' A'"
      using P33A by linarith
    {
      assume "X ≠ y ∧ A B'' ReflectL X y ∧ X ≠ y ∧ A' B' ReflectL X y"
      hence "Per A' B' B''"
        using ‹Per B' A' A› image_spec_preserves_per l10_4_spec by blast
    }
    {
      assume "X ≠ y ∧ A B'' ReflectL X y ∧ X = y ∧ X Midpoint B' A'"
      hence "Per A' B' B''" by blast
    }
    {
      assume "X = y ∧ X Midpoint B'' A ∧ X ≠ y ∧ A' B' ReflectL X y"
      hence "Per A' B' B''" by blast
    }
    {
      assume "X = y ∧ X Midpoint B'' A ∧ X = y ∧ X Midpoint B' A'"
      hence "Per A' B' B''"
        using P32 by blast
    }
    thus ?thesis using R1 R2
      using ‹(X ≠ y ∧ A B'' ReflectL X y ∧ X ≠ y ∧ A' B' ReflectL X y) 
    ⟹ Per A' B' B''› 
      by auto
  qed
  have "A' B' OS A B''"
  proof -
    {
      assume S1: "X y Perp A B''"
      have "Coplanar A y A' X"
        by (metis P28A P29 col_one_side coplanar_perm_16 ncop_distincts 
            os__coplanar)
      have "A' B' OS A y" 
        using P29 by blast 
      hence "Coplanar A' B' A y" 
        using os__coplanar by auto
      hence "Coplanar A y B' X"
        using P12 P28A col2_cop__cop col_trivial_2 ncoplanar_perm_16 by blast
      have S2: "¬ Col A X y"
        using Col_perm P34A S1 local.image_id perp_distinct by blast
      have "A' B' Par A B''"
      proof -
        have "Coplanar X y A' A"
          using ‹Coplanar A y A' X› ncoplanar_perm_21 by blast
        moreover have "Coplanar X y A' B''"
        proof -
          have "Coplanar A X y A'"
            using ‹Coplanar X y A' A› ncoplanar_perm_9 by blast
          moreover  have "Coplanar A X y B''"
            using Coplanar_def S1 perp_inter_exists by blast
          ultimately show ?thesis
            using S2 coplanar_trans_1 by auto
        qed
        moreover have "Coplanar X y B' A"
        proof -
          have "¬ Col A X y"
            by (simp add: S2)
          moreover have "Coplanar A X y B'"
            using ‹Coplanar A y B' X› ncoplanar_perm_3 by blast
          moreover have "Coplanar A X y B''"
            using Coplanar_def S1 perp_inter_exists by blast
          ultimately show ?thesis
            using ncoplanar_perm_18 by blast
        qed
        moreover have "Coplanar X y B' B''"
        proof -
          have "¬ Col A X y"
            by (simp add: S2)
          moreover have "Coplanar A X y B'"
            using ‹Coplanar X y B' A› ncoplanar_perm_9 by blast
          moreover have "Coplanar A X y B''"
            using Coplanar_def S1 perp_inter_exists by blast
          ultimately show ?thesis
            using coplanar_trans_1 by blast
        qed
        ultimately show ?thesis using l12_9
          using P29 Perp_cases S1 by blast
      qed
      have "A' B' OS A B''"
      proof -
        {
          assume "A' B' ParStrict A B''"
          have "A' B' OS A B''" using l12_6
            using ‹A' B' ParStrict A B''› by blast
        }
        {
          assume "A' ≠ B' ∧ A ≠ B'' ∧ Col A' A B'' ∧ Col B' A B''"
          have "A' B' OS A B''"
            using P26 ‹A' B' Par A B''› 
              ‹A' B' ParStrict A B'' ⟹ A' B' OS A B''› 
              col_trivial_3 par_not_col_strict by blast
        }
        thus ?thesis
          using Par_def ‹A' B' Par A B''› 
            ‹A' B' ParStrict A B'' ⟹ A' B' OS A B''› 
          by auto
      qed
    }
    {
      assume "A = B''"
      hence "A' B' OS A B''"
        using P12 P25 ‹Per A' B' B''› l8_2 l8_7 by blast
    }
    thus ?thesis
      using P30 ‹X y Perp A B'' ⟹ A' B' OS A B''› by blast
  qed
  have "A' B' OS A B"
  proof -
    have "A' B' TS A C"
    proof -
      have "¬ Col A A' B'"
        using Col_perm ‹¬ Col B' A' A› by blast
      moreover have "¬ Col C A' B'"
        by (metis P13 P14 P2A ‹¬ Col B' A' A› col3 not_col_distincts 
            not_col_permutation_3 not_col_permutation_4)
      moreover have "∃ T. Col T A' B' ∧ Bet A T C"
        using P14 assms(3) midpoint_bet not_col_permutation_1 by blast
      ultimately show ?thesis
        by (simp add: TS_def)
    qed
    moreover have "A' B' TS B C"
      by (metis Col_cases P13 TS_def ‹¬ Col A' B' B› assms(2) 
          calculation midpoint_bet)
    ultimately show ?thesis
      using OS_def by blast
  qed
  have "Col B B'' B'"
  proof -
    have "Coplanar A' B B'' B'"
    proof -
      have "Coplanar A' B' B B''"
      proof -
        have "¬ Col A A' B'"
          using Col_perm ‹¬ Col B' A' A› by blast
        moreover have "Coplanar A A' B' B"
          using ‹A' B' OS A B› ncoplanar_perm_8 os__coplanar by blast
        moreover have "Coplanar A A' B' B''"
          using ‹A' B' OS A B''› ncoplanar_perm_8 os__coplanar by blast
        ultimately show ?thesis
          using coplanar_trans_1 by blast
      qed
      thus ?thesis
        using ncoplanar_perm_4 by blast
    qed
    moreover have "A' ≠ B'"
      by (simp add: P12)
    moreover have "Per B B' A'"
      by (simp add: P24 l8_2)
    moreover have "Per B'' B' A'"
      using Per_cases ‹Per A' B' B''› by auto
    ultimately show ?thesis
      using cop_per2__col by blast
  qed
  have "Cong B B' A A'"
    using P6 P7 cong_inner_transitivity by blast
  have "B = B'' ∨ B' Midpoint B B''"
  proof -
    have "Col B B' B''"
      using ‹Col B B'' B'› not_col_permutation_5 by blast
    moreover have "Cong B' B B' B''"
      by (metis Cong_perm P35 P6 P7 cong_inner_transitivity)
    ultimately show ?thesis
      using l7_20 by simp
  qed
  {
    assume "B = B''"
    then obtain M where S1: "Col X y M ∧ M Midpoint A B"
      using P30 by blast
    hence "R = M"
      using assms(4) l7_17 by auto
    have "A ≠ B"
      using assms(1) col_trivial_1 by auto
    have "Col R A B"
      by (simp add: assms(4) midpoint_col)
    have "X ≠ R"
      using Midpoint_def P28 ‹A' B' OS A B''› ‹B = B''› assms(4) 
        midpoint_col one_side_chara by auto
    hence "∃ X Y. (R PerpAt X Y A B ∧ X Y Perp P Q ∧ 
    Coplanar A B C X ∧ Coplanar A B C Y)"
    proof -
      have "R PerpAt R X A B"
      proof -
        have "R X Perp A B"
          using P30 S1 ‹A ≠ B› ‹B = B''› ‹R = M› ‹X ≠ R› 
            perp_col perp_left_comm by blast
        thus ?thesis
          using ‹Col R A B› l8_14_2_1b_bis not_col_distincts by blast
      qed
      moreover have "R X Perp P Q"
      proof -
        have "X R Perp P Q"
        proof -
          have "X y Perp P Q"
          proof -
            have "P Q Perp X y"
              using P11 P13 P14 P29 P33A col_trivial_2 col_trivial_3 
                perp_col4 by blast
            thus ?thesis
              using Perp_perm by blast
          qed
          moreover have "Col X y R"
            by (simp add: S1 ‹R = M›)
          ultimately show ?thesis
            using ‹X ≠ R› perp_col by blast
        qed
        thus ?thesis
          using Perp_perm by blast
      qed
      moreover have "Coplanar A B C R"
        using ‹Col R A B› ncop__ncols not_col_permutation_2 by blast
      moreover have "Coplanar A B C X"
      proof -
        have "Col P Q X"
          using P12 P13 P14 P28A col3 by blast
        moreover  have "¬ Col P Q C"
          by (simp add: P2A)
        moreover have "Coplanar P Q C A"
          using assms(3) coplanar_perm_19 midpoint__coplanar by blast
        moreover have "Coplanar P Q C B"
          using assms(2) midpoint_col ncop__ncols 
            not_col_permutation_5 by blast
        moreover have "Coplanar P Q C C"
          using ncop_distincts by auto
        moreover have "Coplanar P Q C X"
          using calculation(1) ncop__ncols by blast
        ultimately show ?thesis
          using coplanar_pseudo_trans by blast
      qed
      ultimately show ?thesis by blast
    qed
  }
  {
    assume "B' Midpoint B B''"
    have "A' B' TS B B''"
    proof -
      have "¬ Col B A' B'"
        using Col_perm ‹¬ Col A' B' B› by blast
      moreover have "¬ Col B'' A' B'"
        using ‹A' B' OS A B''› col124__nos not_col_permutation_2 by blast
      moreover have "∃ T. Col T A' B' ∧ Bet B T B''"
        using ‹B' Midpoint B B''› col_trivial_3 midpoint_bet by blast
      ultimately show ?thesis
        by (simp add: TS_def)
    qed
    have "A' B' OS B B''"
      using ‹A' B' OS A B''› ‹A' B' OS A B› one_side_symmetry 
        one_side_transitivity by blast
    have "¬ A' B' OS B B''"
      using ‹A' B' TS B B''› l9_9_bis by blast
    hence "False"
      by (simp add: ‹A' B' OS B B''›)
    hence "∃ X Y. (R PerpAt X Y A B ∧ X Y Perp P Q ∧ 
    Coplanar A B C X ∧ Coplanar A B C Y)"
      by auto
  }
  thus ?thesis
    using ‹B = B'' ⟹ ∃X Y. R PerpAt X Y A B ∧ X Y Perp P Q ∧ 
    Coplanar A B C X ∧ Coplanar A B C Y› 
      ‹B = B'' ∨ B' Midpoint B B''› by blast
qed

lemma l13_1:
  assumes "¬ Col A B C" and
    "P Midpoint B C" and
    "Q Midpoint A C" and
    "R Midpoint A B"
  shows
    "∃ X Y.(R PerpAt X Y A B ∧ X Y Perp P Q)"
proof -
  obtain X Y where "R PerpAt X Y A B" and "X Y Perp P Q" and
    "Coplanar A B C X" and "Coplanar A B C Y"
    using l13_1_aux assms(1) assms(2) assms(3) assms(4) by blast
  thus ?thesis by blast
qed

lemma per_lt:
  assumes "A ≠ B" and
    "C ≠ B" and
    "Per A B C"
  shows "A B Lt A C ∧ C B Lt A C"
proof -
  have "B A Lt A C ∧ B C Lt A C"
    using assms(1) assms(2) assms(3) l11_46 by auto
  thus ?thesis
    using lt_left_comm by blast
qed

lemma cong_perp_conga:
  assumes "Cong A B C B" and
    "A C Perp B P"
  shows "A B P CongA C B P ∧ B P TS A C"
proof -
  have P1: "A ≠ C"
    using assms(2) perp_distinct by auto
  have P2: "B ≠ P"
    using assms(2) perp_distinct by auto
  have P3: "A ≠ B"
    by (metis P1 assms(1) cong_diff_3)
  have P4: "C ≠ B"
    using P3 assms(1) cong_diff by blast
  show ?thesis
  proof cases
    assume P5: "Col A B C"
    have P6: "¬ Col B A P"
      using P3 P5 assms(2) col_transitivity_1 not_col_permutation_4 
        not_col_permutation_5 perp_not_col2 by blast
    have "Per P B A"
      using P3 P5 Perp_perm assms(2) not_col_permutation_5 perp_col1 perp_per_1 by blast
    hence P8: "Per A B P"
      using Per_cases by blast
    have "Per P B C"
      using P3 P5 P8 col_per2__per l8_2 l8_5 by blast
    hence P10: "Per C B P"
      using Per_perm by blast
    show ?thesis
    proof -
      have "A B P CongA C B P"
        using P2 P3 P4 P8 P10 l11_16 by auto
      moreover have "B P TS A C"
        by (metis Col_cases P1 P5 P6 assms(1) bet__ts between_cong 
            not_cong_2143 not_cong_4321 third_point)
      ultimately show ?thesis
        by simp
    qed
  next
    assume T1: "¬ Col A B C"
    obtain T where T2: "T PerpAt A C B P"
      using assms(2) perp_inter_perp_in by blast
    hence T3: "Col A C T ∧ Col B P T"
      using perp_in_col by auto
    have T4: "B ≠ T"
      using Col_perm T1 T3 by blast
    have T5: "B T Perp A C"
      using Perp_cases T3 T4 assms(2) perp_col1 by blast
    {
      assume T5_1: "A = T"
      have "B A Lt B C ∧ C A Lt B C"
      proof -
        have "B ≠ A"
          using P3 by auto
        moreover have "C ≠ A"
          using P1 by auto
        moreover have "Per B A C"
          using T5 T5_1 perp_comm perp_per_1 by blast
        ultimately show ?thesis
          by (simp add: per_lt)
      qed
      hence "False"
        using Cong_perm assms(1) cong__nlt by blast
    }
    hence T6: "A ≠ T" by auto
    {
      assume T6_1: "C = T"
      have "B C Lt B A ∧ A C Lt B A"
      proof -
        have "B ≠ C"
          using P4 by auto
        moreover have "A ≠ C"
          by (simp add: P1)
        moreover have "Per B C A"
          using T5 T6_1 perp_left_comm perp_per_1 by blast
        ultimately show ?thesis
          by (simp add: per_lt)
      qed
      hence "False"
        using Cong_perm assms(1) cong__nlt by blast
    }
    hence T7: "C ≠ T" by auto
    have T8: "T PerpAt B T T A"
      by (metis Perp_in_cases T2 T3 T4 T6 perp_in_col_perp_in)
    have T9: "T PerpAt B T T C"
      by (metis Col_cases T3 T7 T8 perp_in_col_perp_in)
    have T10: "Cong T A T C ∧ T A B CongA T C B ∧ T B A CongA T B C"
    proof -
      have "A T B CongA C T B"
      proof -
        have "Per A T B"
          using T2 perp_in_per_1 by auto
        moreover have "Per C T B"
          using T2 perp_in_per_3 by auto
        ultimately show ?thesis
          by (simp add: T4 T6 T7 l11_16)
      qed
      moreover have "Cong A B C B"
        by (simp add: assms(1))
      moreover have "Cong T B T B"
        by (simp add: cong_reflexivity)
      moreover have "T B Le A B"
      proof -
        have "Per B T A"
          using T8 perp_in_per by auto
        hence "B T Lt B A ∧ A T Lt B A"
          using T4 T6 per_lt by blast
        thus ?thesis
          using Le_cases Lt_def by blast
      qed
      ultimately show ?thesis
        using l11_52 by blast
    qed
    show ?thesis
    proof -
      have T11: "A B P CongA C B P"
      proof -
        have "P B A CongA P B C"
          using Col_cases P2 T10 T3 col_conga__conga by blast
        thus ?thesis
          using conga_comm by blast
      qed
      moreover have "B P TS A C"
      proof -
        have T12: "A = C ∨ T Midpoint A C"
          using T10 T3 l7_20_bis not_col_permutation_5 by blast
        {
          assume "T Midpoint A C"
          hence "B P TS A C" 
            by (metis (mono_tags, opaque_lifting) T2 T3 l8_14_2_1b l9_18 
                ‹A = T ⟹ False› ‹C = T ⟹ False› 
                col_trivial_1 midpoint_bet not_col_permutation_1)
        }
        thus ?thesis
          using P1 T12 by auto
      qed
      ultimately show ?thesis
        by simp
    qed
  qed
qed

lemma perp_per_bet:
  assumes "¬ Col A B C" and
    (*  "Col A P C" and *)
    "Per A B C" and
    "P PerpAt P B A C"
  shows "Bet A P C"
proof -
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto
  thus ?thesis
    using assms(2) assms(3) l11_47 perp_in_left_comm by blast
qed

lemma ts_per_per_ts:
  assumes "A B TS C D" and
    "Per B C A" and
    "Per B D A"
  shows "C D TS A B"
proof -
  have P1: "¬ Col C A B"
    using TS_def assms(1) by blast
  have P2: "A ≠ B"
    using P1 col_trivial_2 by auto
  obtain P where P3: "Col P A B ∧ Bet C P D"
    using TS_def assms(1) by blast
  have P4: "C ≠ D"
    using assms(1) not_two_sides_id by auto
  show ?thesis
  proof -
    {
      assume "Col A C D"
      hence "C = D"
        by (metis assms(1) assms(2) assms(3) col_per2_cases col_permutation_2 not_col_distincts ts_distincts)
      hence "False"
        using P4 by auto
    }
    hence "¬ Col A C D" by auto
    moreover have "¬ Col B C D"
      using assms(1) assms(2) assms(3) per2_preserves_diff ts_distincts by blast
    moreover have "∃ T. Col T C D ∧ Bet A T B"
    proof -
      have "Col P C D"
        using Col_def Col_perm P3 by blast
      moreover have "Bet A P B"
      proof -
        have "∃ X. Col A B X ∧ A B Perp C X"
          using Col_perm P1 l8_18_existence by blast
        then obtain C' where P5: "Col A B C' ∧ A B Perp C C'" by blast
        have "∃ X. Col A B X ∧ A B Perp D X"
          by (metis (no_types) Col_perm TS_def assms(1) l8_18_existence)
        then obtain D' where P6: "Col A B D' ∧ A B Perp D D'" by blast
        have P7: "A ≠ C'"
          using P5 assms(2) l8_7 perp_not_eq_2 perp_per_1 by blast
        have P8: "A ≠ D'"
          using P6 assms(3) l8_7 perp_not_eq_2 perp_per_1 by blast
        have P9: "Bet A C' B"
        proof -
          have "¬ Col A C B"
            using Col_cases P1 by blast
          moreover have "Per A C B"
            by (simp add: assms(2) l8_2)
          moreover have "C' PerpAt C' C A B"
            using P5 Perp_in_perm l8_15_1 by blast
          ultimately show ?thesis
            using perp_per_bet by blast
        qed
        have P10: "Bet A D' B"
        proof -
          have "¬ Col A D B"
            using P6 col_permutation_5 perp_not_col2 by blast
          moreover have "Per A D B"
            by (simp add: assms(3) l8_2)
          moreover have "D' PerpAt D' D A B"
            using P6 Perp_in_perm l8_15_1 by blast
          ultimately show ?thesis
            using perp_per_bet by blast
        qed
        show ?thesis
        proof cases
          assume "P = C'"
          thus ?thesis
            by (simp add: P9)
        next
          assume "P ≠ C'"
          show ?thesis
          proof cases
            assume "P = D'"
            thus ?thesis
              by (simp add: P10)
          next
            assume "P ≠ D'"
            show ?thesis
            proof cases
              assume "A = P"
              thus ?thesis
                by (simp add: between_trivial2)
            next
              assume "A ≠ P"
              show ?thesis
              proof cases
                assume "B = P"
                thus ?thesis
                  using between_trivial by auto
              next
                assume "B ≠ P"
                have "Bet C' P D'"
                proof -
                  have "Bet C P D"
                    by (simp add: P3)
                  moreover have "P ≠ C'"
                    by (simp add: ‹P ≠ C'›)
                  moreover have "P ≠ D'"
                    by (simp add: ‹P ≠ D'›)
                  moreover have "Col C' P D'"
                    by (meson P2 P3 P5 P6 col3 col_permutation_2)
                  moreover have "Per P C' C"
                    using P3 P5 l8_16_1 l8_2 not_col_permutation_3 not_col_permutation_4 by blast
                  moreover have "Per P D' D"
                    by (metis P3 P6 calculation(3) not_col_permutation_2 perp_col2 perp_per_1)
                  ultimately show ?thesis
                    using per13_preserves_bet by blast
                qed
                thus ?thesis
                  using P10 P9 bet3__bet by blast
              qed
            qed
          qed
        qed
      qed
      ultimately show ?thesis
        by auto
    qed
    ultimately show ?thesis
      by (simp add: TS_def)
  qed
qed

lemma l13_2_1:
  assumes "A B TS C D" and
    "Per B C A" and
    "Per B D A" and
    "Col C D E" and
    "A E Perp C D" and
    "C A B CongA D A B"
  shows "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D"
proof -
  have P1: "¬ Col C A B"
    using TS_def assms(1) by auto
  have P2: "A ≠ C"
    using P1 col_trivial_1 by blast
  have P3: "A ≠ B"
    using P1 col_trivial_2 by auto
  have P4: "A ≠ D"
    using assms(1) ts_distincts by auto
  have P5: "Cong B C B D ∧ Cong A C A D ∧ C B A CongA D B A"
  proof -
    have "¬ Col B A C"
      by (simp add: P1 not_col_permutation_3)
    moreover have "A C B CongA A D B"
      using assms(1) assms(2) assms(3) l11_16 l8_2 ts_distincts by blast
    moreover have "B A C CongA B A D"
      by (simp add: assms(6) conga_comm)
    moreover have "Cong B A B A"
      by (simp add: cong_reflexivity)
    ultimately show ?thesis
      using l11_50_2 by blast
  qed
  hence P6: "C D Perp A B"
    using assms(1) assms(6) cong_conga_perp not_cong_2143 by blast
  hence P7: "C D TS A B"
    by (simp add: assms(1) assms(2) assms(3) ts_per_per_ts)
  obtain T1 where P8: "Col T1 C D ∧ Bet A T1 B"
    using P7 TS_def by auto
  obtain T where P9: "Col T A B ∧ Bet C T D"
    using TS_def assms(1) by blast
  have P10: "T1 = T"
    by (metis (no_types) Col_def P1 P3 P8 P9 between_equality_2 between_trivial2 l6_16_1)
  have P11: "T = E"
  proof -
    have "¬ Col A B C"
      using Col_perm P1 by blast
    moreover have "C ≠ D"
      using assms(1) ts_distincts by blast
    moreover have "Col A B T"
      using Col_cases P9 by auto
    moreover have "Col A B E"
      by (metis P7 Perp_cases P6 assms(1) assms(5) col_perp2_ncol_col 
          col_trivial_3 not_col_permutation_3 one_side_not_col123 os_ts1324__os ts_ts_os)
    moreover have "Col C D T"
      using NCol_cases P9 bet_col by blast
    moreover have "Col C D E"
      by (simp add: assms(4))
    ultimately show ?thesis
      using l6_21 by blast
  qed
  show ?thesis
  proof -
    have "B A C CongA D A E"
    proof -
      have "A Out C C"
        using P2 out_trivial by auto
      moreover have "A Out B B"
        using P3 out_trivial by auto
      moreover have "A Out D D"
        using P4 out_trivial by auto
      moreover have "A Out E B"
        by (metis P10 P11 P7 P8 TS_def bet_out)
      ultimately show ?thesis
        by (meson assms(6) conga_comm conga_right_comm l11_10)
    qed
    moreover have "B A D CongA C A E"
    proof -
      have "C A E CongA D A B"
        by (meson Perp_cases P5 assms(5) assms(6) calculation cong_perp_conga 
            conga_right_comm conga_trans not_cong_2143 not_conga_sym)
      hence "C A E CongA B A D"
        by (simp add: conga_right_comm)
      thus ?thesis
        by (simp add: conga_sym)
    qed
    moreover have "Bet C E D"
      using P11 P9 by auto
    ultimately show ?thesis by simp
  qed
qed

lemma triangle_mid_par_lem:
  assumes "¬ Col A B C" and
    "P Midpoint B C" and
    "Q Midpoint A C"
  shows "A B Par P Q" 
proof -
  obtain R where "R Midpoint A B"
    using midpoint_existence by auto
  then obtain X Y where "R PerpAt X Y A B" and "X Y Perp P Q" and
    "Coplanar A B C X" and "Coplanar A B C Y"
    using l13_1_aux assms(1) assms(2) assms(3) by blast
  have "Coplanar A B C A"
    using ncop_distincts by auto
  have "Coplanar A B C B"
    using ncop_distincts by auto
  have "Coplanar A B C P"
    using assms(2) coplanar_perm_21 midpoint__coplanar by blast
  have "Coplanar A B C Q"
    using assms(3) coplanar_perm_11 midpoint__coplanar by blast
  have "Coplanar X Y A P" 
    using ‹Coplanar A B C A› ‹Coplanar A B C P› ‹Coplanar A B C X› 
      ‹Coplanar A B C Y› assms(1) coplanar_pseudo_trans by blast
  moreover have "Coplanar X Y A Q" 
    using ‹Coplanar A B C A› ‹Coplanar A B C Q› ‹Coplanar A B C X› 
      ‹Coplanar A B C Y› assms(1) coplanar_pseudo_trans by blast
  moreover have "Coplanar X Y B P" 
    using ‹Coplanar A B C B› ‹Coplanar A B C P› ‹Coplanar A B C X› 
      ‹Coplanar A B C Y› assms(1) coplanar_pseudo_trans by blast
  moreover have "Coplanar X Y B Q" 
    using ‹Coplanar A B C B› ‹Coplanar A B C Q› ‹Coplanar A B C X› 
      ‹Coplanar A B C Y› assms(1) coplanar_pseudo_trans by presburger
  moreover have "Col X Y R" and "Col A B R"
    using perp_in_col ‹R PerpAt X Y A B› perp_in_col by auto
  hence "Col X R Y"  
    using Col_perm by blast
  hence "X Y Perp A B"
    using perp_col ‹R PerpAt X Y A B› perp_in_perp by auto
  ultimately show ?thesis
    by (meson Perp_cases ‹X Y Perp P Q› l12_9)
qed

lemma triangle_mid_par:
  assumes "¬ Col A B C" and
    "P Midpoint B C" and
    "Q Midpoint A C"
  shows "A B ParStrict Q P" 
proof -
  have "A B Par P Q"
    using assms(1) assms(2) assms(3) triangle_mid_par_lem by blast
  hence "A B Par Q P" 
    using Par_cases by blast
  thus ?thesis 
    by (metis assms(1) assms(3) col_transitivity_2 midpoint_col midpoint_distinct_3 
        not_col_distincts par_not_col_strict)
qed

lemma cop4_perp_in2__col:
  assumes "Coplanar X Y A A'" and
    "Coplanar X Y A B'" and
    "Coplanar X Y B A'" and
    "Coplanar X Y B B'" and
    "P PerpAt A B X Y" and
    "P PerpAt A' B' X Y"
  shows "Col A B A'"
proof -
  have P1: "Col A B P ∧ Col X Y P"
    using assms(5) perp_in_col by auto
  show ?thesis
  proof cases
    assume P2: "A = P"
    show ?thesis
    proof cases
      assume P3: "P = X"
      have "Col B A' P"
      proof -
        have "Coplanar Y B A' P"
          using P3 assms(3) ncoplanar_perm_18 by blast
        moreover have "Y ≠ P"
          using P3 assms(6) perp_in_distinct by blast
        moreover have "Per B P Y"
          using assms(5) perp_in_per_4 by auto
        moreover have "Per A' P Y"
          using assms(6) perp_in_per_2 by auto
        ultimately show ?thesis
          using cop_per2__col by auto
      qed
      thus ?thesis
        using Col_perm P2 by blast
    next
      assume P4: "P ≠ X"
      have "Col B A' P"
      proof -
        have "Coplanar X B A' P"
          by (metis P1 assms(3) assms(6) col2_cop__cop col_trivial_3 
              ncoplanar_perm_9 perp_in_distinct)
        moreover have "Per B P X"
          using assms(5) perp_in_per_3 by auto
        moreover have "Per A' P X"
          using assms(6) perp_in_per_1 by auto
        ultimately show ?thesis
          using cop_per2__col P4 by auto
      qed
      thus ?thesis
        using Col_perm P2 by blast
    qed
  next
    assume P5: "A ≠ P"
    have P6: "Per A P Y"
      using assms(5) perp_in_per_2 by auto
    show ?thesis
    proof cases
      assume P7: "P = A'"
      have P8: "Per B' P Y"
        using assms(6) perp_in_per_4 by auto
      have "Col A B' P"
      proof -
        have "Coplanar Y A B' P"
          using assms(2) by (metis P1 assms(6) col_transitivity_2 coplanar_trans_1 
              ncop__ncols perp_in_distinct)
        thus ?thesis using P6 P8 cop_per2__col
          by (metis assms(2) assms(5) assms(6) col_permutation_4 coplanar_perm_5 
              perp_in_distinct perp_in_per_1 perp_in_per_3)
      qed
      thus ?thesis
        using P1 P7 by auto
    next
      assume T1: "P ≠ A'"
      show ?thesis
      proof cases
        assume T2: "Y = P"
        {
          assume R1: "Coplanar X P A A' ∧ P PerpAt A B X P ∧ P PerpAt A' B' X P ∧ A ≠ P"
          hence R2: "Per A P X"
            using perp_in_per_1 by auto
          have "Per A' P X"
            using R1 perp_in_per_1 by auto
          hence "Col A B A'"
            by (metis R1 R2 PerpAt_def col_permutation_3 col_transitivity_2 
                cop_per2__col ncoplanar_perm_5)
        }
        thus ?thesis
          using P5 T1 T2 assms(1) assms(2) assms(3) assms(4) assms(5) 
            assms(6) by blast
      next
        assume P10: "Y ≠ P"
        have "Col A A' P"
        proof -
          have "Coplanar Y A A' P"
            by (metis P1 assms(1) assms(6) col2_cop__cop col_trivial_2 
                ncoplanar_perm_9 perp_in_distinct)
          moreover have "Per A P Y"
            by (simp add: P6)
          moreover  have "Per A' P Y"
            using assms(6) perp_in_per_2 by auto
          ultimately show ?thesis
            using cop_per2__col P10 by auto
        qed
        thus ?thesis
          using P1 P5 col2__eq col_permutation_4 by blast
      qed
    qed
  qed
qed

lemma l13_2:
  assumes "A B TS C D" and
    "Per B C A" and
    "Per B D A" and
    "Col C D E" and
    "A E Perp C D"
  shows "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D"
proof -
  have P2: "¬ Col C A B"
    using TS_def assms(1) by auto
  have P3: "C ≠ D"
    using assms(1) not_two_sides_id by blast
  have P4: "∃ C'. B A C CongA D A C' ∧ D A OS C' B"
  proof -
    have "¬ Col B A C"
      using Col_cases P2 by auto
    moreover have "¬ Col D A B"
      using TS_def assms(1) by blast
    ultimately show ?thesis
      by (simp add: angle_construction_1)
  qed
  then obtain E' where P5: "B A C CongA D A E' ∧ D A OS E' B" by blast
  have P6: "A ≠ B"
    using P2 not_col_distincts by blast
  have P7: "A ≠ C"
    using P2 not_col_distincts by blast
  have P8: "A ≠ D"
    using P5 os_distincts by blast
  have P9: "((A B TS C E' ∧ A E' TS D B) ∨ 
  (A B OS C E' ∧ A E' OS D B ∧ C A B CongA D A E' ∧ B A E' CongA E' A B)) 
  ⟶ C A E' CongA D A B"
    by (metis P5 P6 conga_diff56 conga_left_comm conga_pseudo_refl l11_22)
  have P10: "C D TS A B"
    by (simp add: assms(1) assms(2) assms(3) ts_per_per_ts)
  have P11: "¬ Col A C D"
    using P10 TS_def by auto
  obtain T where P12: "Col T A B ∧ Bet C T D"
    using TS_def assms(1) by blast
  obtain T2 where P13: "Col T2 C D ∧ Bet A T2 B"
    using P10 TS_def by auto
  hence P14: "T = T2"
    by (metis Col_def Col_perm P12 P2 P3 P6 l6_16_1)
  have P15: "B InAngle D A C"
    using P10 assms(1) l11_24 ts2__inangle by blast
  have P16: "C A B LeA C A D"
    by (simp add: P10 assms(1) inangle__lea ts2__inangle)
  have P17: "E' InAngle D A C"
  proof -
    have "D A E' LeA D A C"
      using P16 P5 P7 P8 conga_left_comm conga_pseudo_refl l11_30 by presburger
    moreover have "D A OS C E'"
      by (meson P11 P15 P5 col124__nos in_angle_one_side invert_one_side 
          not_col_permutation_2 one_side_symmetry one_side_transitivity)
    ultimately show ?thesis
      by (simp add: lea_in_angle)
  qed
  obtain E'' where P18: "Bet D E'' C ∧ (E'' = A ∨ A Out E'' E')"
    using InAngle_def P17 by auto
  {
    assume "E'' = A"
    hence "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D"
      using Col_def P11 P18 by auto
  }
  {
    assume P19: "A Out E'' E'"
    hence P20: "B A C CongA D A E''"
      by (meson OS_def P5 out2__conga Tarski_neutral_dimensionless_axioms 
          col_one_side_out col_trivial_2 l9_18_R1 not_conga one_side_reflexivity)
    have P21: "A ≠ T"
      using P11 P13 P14 by auto
    have "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D"
    proof cases
      assume P22: "E'' = T"
      have P23: "C A B CongA D A B"
      proof -
        have "C A B CongA D A T"
          using P22 P20 conga_left_comm by blast
        moreover have "A Out C C"
          using P7 out_trivial by presburger
        moreover have "A Out B B"
          using P6 out_trivial by auto
        moreover have "A Out D D"
          using P8 out_trivial by auto
        moreover have "A Out B T"
          using Out_def P13 P14 P6 P21 by blast
        ultimately show ?thesis
          using l11_10 by blast
      qed
      thus ?thesis
        using assms(1) assms(2) assms(3) assms(4) assms(5) l13_2_1 by blast
    next
      assume P23A: "E'' ≠ T"
      have P24: "D ≠ E''"
        using P2 P20 col_trivial_3 ncol_conga_ncol not_col_permutation_3 by blast
      {
        assume P24A: "C = E''"
        have P24B: "C A OS B D"
          by (meson P10 assms(1) invert_one_side ts_ts_os)
        have P24C: "A Out B D"
        proof -
          have "C A B CongA C A D"
            using P20 P24A conga_comm by blast
          moreover have "C A OS B D"
            by (simp add: P24B)
          ultimately show ?thesis
            using conga_os__out by blast
        qed
        hence "False"
          using Col_def P5 one_side_not_col124 out_col by blast
      }
      hence P25: "C ≠ E''" by auto
      have P26: "A ≠ E''"
        using P19 out_diff1 by auto
      {
        assume "Col E'' A B"
        hence "E'' = T" 
          by (metis P13 P14 P18 P2 P3 bet_col l6_21 not_col_permutation_3 not_col_permutation_4)
        hence "False"
          using P23A by auto
      }
      hence P27: "¬ Col E'' A B" by auto
      have "(A B TS C E'' ∧ A E'' TS D B) ∨ 
    (A B OS C E'' ∧ A E'' OS D B ∧ C A B CongA D A E'' ∧ B A E'' CongA E'' A B)"
      proof cases
        assume P27_0: "A B OS C E''"
        have "A E'' OS D B"
        proof -
          have P27_1: "A E'' TS D C"
            by (metis Col_def P10 P18 P24 TS_def P25 bet__ts invert_two_sides l6_16_1)
          moreover have "A E'' TS B C"
          proof -
            have "A E'' TS T C"
            proof -
              have "¬ Col T A E''"
                by (metis NCol_cases P13 P14 P21 P27 bet_col col3 col_trivial_2)
              moreover have "¬ Col C A E''"
                using P27_1 TS_def by auto
              moreover have "∃ T0. (Col T0 A E'' ∧ Bet T T0 C)"
                by (meson P12 P18 P27_0 between_symmetry col_trivial_3 l5_3 one_side_chara)
              ultimately show ?thesis
                by (simp add: TS_def)
            qed
            moreover have "A Out T B"
              using Out_def P13 P14 P21 P6 by auto
            ultimately show ?thesis
              using col_trivial_1 l9_5 by blast
          qed
          ultimately show ?thesis
            using OS_def by auto
        qed
        thus ?thesis
          using P20 P27_0 conga_distinct conga_left_comm conga_pseudo_refl by blast
      next
        assume P27_2: "¬ A B OS C E''"
        show ?thesis
        proof -
          have P27_3: "A B TS C E''"
            using P18 P2 P27_2 P27 assms(1) bet_cop__cop between_symmetry 
              cop_nos__ts ts__coplanar by blast
          moreover have "A E'' TS D B"
          proof -
            have P27_3: "A B OS D E''"
              using P18 bet_ts__os between_symmetry calculation one_side_symmetry by blast
            have P27_4: "A E'' TS T D"
            proof -
              have "¬ Col T A E''"
                by (metis NCol_cases P13 P14 P21 P27 bet_col col3 col_trivial_2)
              moreover have "¬ Col D A E''" 
                by (metis P11 P18 P24 bet_col l6_16_1 not_col_permutation_2)
              moreover have "∃ T0. (Col T0 A E'' ∧ Bet T T0 D)"
                by (meson Bet_perm P12 P18 P27_3 bet_col1 bet_out__bet 
                    between_exchange3 col_trivial_3 not_bet_out one_side_chara)
              ultimately show ?thesis
                by (simp add: TS_def)
            qed
            have "A E'' TS B D"
            proof -
              have "A E'' TS T D"
                using P27_4 by simp
              moreover have "Col A A E''"
                using col_trivial_1 by auto
              moreover have "A Out T B"
                using P13 P14 P21 bet_out by auto
              ultimately show ?thesis
                using l9_5 by blast
            qed
            thus ?thesis
              by (simp add: l9_2)
          qed
          ultimately show ?thesis
            by simp
        qed
      qed
      hence P28: "C A E'' CongA D A B" using l11_22
        by (metis P20 P26 P6 conga_left_comm conga_pseudo_refl)
      obtain C' where P29: "Bet B C C' ∧ Cong C C' B C"
        using segment_construction by blast
      obtain D' where P30: "Bet B D D' ∧ Cong D D' B D"
        using segment_construction by blast
      have P31: "B A D Cong3 D' A D"
      proof -
        have "Per A D B"
          by (simp add: assms(3) l8_2)
        then obtain D'' where P31_2: "D Midpoint B D'' ∧ Cong A B A D''"
          using Per_def by auto
        have "D Midpoint B D'"
          using Cong_perm Midpoint_def P30 by blast
        hence "D' = D''"
          using P31_2 symmetric_point_uniqueness by auto
        thus ?thesis
          using Cong3_def Cong_perm P30 P31_2 cong_reflexivity by blast
      qed
      hence P32: "B A D CongA D' A D"
        using P6 P8 cong3_conga by auto
      have "B A C Cong3 C' A C"
      proof -
        obtain C'' where P33_1: "C Midpoint B C'' ∧ Cong A B A C''"
          using Per_def assms(2) l8_2 by blast
        have "C Midpoint B C'"
          using Cong_perm Midpoint_def P29 by blast
        hence "C' = C''"
          using P33_1 symmetric_point_uniqueness by auto
        thus ?thesis
          using Cong3_def Cong_perm P29 P33_1 cong_reflexivity by blast
      qed
      hence P34: "B A C CongA C' A C"
        using P6 P7 cong3_conga by auto
      have P35: "E'' A C' CongA D' A E''"
      proof -
        have "(A C TS E'' C' ∧ A D TS D' E'') ∨ (A C OS E'' C' ∧ A D OS D' E'')"
        proof -
          have P35_1: "C A OS D E''"
            by (metis Col_perm P11 P18 P25 bet_out between_symmetry 
                one_side_symmetry out_one_side)
          have P35_2: "C A OS B D"
            using P10 assms(1) one_side_symmetry ts_ts_os by blast
          have P35_3: "C A TS B C'"
            by (metis P2 P29 bet__ts cong_diff_4 not_col_distincts)
          have P35_4: "C A OS B E''"
            using P35_1 P35_2 one_side_transitivity by blast
          have P35_5: "D A OS C E''"
            by (metis Col_perm P18 P24 P35_1 bet2__out l5_1 one_side_not_col123 out_one_side)
          have P35_6: "D A OS B C"
            by (simp add: P10 assms(1) invert_two_sides l9_2 one_side_symmetry ts_ts_os)
          have P35_7: "D A TS B D'"
            by (metis P30 TS_def assms(1) bet__ts cong_diff_3 ts_distincts)
          have P35_8: "D A OS B E''"
            using P35_5 P35_6 one_side_transitivity by blast
          have P35_9: "A C TS E'' C'"
            using P35_3 P35_4 invert_two_sides l9_8_2 by blast
          have "A D TS D' E''"
            using P35_7 P35_8 invert_two_sides l9_2 l9_8_2 by blast
          thus ?thesis
            using P35_9 by simp
        qed
        moreover have "E'' A C CongA D' A D"
        proof -
          have "E'' A C CongA B A D"
            by (simp add: P28 conga_comm)
          moreover have "B A D CongA D' A D"
            by (simp add: P32)
          ultimately show ?thesis
            using conga_trans by blast
        qed
        moreover have "C A C' CongA D A E''"
        proof -
          have "D A E'' CongA C A C'"
          proof -
            have "D A E'' CongA B A C"
              by (simp add: P20 conga_sym)
            moreover have "B A C CongA C A C'"
              by (simp add: P34 conga_right_comm)
            ultimately show ?thesis
              using conga_trans by blast
          qed
          thus ?thesis
            using not_conga_sym by blast
        qed
        ultimately show ?thesis
          using l11_22 by auto
      qed
      have P36: "D' ≠ B"
        using P30 assms(1) bet_neq32__neq ts_distincts by blast
      have P37: "C' ≠ B"
        using P29 assms(1) bet_neq32__neq ts_distincts by blast
      hence P38: "¬ Col C' D' B"
        by (metis Col_def P10 P29 P30 P36 TS_def col_transitivity_2)
      have P39: "C' D' ParStrict C D"
      proof -
        have "¬ Col C' D' B"
          by (simp add: P38)
        moreover have "D Midpoint D' B"
          using P30 l7_2 midpoint_def not_cong_3412 by blast
        moreover have "C Midpoint C' B"
          using P29 l7_2 midpoint_def not_cong_3412 by blast
        ultimately show ?thesis
          using triangle_mid_par by auto
      qed
      have P40: "A E'' TS C D"
        by (metis Bet_perm Col_def P10 P18 P24 TS_def ‹C = E'' ⟹ False› 
            bet__ts col_transitivity_2 invert_two_sides)
      have P41: "B A TS C D"
        by (simp add: assms(1) invert_two_sides)
      have P42: "A B OS C C'"
      proof -
        have "¬ Col A B C"
          by (simp add: P2 not_col_permutation_1)
        moreover have "Col A B B"
          by (simp add: col_trivial_2)
        moreover have "B Out C C'"
          by (metis P29 P37 bet_out cong_identity)
        ultimately show ?thesis
          using out_one_side_1 by blast
      qed
      have P43: "A B OS D D'" using out_one_side_1
        by (metis Col_perm P30 TS_def assms(1) bet_out col_trivial_1)
      hence P44: "A B OS D D'" using invert_two_sides by blast
      have P45: "A B TS C' D"
        using P42 assms(1) l9_8_2 by blast
      hence P46: "A B TS C' D'"
        using P44 l9_2 l9_8_2 by blast
      have P47: "C' D' Perp A E''"
      proof -
        have "A E'' TS C' D'"
        proof -
          have "A Out C' D' ∨ E'' A TS C' D'"
          proof -
            have "E'' A C' CongA E'' A D'"
              by (simp add: P35 conga_right_comm)
            moreover have "Coplanar E'' A C' D'"
            proof -
              have f1: "B A OS C C'"
                by (metis P42 invert_one_side)
              have f2: "Coplanar B A C' C"
                by (meson P42 ncoplanar_perm_7 os__coplanar)
              have f3: "Coplanar D' A C' D"
                by (meson P44 P46 col124__nos coplanar_trans_1 invert_one_side 
                    ncoplanar_perm_7 os__coplanar ts__coplanar)
              have "Coplanar D' A C' C"
                using f2 f1 by (meson P46 col124__nos coplanar_trans_1 
                    ncoplanar_perm_6 ncoplanar_perm_8 ts__coplanar)
              thus ?thesis
                using f3 by (meson P18 bet_cop2__cop ncoplanar_perm_6 
                    ncoplanar_perm_7 ncoplanar_perm_8)
            qed
            ultimately show ?thesis using conga_cop__or_out_ts
              by simp
          qed
          thus ?thesis
            using P46 col_two_sides_bet invert_two_sides not_bet_and_out out_col by blast
        qed
        moreover have "Cong C' A D' A"
          using Cong3_def P31 ‹B A C Cong3 C' A C› cong_inner_transitivity by blast
        moreover have "C' A E'' CongA D' A E''"
          by (simp add: P35 conga_left_comm)
        ultimately show ?thesis
          by (simp add: cong_conga_perp)
      qed
      have T1: "Cong A C' A D'"
      proof -
        have "Cong A C' A B"
          using Cong3_def Cong_perm ‹B A C Cong3 C' A C› by blast
        moreover have "Cong A D' A B"
          using Cong3_def P31 not_cong_4321 by blast
        ultimately show ?thesis
          using Cong_perm ‹Cong A C' A B› ‹Cong A D' A B› cong_inner_transitivity by blast
      qed
      obtain R where T2: "R Midpoint C' D'"
        using midpoint_existence by auto
      have "∃ X Y. (R PerpAt X Y C' D' ∧ X Y Perp D C ∧ 
    Coplanar C' D' B X ∧ Coplanar C' D' B Y)"
      proof -
        have "¬ Col C' D' B"
          by (simp add: P38)
        moreover have "D Midpoint D' B"
          using P30 l7_2 midpoint_def not_cong_3412 by blast
        moreover have "C Midpoint C' B"
          using Cong_perm Mid_perm Midpoint_def P29 by blast
        moreover have "R Midpoint C' D'"
          by (simp add: T2)
        ultimately show ?thesis using l13_1_aux by blast
      qed
      then obtain X Y where T3: "R PerpAt X Y C' D' ∧ X Y Perp D C ∧ 
    Coplanar C' D' B X ∧ Coplanar C' D' B Y"
        by blast
      hence "X ≠ Y"
        using perp_not_eq_1 by blast
      have "C D Perp A E''"
      proof cases
        assume "A = R"
        hence W1: "A PerpAt C' D' A E''"
          using Col_def P47 T2 between_trivial2 l8_14_2_1b_bis midpoint_col by blast
        have "Coplanar B C' D' E''"
        proof -
          have "¬ Col B C D"
            using P10 TS_def by auto
          moreover have "Coplanar B C D B"
            using ncop_distincts by auto
          moreover have "Coplanar B C D C'"
            using P29 bet_col ncop__ncols by blast
          moreover have "Coplanar B C D D'"
            using P30 bet_col ncop__ncols by blast
          moreover have "Coplanar B C D E''"
            by (simp add: P18 bet__coplanar coplanar_perm_22)
          ultimately show ?thesis
            using coplanar_pseudo_trans by blast
        qed
        have "Coplanar C' D' X E''"
        proof -
          have "¬ Col B C' D'"
            by (simp add: P38 not_col_permutation_2)
          moreover have "Coplanar B C' D' X"
            using T3 ncoplanar_perm_8 by blast
          moreover have "Coplanar B C' D' E''"
            by (simp add: ‹Coplanar B C' D' E''›)
          ultimately show ?thesis
            using coplanar_trans_1 by blast
        qed
        have "Coplanar C' D' Y E''"
        proof -
          have "¬ Col B C' D'"
            by (simp add: P38 not_col_permutation_2)
          moreover have "Coplanar B C' D' Y"
            by (simp add: T3 coplanar_perm_12)
          moreover have "Coplanar B C' D' E''"
            by (simp add: ‹Coplanar B C' D' E''›)
          ultimately show ?thesis
            using coplanar_trans_1 by blast
        qed
        have "Coplanar C' D' X A"
        proof -
          have "Col C' D' A"
            using T2 ‹A = R› midpoint_col not_col_permutation_2 by blast
          moreover have "Col X A A"
            by (simp add: col_trivial_2)
          ultimately show ?thesis
            using ncop__ncols by blast
        qed
        have "Coplanar C' D' Y A"
        proof -
          have "Col C' D' A"
            using T2 ‹A = R› midpoint_col not_col_permutation_2 by blast
          moreover have "Col Y A A"
            by (simp add: col_trivial_2)
          ultimately show ?thesis
            using ncop__ncols by blast
        qed
        have "Col X Y A"
        proof -
          have "Coplanar C' D' X A"
            by (simp add: ‹Coplanar C' D' X A›)
          moreover have "Coplanar C' D' X E''"
            by (simp add: ‹Coplanar C' D' X E''›)
          moreover have "Coplanar C' D' Y A"
            by (simp add: ‹Coplanar C' D' Y A›)
          moreover have "Coplanar C' D' Y E''"
            by (simp add: ‹Coplanar C' D' Y E''›)
          moreover have "A PerpAt X Y C' D'"
            using T3 ‹A = R› Perp_in_cases by auto
          moreover have "A PerpAt A E'' C' D'"
            using Perp_in_cases ‹A PerpAt C' D' A E''› by blast
          ultimately show ?thesis
            using cop4_perp_in2__col by blast
        qed
        have "Col X Y E''"
        proof -
          have "Coplanar C' D' X E''"
            using ‹Coplanar C' D' X E''› by auto
          moreover have "Coplanar C' D' X A"
            by (simp add: ‹Coplanar C' D' X A›)
          moreover have "Coplanar C' D' Y E''"
            by (simp add: ‹Coplanar C' D' Y E''›)
          moreover have "Coplanar C' D' Y A"
            using ‹Coplanar C' D' Y A› by auto
          moreover have "A PerpAt X Y C' D'"
            using T3 ‹A = R› Perp_in_cases by auto
          moreover have "A PerpAt E'' A C' D'"
            using Perp_in_perm W1 by blast
          ultimately show ?thesis
            using cop4_perp_in2__col by blast
        qed
        have "A E'' Perp C D"
        proof cases
          assume "Y = A"
          show ?thesis
          proof -
            have "A ≠ E''"
              by (simp add: P26)
            moreover have "A X Perp C D"
              using T3 Perp_cases ‹Y = A› by blast
            moreover have "Col A X E''"
              using Col_perm ‹Col X Y E''› ‹Y = A› by blast
            ultimately show ?thesis
              using perp_col by blast
          qed
        next
          assume "Y ≠ A"
          show ?thesis
          proof -
            have "A ≠ E''"
              by (simp add: P26)
            moreover have "A Y Perp C D"
            proof -
              have "Y X Perp C D"
                using T3 by (simp add: perp_comm)
              hence "Y A Perp C D"
                using ‹Col X Y A› ‹Y ≠ A› col_trivial_2 perp_col2 perp_left_comm by blast
              thus ?thesis
                using Perp_cases by blast
            qed
            moreover have "Col A Y E''"
              using Col_perm ‹Col X Y A› ‹Col X Y E''› ‹X ≠ Y› col_transitivity_2 by blast
            ultimately show ?thesis
              using perp_col by blast
          qed
        qed
        thus ?thesis
          using Perp_perm by blast
      next
        assume "A ≠ R"
        have "R ≠ C'"
          using P46 T2 is_midpoint_id ts_distincts by blast
        have "Per A R C'" using T1 T2 Per_def by blast
        hence "R PerpAt A R R C'"
          by (simp add: ‹A ≠ R› ‹R ≠ C'› per_perp_in)
        hence "R PerpAt R C' A R"
          using Perp_in_perm by blast
        hence "R C' Perp A R ∨ R R Perp A R"
          using perp_in_perp by auto
        {
          assume "R C' Perp A R"
          hence "C' R Perp A R"
            by (simp add: ‹R C' Perp A R› Perp_perm)
          have "C' D' Perp R A"
            by (metis P47 T2 ‹A ≠ R› ‹Per A R C'› ‹R ≠ C'› col_per_perp 
                midpoint_col perp_distinct perp_right_comm)
          hence "R PerpAt C' D' R A"
            using T2 l8_14_2_1b_bis midpoint_col not_col_distincts by blast
          have "Col B D D'"
            by (simp add: Col_def P30)
          have "Col B C C'"
            using Col_def P29 by auto
          have "Col D E'' C"
            using P18 bet_col by auto
          have "Col R C' D'"
            using ‹R PerpAt C' D' R A› by (simp add: T2 midpoint_col)
          have "Col A E'' E'"
            by (simp add: P19 out_col)
          have "Coplanar C' D' X A"
          proof -
            have "¬ Col B C' D'"
              using Col_perm P38 by blast
            moreover have "Coplanar B C' D' X"
              using T3 ncoplanar_perm_8 by blast
            moreover have "Coplanar B C' D' A"
              using P46 ncoplanar_perm_18 ts__coplanar by blast
            ultimately show ?thesis
              using coplanar_trans_1 by auto
          qed
          have "Coplanar C' D' Y A"
          proof -
            have "¬ Col B C' D'"
              using Col_perm P38 by blast
            moreover have "Coplanar B C' D' Y"
              using T3 ncoplanar_perm_8 by blast
            moreover have "Coplanar B C' D' A"
              using P46 ncoplanar_perm_18 ts__coplanar by blast
            ultimately show ?thesis
              using coplanar_trans_1 by auto
          qed
          have "Coplanar C' D' X R"
          proof -
            have "Col C' D' R"
              using Col_perm ‹Col R C' D'› by blast
            moreover have "Col X R R"
              by (simp add: col_trivial_2)
            ultimately show ?thesis
              using ncop__ncols by blast
          qed
          have "Coplanar C' D' Y R"
            using Col_perm T2 midpoint_col ncop__ncols by blast
          have "Col X Y A"
          proof -
            have "R PerpAt X Y C' D'"
              using T3 by simp
            moreover have "R PerpAt A R C' D'"
              using Perp_in_perm ‹R PerpAt C' D' R A› by blast
            ultimately show ?thesis
              using ‹Coplanar C' D' Y R›  ‹Coplanar C' D' X R› cop4_perp_in2__col 
                ‹Coplanar C' D' X A› ‹Coplanar C' D' Y A› by blast
          qed
          have Z1: "Col X Y R"
            using T3 perp_in_col by blast
          have "Col A E'' R"
          proof -
            have "Coplanar C' D' E'' R"
              using Col_cases ‹Col R C' D'› ncop__ncols by blast
            moreover have "A E'' Perp C' D'"
              using P47 Perp_perm by blast
            moreover have "A R Perp C' D'"
              using Perp_perm ‹C' D' Perp R A› by blast
            ultimately show ?thesis
              using cop_perp2__col by blast
          qed
          hence "Col X Y E''" using Z1
            by (metis (full_types) ‹A ≠ R› ‹Col X Y A› col_permutation_4 col_trivial_2 l6_21)
          have "Col A E'' R"
          proof -
            have "Coplanar C' D' E'' R"
              using Col_cases ‹Col R C' D'› ncop__ncols by blast
            moreover have "A E'' Perp C' D'"
              using P47 Perp_perm by blast
            moreover have "A R Perp C' D'"
              using Perp_perm ‹C' D' Perp R A› by blast
            ultimately show ?thesis
              using cop_perp2__col by blast
          qed
          have "Col A R X"
            using ‹Col X Y A› ‹Col X Y R› ‹X ≠ Y› col_transitivity_1 
              not_col_permutation_3 by blast
          have "Col A R Y"
            using ‹Col X Y A› ‹Col X Y R› ‹X ≠ Y› col_transitivity_2 
              not_col_permutation_3 by blast
          have "A E'' Perp C D"
          proof cases
            assume "X = A"
            show ?thesis
            proof -
              have "A ≠ E''"
                by (simp add: P26)
              moreover have "A Y Perp C D"
                using T3 ‹X = A› perp_right_comm by blast
              moreover have "Col A Y E''"
                using Col_perm ‹A ≠ R› ‹Col A E'' R› ‹Col A R Y› 
                  col_transitivity_1 by blast
              ultimately show ?thesis
                using perp_col by auto
            qed
          next
            assume "X ≠ A"
            show ?thesis
            proof -
              have "X Y Perp D C" 
                using T3 by blast
              hence "X Y Perp C D" 
                using perp_right_comm by blast
              hence "A X Perp C D" 
                using Perp_perm ‹Col X Y A› ‹X ≠ A› col_trivial_3 perp_col2_bis by blast
              moreover have "Col A X E''"
                using Col_perm ‹A ≠ R› ‹Col A E'' R› ‹Col A R X› 
                  col_transitivity_1 by blast
              ultimately show ?thesis
                using P26 perp_col by blast
            qed
          qed
        }
        {
          assume "R R Perp A R"
          hence "A E'' Perp C D"
            using perp_distinct by blast
        }
        hence "A E'' Perp C D"
          using Perp_cases ‹R C' Perp A R ⟹ A E'' Perp C D› 
            ‹R C' Perp A R ∨ R R Perp A R› by auto
        thus ?thesis
          using Perp_perm by blast
      qed
      show ?thesis
      proof -
        have "Col A E E''"
        proof -
          have "Coplanar C D E E'"
            using assms(4) col__coplanar by auto
          moreover have "A E Perp C D"
            using assms(5) by auto
          moreover have "A E'' Perp C D"
            using Perp_perm ‹C D Perp A E''› by blast
          ultimately show ?thesis
            by (meson P11 col_perp2_ncol_col col_trivial_3 not_col_permutation_2)
        qed
        moreover have "E'' = E"
        proof -
          have f1: "C = E'' ∨ Col C E'' D"
            by (metis P18 bet_out_1 out_col)
          hence f2: "C = E'' ∨ Col C E'' E"
            using Col_perm P3 assms(4) col_transitivity_1 by blast
          have "∀p. (C = E'' ∨ Col C p D) ∨ ¬ Col C E'' p"
            using f1 by (meson col_transitivity_1)
          hence "∃p. ¬ Col E'' p A ∧ Col E'' E p"
            using f2 by (metis (no_types) Col_perm P11 assms(4))
          thus ?thesis
            using Col_perm calculation col_transitivity_1 by blast
        qed
        ultimately show ?thesis
          by (metis Bet_perm P18 P20 P28 conga_left_comm not_conga_sym)
      qed
    qed
    hence "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D"
      by blast
  }
  thus ?thesis
    using P18 ‹E'' = A ⟹ B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D› by blast
qed

lemma perp2_refl:
  assumes "A ≠ B"
  shows "P Perp2 A B A B"
proof cases
  assume "Col A B P"
  obtain X where "¬ Col A B X"
    using assms not_col_exists by blast
  then obtain Q where "A B Perp Q P ∧ A B OS X Q"
    using ‹Col A B P› l10_15 by blast
  thus ?thesis
    using Perp2_def Perp_cases col_trivial_3 by blast
next
  assume "¬ Col A B P"
  then obtain Q where "Col A B Q ∧ A B Perp P Q"
    using l8_18_existence by blast
  thus ?thesis
    using Perp2_def Perp_cases col_trivial_3 by blast
qed

lemma perp2_sym:
  assumes "P Perp2 A B C D"
  shows "P Perp2 C D A B"
proof -
  obtain X Y where "Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms by auto
  thus ?thesis
    using Perp2_def by blast
qed

lemma perp2_left_comm:
  assumes "P Perp2 A B C D"
  shows "P Perp2 B A C D"
proof -
  obtain X Y where "Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms by auto
  thus ?thesis
    using Perp2_def perp_right_comm by blast
qed

lemma perp2_right_comm:
  assumes "P Perp2 A B C D"
  shows "P Perp2 A B D C"
proof -
  obtain X Y where "Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms by auto
  thus ?thesis
    using Perp2_def perp_right_comm by blast
qed

lemma perp2_comm:
  assumes "P Perp2 A B C D"
  shows "P Perp2 B A D C"
proof -
  obtain X Y where "Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms by auto
  thus ?thesis
    using assms perp2_left_comm perp2_right_comm by blast
qed

lemma perp2_pseudo_trans:
  assumes "P Perp2 A B C D" and
    "P Perp2 C D E F" and
    "¬ Col C D P"
  shows "P Perp2 A B E F"
proof -
  obtain X Y where P1: "Col P X Y ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms(1) by auto
  obtain X' Y' where P2: "Col P X' Y' ∧ X' Y' Perp C D ∧ X' Y' Perp E F"
    using Perp2_def assms(2) by auto
  have "X Y Par X' Y'"
  proof -
    have "Coplanar P C D X"
    proof cases
      assume "X = P"
      thus ?thesis
        using ncop_distincts by blast
    next
      assume "X ≠ P"
      hence "X P Perp C D"
        using Col_cases P1 perp_col by blast
      hence "Coplanar X P C D"
        by (simp add: perp__coplanar)
      thus ?thesis
        using ncoplanar_perm_18 by blast
    qed
    have "Coplanar P C D Y"
    proof cases
      assume "Y = P"
      thus ?thesis
        using ncop_distincts by blast
    next
      assume "Y ≠ P"
      hence "Y P Perp C D"
        by (metis (full_types) Col_cases P1 Perp_cases col_transitivity_2 perp_col2)
      hence "Coplanar Y P C D"
        by (simp add: perp__coplanar)
      thus ?thesis
        using ncoplanar_perm_18 by blast
    qed
    have "Coplanar P C D X'"
    proof cases
      assume "X' = P"
      thus ?thesis
        using ncop_distincts by blast
    next
      assume "X' ≠ P"
      hence "X' P Perp C D"
        using Col_cases P2 perp_col by blast
      hence "Coplanar X' P C D"
        by (simp add: perp__coplanar)
      thus ?thesis
        using ncoplanar_perm_18 by blast
    qed
    have "Coplanar P C D Y'"
    proof cases
      assume "Y' = P"
      thus ?thesis
        using ncop_distincts by blast
    next
      assume "Y' ≠ P"
      hence "Y' P Perp C D"
        by (metis (full_types) Col_cases P2 Perp_cases col_transitivity_2 perp_col2)
      hence "Coplanar Y' P C D"
        by (simp add: perp__coplanar)
      thus ?thesis
        using ncoplanar_perm_18 by blast
    qed
    show ?thesis
    proof -
      have "Coplanar C D X X'"
        using Col_cases ‹Coplanar P C D X'› ‹Coplanar P C D X› assms(3) 
          coplanar_trans_1 by blast
      moreover have "Coplanar C D X Y'"
        using Col_cases ‹Coplanar P C D X› ‹Coplanar P C D Y'› assms(3) 
          coplanar_trans_1 by blast
      moreover have "Coplanar C D Y X'"
        using Col_cases ‹Coplanar P C D X'› ‹Coplanar P C D Y› assms(3) 
          coplanar_trans_1 by blast
      moreover have "Coplanar C D Y Y'"
        using Col_cases ‹Coplanar P C D Y'› ‹Coplanar P C D Y› assms(3) 
          coplanar_trans_1 by blast
      ultimately show ?thesis
        using l12_9 P1 P2 by blast
    qed
  qed
  thus ?thesis
  proof -
    {
      assume "X Y ParStrict X' Y'"
      hence "Col X X' Y'"
        using P1 P2 ‹X Y ParStrict X' Y'› par_not_col by blast
    }
    hence "Col X X' Y'"
      using Par_def ‹X Y Par X' Y'› by blast
    moreover have "Col Y X' Y'"
    proof -
      {
        assume "X Y ParStrict X' Y'"
        hence "Col Y X' Y'"
          using P1 P2 ‹X Y ParStrict X' Y'› par_not_col by blast
      }
      thus ?thesis
        using Par_def ‹X Y Par X' Y'› by blast
    qed
    moreover have "X ≠ Y"
      using P1 perp_not_eq_1 by auto
    ultimately show ?thesis
      by (meson Perp2_def P1 P2 col_permutation_1 perp_col2)
  qed
qed

lemma col_cop_perp2__pars_bis:
  assumes "¬ Col A B P" and
    "Col C D P" and
    "Coplanar A B C D" and
    "P Perp2 A B C D"
  shows "A B ParStrict C D"
proof -
  obtain X Y where "Col P X Y" and "X Y Perp A B" and "X Y Perp C D"
    using Perp2_def assms(4) by auto
  hence "Col X Y P"
    using Col_perm by blast
  obtain Q where "X ≠ Q" and "Y ≠ Q" and "P ≠ Q" and "Col X Y Q"
    using ‹Col X Y P› diff_col_ex3 by blast
  have "A B Perp P Q" 
    using ‹Col X Y P› ‹Col X Y Q› ‹P ≠ Q› ‹X Y Perp A B› perp_col0 by blast
  moreover have "C D Perp P Q" 
    using ‹Col X Y P› ‹Col X Y Q› ‹P ≠ Q› ‹X Y Perp C D› perp_col0 by blast
  ultimately show ?thesis
    by (meson col_cop_perp2__pars assms(1) assms(2) assms(3))
qed

lemma perp2_preserves_bet23:
  assumes "Bet PO A B" and
    "Col PO A' B'" and
    "¬ Col PO A A'" and
    "PO Perp2 A A' B B'"
  shows "Bet PO A' B'"
proof -
  have "A ≠ A'"
    using assms(3) not_col_distincts by auto
  show ?thesis
  proof cases
    assume "A' = B'"
    thus ?thesis
      using between_trivial by auto
  next
    assume "A' ≠ B'"
    {
      assume "A = B"
      then obtain X Y where P1: "Col PO X Y ∧ X Y Perp A A' ∧ X Y Perp A B'"
        using Perp2_def assms(4) by blast
      have "Col A A' B'"
      proof -
        have "Coplanar X Y A' B'"
          using Col_cases Coplanar_def P1 assms(2) by auto
        moreover have "A A' Perp X Y"
          using P1 Perp_perm by blast
        moreover have "A B' Perp X Y"
          using P1 Perp_perm by blast
        ultimately show ?thesis
          using cop_perp2__col by blast
      qed
      hence "False"
        using Col_perm ‹A' ≠ B'› assms(2) assms(3) l6_16_1 by blast
    }
    hence "A ≠ B" by auto
    have "A A' Par B B'"
    proof -
      obtain X Y where P2: "Col PO X Y ∧ X Y Perp A A' ∧ X Y Perp B B'"
        using Perp2_def assms(4) by auto
      hence "Coplanar X Y A B"
        using Coplanar_def assms(1) bet_col not_col_permutation_2 by blast
      show ?thesis
      proof -
        have "Coplanar X Y A B'"
          by (metis (full_types) Col_cases P2 assms(2) assms(3) col_cop2__cop 
              col_trivial_3 ncop__ncols perp__coplanar)
        moreover have "Coplanar X Y A' B"
        proof cases
          assume "Col A X Y"
          hence "Col Y X A"
            by (metis (no_types) Col_cases)
          thus ?thesis
            by (metis Col_cases P2 assms(1) assms(3) bet_col colx 
                ncop__ncols not_col_distincts)
        next
          assume "¬ Col A X Y"
          moreover have "Coplanar A X Y A'"
            using Coplanar_def P2 perp_inter_exists by blast
          moreover have "Coplanar A X Y B"
            using ‹Coplanar X Y A B› ncoplanar_perm_8 by blast
          ultimately show ?thesis
            using coplanar_trans_1 by auto
        qed
        moreover have "Coplanar X Y A' B'"
          using Col_cases Coplanar_def P2 assms(2) by auto
        moreover have "A A' Perp X Y"
          using P2 Perp_perm by blast
        moreover have "B B' Perp X Y"
          using P2 Perp_perm by blast
        ultimately show ?thesis
          using ‹Coplanar X Y A B› l12_9 by auto
      qed
    qed
    {
      assume "A A' ParStrict B B'"
      hence "A A' OS B B'"
        by (simp add: l12_6)
      have "A A' TS PO B"
        using Col_cases ‹A ≠ B› assms(1) assms(3) bet__ts by blast
      hence "A A' TS B' PO"
        using ‹A A' OS B B'› l9_2 l9_8_2 by blast
      hence "Bet PO A' B'"
        using Col_cases assms(2) between_symmetry col_two_sides_bet 
          invert_two_sides by blast
    }
    thus ?thesis
      by (metis Col_cases Par_def ‹A A' Par B B'› ‹A ≠ B› assms(1) assms(3) 
          bet_col col_trivial_3 l6_21)
  qed
qed

lemma perp2_preserves_bet13:
  assumes "Bet B PO C" and
    "Col PO B' C'" and
    "¬ Col PO B B'" and
    "PO Perp2 B C' C B'"
  shows "Bet B' PO C'"
proof cases
  assume "C' = PO"
  thus ?thesis
    using not_bet_distincts by blast
next
  assume "C' ≠ PO"
  show ?thesis
  proof cases
    assume "B' = PO"
    thus ?thesis
      using between_trivial2 by auto
  next
    assume "B' ≠ PO"
    have "B ≠ PO"
      using assms(3) col_trivial_1 by auto
    have "Col B PO C"
      by (simp add: Col_def assms(1))
    show ?thesis
    proof cases
      assume "B = C"
      thus ?thesis
        using ‹B = C› ‹B ≠ PO› assms(1) between_identity by blast
    next
      assume "B ≠ C"
      have "B C' Par C B'"
      proof -
        obtain X Y where P1: "Col PO X Y ∧ X Y Perp B C' ∧ X Y Perp C B'"
          using Perp2_def assms(4) by auto
        have "Coplanar X Y B C"
          by (meson P1 ‹Col B PO C› assms(1) l9_18_R2 ncop__ncols 
              not_col_permutation_2 not_col_permutation_5 ts__coplanar)
        have "Coplanar X Y C' B'"
          using Col_cases Coplanar_def P1 assms(2) by auto
        have "Coplanar X Y B B'" 
          by (metis P1 ‹C' ≠ PO› ‹Coplanar X Y B C› assms(1) assms(2) 
              bet_cop__cop col_cop2__cop not_col_permutation_5 perp__coplanar)
        moreover 
        have "Coplanar X Y C' C" 
        proof cases
          assume "Col B X Y"
          thus ?thesis 
            by (meson P1 ‹B ≠ PO› ‹Col B PO C› col_permutation_1 colx ncop__ncols)
        next
          assume "¬ Col B X Y"
          thus ?thesis 
            by (meson P1 ‹Coplanar X Y B C› coplanar_perm_8 coplanar_pseudo_trans 
                ncop_distincts perp__coplanar)
        qed
        ultimately show ?thesis using l12_9 
          by (meson P1 Perp_cases ‹Coplanar X Y B C› ‹Coplanar X Y C' B'›)
      qed
      have "B C' ParStrict C B'"
        by (metis Out_def Par_def ‹B C' Par C B'› ‹B ≠ C› ‹B ≠ PO› assms(1) 
            assms(3) col_transitivity_1 not_col_permutation_4 out_col)
      have "B' ≠ PO"
        by (simp add: ‹B' ≠ PO›)
      obtain X Y where P5: "Col PO X Y ∧ X Y Perp B C' ∧ X Y Perp C B'"
        using Perp2_def assms(4) by auto
      have "X ≠ Y"
        using P5 perp_not_eq_1 by auto
      show ?thesis
      proof cases
        assume "Col X Y B"
        have "Col X Y C"
          using P5 ‹B ≠ PO› ‹Col B PO C› ‹Col X Y B› col_permutation_1 colx by blast
        show ?thesis
        proof -
          have "Col B' PO C'"
            using Col_cases assms(2) by auto
          moreover have "Per PO C B'"
            by (metis P5 ‹B C' ParStrict C B'› ‹Col X Y C› assms(2) 
                col_permutation_2 par_strict_not_col_2 perp_col2 perp_per_2)
          moreover have "Per PO B C'"
            using P5 ‹B ≠ PO› ‹Col X Y B› col_permutation_1 perp_col2 perp_per_2 by blast
          ultimately show ?thesis
            by (metis per13_preserves_bet_inv  ‹B C' ParStrict C B'› assms(1) assms(3) 
                between_symmetry not_col_distincts not_col_permutation_3 par_strict_not_col_2)
        qed
      next
        assume "¬ Col X Y B"
        then obtain B0 where U1: "Col X Y B0 ∧ X Y Perp B B0"
          using l8_18_existence by blast
        have "¬ Col X Y C"
          using P5 ‹B C' ParStrict C B'› ‹Col B PO C› ‹¬ Col X Y B› assms(2) 
            col_permutation_2 colx par_strict_not_col_2 by metis
        then obtain C0 where U2: "Col X Y C0 ∧ X Y Perp C C0"
          using l8_18_existence by blast
        have "B0 ≠ PO"
          by (metis P5 Perp_perm ‹Col B PO C› ‹Col X Y B0 ∧ X Y Perp B B0› ‹¬ Col X Y C› 
              assms(3) col_permutation_2 col_permutation_3 col_perp2_ncol_col)
        {
          assume "C0 = PO"
          hence "C PO Par C B'"
            by (metis P5 Par_def Perp_cases ‹Col X Y C0 ∧ X Y Perp C C0› ‹¬ Col X Y C› 
                col_perp2_ncol_col not_col_distincts not_col_permutation_3 perp_distinct)
          hence "False"
            by (metis ‹B C' ParStrict C B'› assms(2) assms(3) col3 not_col_distincts 
                par_id_2 par_strict_not_col_2)
        }
        hence "C0 ≠ PO" by auto
        have "Bet B0 PO C0"
        proof -
          have "Bet B PO C"
            by (simp add: assms(1))
          moreover have "PO ≠ B0"
            using ‹B0 ≠ PO› by auto
          moreover have "PO ≠ C0"
            using ‹C0 ≠ PO› by auto
          moreover have "Col B0 PO C0"
            using U1 U2 P5 ‹X ≠ Y› col3 not_col_permutation_2 by blast
          moreover have "Per PO B0 B"
          proof -
            have "B0 PerpAt PO B0 B0 B"
            proof cases
              assume "X = B0"
              have "B0 PO Perp B B0"
                by (metis P5 U1 calculation(2) col3 col_trivial_2 col_trivial_3 perp_col2)
              show ?thesis
              proof -
                have "B0 ≠ PO"
                  using calculation(2) by auto
                moreover have "B0 Y Perp B B0"
                  using U1 ‹X = B0› by auto
                moreover have "Col B0 Y PO"
                  using Col_perm P5 ‹X = B0› by blast
                ultimately show ?thesis
                  using ‹B0 PO Perp B B0› perp_in_comm perp_perp_in by blast
              qed
            next
              assume "X ≠ B0"
              have "X B0 Perp B B0"
                using U1 ‹X ≠ B0› perp_col by blast
              have "B0 PO Perp B B0"
                by (metis P5 U1 calculation(2) not_col_permutation_2 perp_col2)
              hence "B0 PerpAt B0 PO B B0"
                by (simp add: perp_perp_in)
              thus ?thesis
                using Perp_in_perm by blast
            qed
            thus ?thesis
              by (simp add: perp_in_per)
          qed
          moreover have "Per PO C0 C"
          proof -
            have "C0 PO Perp C C0"
              by (metis P5 U2 calculation(3) col3 col_trivial_2 col_trivial_3 perp_col2)
            hence "C0 PerpAt PO C0 C0 C"
              by (simp add: perp_in_comm perp_perp_in)
            thus ?thesis
              using perp_in_per_2 by auto
          qed
          ultimately show ?thesis
            using per13_preserves_bet by blast
        qed
        show ?thesis
        proof cases
          assume "C' = B0"
          have "B' = C0"
          proof -
            have "¬ Col C' PO C"
              using P5 U1 ‹B0 ≠ PO› ‹C' = B0› ‹¬ Col X Y C› colx not_col_permutation_3 
                not_col_permutation_4 by blast
            moreover have "C ≠ C0"
              using U2 ‹¬ Col X Y C› by auto
            moreover have "Col C C0 B'"
            proof -
              have "Coplanar X Y C0 B'"
              proof -
                have "Col X Y C0"
                  by (simp add: U2)
                moreover have "Col C0 B' C0"
                  by (simp add: col_trivial_3)
                ultimately show ?thesis
                  using ncop__ncols by blast
              qed
              moreover have "C C0 Perp X Y"
                using Perp_perm U2 by blast
              moreover have "C B' Perp X Y"
                using P5 Perp_perm by blast
              ultimately show ?thesis
                using cop_perp2__col by auto
            qed
            ultimately show ?thesis
              by (metis Col_def ‹C' = B0› ‹Bet B0 PO C0› assms(2) colx)
          qed
          show ?thesis
            using Bet_cases ‹B' = C0› ‹C' = B0› ‹Bet B0 PO C0› by blast
        next
          assume "C' ≠ B0"
          hence "B' ≠ C0"
            by (metis P5 U1 U2 ‹C0 ≠ PO› assms(2) col_permutation_1 colx l8_18_uniqueness)
          have "B C' Par B B0"
          proof -
            have "Coplanar X Y B B"
              using ncop_distincts by auto
            moreover have "Coplanar X Y B B0"
              using U1 ncop__ncols by blast
            moreover have "Coplanar X Y C' B"
              using P5 ncoplanar_perm_1 perp__coplanar by blast
            moreover have "Coplanar X Y C' B0"
              using ‹¬ Col X Y B› calculation(2) calculation(3) col_permutation_1 
                coplanar_perm_12 coplanar_perm_18 coplanar_trans_1 by blast
            moreover have "B C' Perp X Y"
              using P5 Perp_perm by blast
            moreover have "B B0 Perp X Y"
              using Perp_perm U1 by blast
            ultimately show ?thesis
              using l12_9 by blast
          qed
          {
            assume "B C' ParStrict B B0"
            have "Col B B0 C'"
              by (simp add: ‹B C' Par B B0› par_id_3)
          }
          hence "Col B B0 C'"
            using ‹B C' Par B B0› par_id_3 by blast
          have "Col C C0 B'"
          proof -
            have "Coplanar X Y C0 B'"
              by (simp add: U2 col__coplanar)
            moreover have "C C0 Perp X Y"
              by (simp add: Perp_perm U2)
            moreover have "C B' Perp X Y"
              using P5 Perp_perm by blast
            ultimately show ?thesis
              using cop_perp2__col by auto
          qed
          show ?thesis
          proof -
            have "Col B' PO C'"
              using assms(2) not_col_permutation_4 by blast
            moreover have "Per PO C0 B'"
            proof -
              have "C0 PerpAt PO C0 C0 B'"
              proof cases
                assume "X = C0"
                have "C0 PO Perp C B'"
                proof -
                  have "C0 ≠ PO"
                    by (simp add: ‹C0 ≠ PO›)
                  moreover have "C0 Y Perp C B'"
                    using P5 ‹X = C0› by auto
                  moreover have "Col C0 Y PO"
                    using Col_perm P5 ‹X = C0› by blast
                  ultimately show ?thesis
                    using perp_col by blast
                qed
                hence "B' C0 Perp C0 PO"
                  using Perp_perm ‹B' ≠ C0› ‹Col C C0 B'› not_col_permutation_1
                    perp_col1 by blast
                hence "C0 PerpAt C0 B' PO C0"
                  using Perp_perm perp_perp_in by blast
                thus ?thesis
                  using Perp_in_perm by blast
              next
                assume "X ≠ C0"
                hence "X C0 Perp C B'"
                  using P5 U2 perp_col by blast
                have "C0 PO Perp C B'"
                  using Col_cases P5 U2 ‹C0 ≠ PO› perp_col2 by blast
                hence "B' C0 Perp C0 PO"
                  using Perp_cases ‹B' ≠ C0› ‹Col C C0 B'› col_permutation_2 perp_col by blast
                thus ?thesis
                  using Perp_in_perm Perp_perm perp_perp_in by blast
              qed
              thus ?thesis
                using perp_in_per_2 by auto
            qed
            moreover have "Per PO B0 C'"
            proof -
              have "B0 PerpAt PO B0 B0 C'"
              proof -
                have "Col C' B B0"
                  using Col_cases ‹Col B B0 C'› by blast
                hence "C' B0 Perp X Y" using perp_col P5 Perp_cases ‹C' ≠ B0› by blast
                show ?thesis
                proof -
                  have "PO B0 Perp B0 C'"
                  proof -
                    have "X Y Perp B0 C'" 
                      using P5 Perp_cases ‹C' B0 Perp X Y› by blast
                    moreover have "Col X Y PO" 
                      using Col_cases P5 by blast
                    ultimately show ?thesis 
                      using U1 ‹B0 ≠ PO› perp_col2 by presburger
                  qed
                  thus ?thesis
                    using Perp_in_cases Perp_perm perp_perp_in by blast
                qed
              qed
              thus ?thesis
                by (simp add: perp_in_per)
            qed
            ultimately show ?thesis
              using ‹B0 ≠ PO› ‹C0 ≠ PO› ‹Bet B0 PO C0› between_symmetry 
                per13_preserves_bet_inv by blast
          qed
        qed
      qed
    qed
  qed
qed

lemma is_image_perp_in:
  assumes "A ≠ A'" and
    "X ≠ Y" and
    "A A' Reflect X Y"
  shows "∃ P. P PerpAt A A' X Y"
  by (metis Perp_def Perp_perm assms(1) assms(2) assms(3) ex_sym1 l10_6_uniqueness)

lemma perp_inter_perp_in_n:
  assumes "A B Perp C D"
  shows "∃ P. Col A B P ∧ Col C D P ∧ P PerpAt A B C D"
  by (simp add: assms perp_inter_perp_in)

lemma perp2_perp_in:
  assumes "PO Perp2 A B C D" and
    "¬ Col PO A B" and
    "¬ Col PO C D"
  shows "∃ P Q. Col A B P ∧ Col C D Q ∧ Col PO P Q ∧ P PerpAt PO P A B ∧ Q PerpAt PO Q C D"
proof -
  obtain X Y where P1: "Col PO X Y  ∧ X Y Perp A B ∧ X Y Perp C D"
    using Perp2_def assms(1) by blast
  have "X ≠ Y"
    using P1 perp_not_eq_1 by auto
  obtain P where P2: "Col X Y P ∧ Col A B P ∧ P PerpAt X Y A B"
    using P1 perp_inter_perp_in_n by blast
  obtain Q where P3: "Col X Y Q ∧ Col C D Q ∧ Q PerpAt X Y C D"
    using P1 perp_inter_perp_in_n by blast
  have "Col A B P"
    using P2 by simp
  moreover have "Col C D Q"
    using P3 by simp
  moreover have "Col PO P Q"
    using P2 P3 P1 ‹X ≠ Y› col3 not_col_permutation_2 by blast
  moreover have "P PerpAt PO P A B"
  proof cases
    assume "X = PO"
    thus ?thesis
      by (metis P2 assms(2) not_col_permutation_3 not_col_permutation_4 
          perp_in_col_perp_in perp_in_sym)
  next
    assume "X ≠ PO"
    hence "P PerpAt A B X PO"
      by (meson Col_cases P1 P2 perp_in_col_perp_in perp_in_sym)
    hence "P PerpAt A B PO X"
      using Perp_in_perm by blast
    hence "P PerpAt A B PO P"
      by (metis Col_cases assms(2) perp_in_col perp_in_col_perp_in)
    thus ?thesis
      by (simp add: perp_in_sym)
  qed
  moreover have "Q PerpAt PO Q C D"
    by (metis P1 P3 ‹X ≠ Y› assms(3) col_trivial_2 colx not_col_permutation_3 
        not_col_permutation_4 perp_in_col_perp_in perp_in_right_comm perp_in_sym)
  ultimately show ?thesis
    by blast
qed

lemma l13_8:
  assumes "U ≠ PO" and
    "V ≠ PO" and
    "Col PO P Q" and
    "Col PO U V" and
    "Per P U PO" and
    "Per Q V PO"
  shows "PO Out P Q ⟷ PO Out U V"
proof cases
  assume "P = U"
  thus ?thesis 
    by (metis assms(1) assms(2) assms(3) assms(4) assms(6) col_permutation_3 
        col_transitivity_1 l8_9)
next
  assume "P ≠ U"
  hence "Q ≠ V" 
    by (metis assms(1) assms(2) assms(3) assms(4) assms(5) col_trivial_3 
        colx not_col_permutation_2 per_col_eq)
  {
    assume "PO Out P Q" 
    hence "Bet PO P Q ∨ Bet PO Q P" 
      using Out_def by force 
    moreover
    {
      assume "Bet PO P Q"
      hence "Bet PO U V" 
        by (metis l8_2 assms(1) assms(2) assms(4) assms(5) assms(6) per23_preserves_bet)
      hence "PO Out U V" 
        by (simp add: assms(1) bet_out)
    }
    moreover
    {
      assume "Bet PO Q P"
      hence "Bet U V PO" 
        by (metis l8_2 assms(1) assms(2) assms(4) assms(5) assms(6) between_symmetry 
            not_col_permutation_5 per23_preserves_bet)
      hence "PO Out U V" 
        by (simp add: assms(2) bet_out_1 l6_6)
    }
    ultimately have "PO Out U V" 
      by blast
  }
  moreover
  {
    assume "PO Out U V"
    have "P ≠ PO" 
      by (metis ‹P ≠ U› assms(5) l8_20_1_R1 l8_7)
    moreover have "Q ≠ PO" 
      using assms(2) assms(6) per_distinct by blast
    moreover have "Bet PO P Q ∨ Bet PO Q P" 
    proof -
      {
        assume "Bet PO U V"
        hence "Bet PO P Q"
          by (metis l8_2 assms(1) assms(3) assms(5) assms(6) per23_preserves_bet_inv)
      }
      moreover
      {
        assume "Bet PO V U"
        hence "Bet PO Q P" 
          by (metis l8_2 assms(2) assms(3) assms(5) assms(6) not_col_permutation_5 
              per23_preserves_bet_inv)
      }
      ultimately show ?thesis 
        using Out_def ‹PO Out U V› by fastforce
    qed
    ultimately have "PO Out P Q" 
      using Out_def by blast
  }
  ultimately show ?thesis 
    by blast
qed

lemma perp_in_rewrite:
  assumes "P PerpAt A B C D"
  shows "P PerpAt A P P C ∨ P PerpAt A P P D ∨ P PerpAt B P P C ∨ P PerpAt B P P D"
  by (metis assms per_perp_in perp_in_distinct perp_in_per_1 perp_in_per_3 perp_in_per_4)

lemma perp_out_acute:
  assumes "B Out A C'" and
    "A B Perp C C'"
  shows "Acute A B C"
proof -
  have "A ≠ B"
    using assms(1) out_diff1 by auto
  have "C' ≠ B"
    using Out_def assms(1) by auto
  hence "B C' Perp C C'"
    by (metis assms(1) assms(2) out_col perp_col perp_comm perp_right_comm)
  hence "Per C C' B"
    using Perp_cases perp_per_2 by blast
  hence "Acute C' C B ∧ Acute C' B C"
    by (metis ‹C' ≠ B› assms(2) l11_43 perp_not_eq_2)
  have "C ≠ B"
    using ‹B C' Perp C C'› l8_14_1 by auto
  show ?thesis
  proof -
    have "B Out A C'"
      by (simp add: assms(1))
    moreover have "B Out C C"
      by (simp add: ‹C ≠ B› out_trivial)
    moreover have "Acute C' B C"
      by (simp add: ‹Acute C' C B ∧ Acute C' B C›)
    ultimately show ?thesis
      using acute_out2__acute by auto
  qed
qed

lemma perp_bet_obtuse:
  assumes "B ≠ C'" and
    "A B Perp C C'" and
    "Bet A B C'"
  shows "Obtuse A B C"
proof -
  have "Acute C' B C"
  proof -
    have "B Out C' C'"
      using assms(1) out_trivial by auto
    moreover have "Col A B C'"
      by (simp add: Col_def assms(3))
    hence "C' B Perp C C'"
      using Out_def assms(2) assms(3) bet_col1 calculation perp_col2 by auto
    ultimately show ?thesis
      using perp_out_acute by blast
  qed
  thus ?thesis
    using acute_bet__obtuse assms(2) assms(3) between_symmetry perp_not_eq_1 by blast
qed

(** This development is inspired by The Foundations of Geometry and the Non-Euclidean Plane,
  by George E. Martin, chapters 21 and 22 *)

lemma sac_perm:
  assumes "Saccheri A B C D"
  shows "Saccheri D C B A"
  by (meson Cong_cases Saccheri_def l8_2 Tarski_neutral_dimensionless_axioms 
      assms invert_one_side one_side_symmetry) 

lemma sac_distincts:
  assumes "Saccheri A B C D" 
  shows "A ≠ B ∧ B ≠ C ∧ C ≠ D ∧ A ≠ D ∧ A ≠ C ∧ B ≠ D" 
proof -
  have "Per B A D"
    using Saccheri_def assms by blast 
  have "Per A D C" 
    using Saccheri_def assms by blast 
  have "A D OS B C"
    using Saccheri_def assms by blast 
  hence "B ≠ C"
    using ‹Per A D C› ‹Per B A D› l8_2 l8_7 os_distincts by blast 
  thus ?thesis
    using ‹A D OS B C› os_distincts by blast 
qed

lemma lam_perm:
  assumes "Lambert A B C D"
  shows "Lambert A D C B" 
proof -
  have "Per D A B"
    using Lambert_def assms l8_2 by presburger 
  moreover
  have "Coplanar A D C B"
    using assms lambert__coplanar ncoplanar_perm_5 by blast 
  ultimately
  show ?thesis
    using Lambert_def assms by auto 
qed

(** The two following lemmas come from Theorem 21.10 *)

lemma sac__cong:
  assumes "Saccheri A B C D" 
  shows "Cong A C B D" 
proof -
  have "Per B A D"
    using Saccheri_def assms by blast 
  have "Per A D C"
    using Saccheri_def assms by blast
  have "A ≠ B"
    using assms sac_distincts by auto 
  have "C ≠ D"
    using assms sac_distincts by auto 
  have "A ≠ D"   
    using assms sac_distincts by auto 
  have "B A D CongA C D A"
    by (metis Per_cases ‹A ≠ B› ‹A ≠ D› ‹C ≠ D› ‹Per A D C› ‹Per B A D› l11_16) 
  moreover
  have "Cong A B D C" 
    using assms Saccheri_def not_cong_1243 by blast 
  moreover
  have "Cong A D D A"
    by (simp add: cong_pseudo_reflexivity) 
  ultimately
  show ?thesis
    using l11_49 cong_4312 by blast 
qed

lemma sac__conga: 
  assumes "Saccheri A B C D"
  shows "A B C CongA B C D" 
proof -
  have "Cong A B C D"
    using Saccheri_def assms by blast 
  hence "Cong A B D C"
    using Cong_cases by auto 
  moreover
  have "Cong A C D B"
    by (meson assms not_cong_1243 sac__cong) 
  moreover
  have "Cong B C C B"
    by (simp add: cong_pseudo_reflexivity) 
  ultimately
  show ?thesis 
    using l11_51 by (metis sac_distincts assms conga_right_comm) 
qed

lemma lam__pars1234: 
  assumes "Lambert A B C D"
  shows "A B ParStrict C D" 
proof -
  have "A ≠ B"  
    using assms Lambert_def by blast
  moreover
  have "A ≠ D"
    using assms Lambert_def by blast
  moreover
  have "Per B A D" 
    using assms Lambert_def by blast 
  ultimately
  have "¬ Col B A D" 
    using per_col_eq by blast 
  hence "¬ Col A B D"
    using Col_cases by blast 
  moreover
  have "Col C D D"
    by (simp add: col_trivial_2) 
  moreover
  have "Coplanar A B C D" 
    using assms Lambert_def by blast
  moreover
  have "A B Perp D A" 
    using assms Lambert_def by (metis per_perp perp_comm) 
  moreover
  have "C D Perp D A" 
    using assms Lambert_def by (metis Perp_perm per_perp)
  ultimately
  show ?thesis 
    using col_cop_perp2__pars by blast
qed

lemma lam__pars1423:
  assumes "Lambert A B C D"
  shows "A D ParStrict B C"
  by (meson assms lam__pars1234 lam_perm par_strict_right_comm)

lemma lam__par1234:
  assumes "Lambert A B C D"
  shows "A B Par C D"
  by (meson assms lam__pars1423 lam_perm par_strict_par par_strict_right_comm)

lemma lam__par1423:
  assumes "Lambert A B C D" 
  shows "A D Par B C"
  by (meson assms lam__par1234 lam_perm par_right_comm) 

lemma lam__os:
  assumes "Lambert A B C D"
  shows "A B OS C D" 
  using l12_6 assms lam__pars1234 by blast 

lemma per2_os__pars: 
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C"
  shows "A B ParStrict C D"
proof -
  have "¬ Col A B D" 
    using assms(3) col123__nos not_col_permutation_5 by blast
  moreover have "Col C D D" 
    by (simp add: col_trivial_2)
  moreover have "Coplanar A B C D" 
    using assms(3) coplanar_perm_3 os__coplanar by blast
  moreover have "A B Perp D A" 
    by (metis Perp_cases per_perp assms(1) calculation(1) col_trivial_1 col_trivial_3)
  moreover have "C D Perp D A" 
    by (metis Perp_cases os_distincts per_perp assms(2) assms(3))
  ultimately show ?thesis 
    using col_cop_perp2__pars by blast
qed

lemma per2_os__ncol123:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C"
  shows "¬ Col A B C" 
proof -
  have "A B ParStrict C D"
    using assms(1) assms(2) assms(3) per2_os__pars by blast
  thus ?thesis
    using par_strict_not_col_1 by blast
qed

lemma per2_os__ncol234:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C"
  shows "¬ Col B C D" 
proof -
  have "A B ParStrict C D"
    using assms(1) assms(2) assms(3) per2_os__pars by blast
  thus ?thesis
    using par_strict_not_col_2 by blast 
qed

lemma sac__pars1234: 
  assumes "Saccheri A B C D"
  shows "A B ParStrict C D" 
  using assms Saccheri_def per2_os__pars by blast

lemma sac__par1234:
  assumes "Saccheri A B C D"
  shows "A B Par C D"
  using assms par_strict_par sac__pars1234 by blast 


(** The five following lemmas come from Theorem 21.8 *)


lemma lt_os_per2__lta: 
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C" and
    "A B Lt C D" 
  shows "B C D LtA A B C" 
proof -
  have "A B Lt D C"
    by (simp add: assms(4) lt_right_comm) 
  then obtain E where 1: "Bet D E C ∧ Cong A B D E ∧ ¬ Cong A B D C"
    by (meson cong__nlt le_bet lt__le not_cong_3412)
  hence "E ≠ C" 
    by auto
  have "¬ Col A D B"
    using assms(3) one_side_not_col123 by auto 
  have "¬ Col A D C"
    using assms(3) col123__nos one_side_symmetry by blast 
  have "D ≠ C"
    using ‹¬ Col A D C› col_trivial_2 by force 
  have "D ≠ E"
    using "1" ‹¬ Col A D B› col_trivial_3 cong_identity by blast 
  have "¬ Col A B C"
    using assms(1) assms(2) assms(3) per2_os__ncol123 by blast 
  have "¬ Col B C D"
    using assms(1) assms(2) assms(3) per2_os__ncol234 by blast 
  have "¬ Col E C B"
    by (metis "1" NCol_perm ‹¬ Col B C D› bet_col col_trivial_2 l6_21) 
  have "A B ParStrict C D"
    using assms(1) assms(2) assms(3) per2_os__pars by blast
  have "C ≠ B"
    using ‹¬ Col E C B› col_trivial_2 by auto 
  have "E ≠ B"
    using ‹¬ Col E C B› col_trivial_3 by auto 
  have "B C D LtA B E D" 
  proof -
    have "E B C LtA B E D"
      using "1" ‹D ≠ E› ‹¬ Col E C B› between_symmetry l11_41_aux by blast 
    have "E C B LtA B E D"
      using "1" ‹D ≠ E› ‹¬ Col E C B› between_symmetry l11_41 by blast 
    have "E C B CongA B C D"
    proof -
      have "E C B CongA B C E"
        by (metis conga_pseudo_refl ‹C ≠ B› ‹E ≠ C›) 
      moreover
      have "Bet C E D" using "1"
        by (simp add: between_symmetry) 
      hence "C Out D E"
        by (metis "1" bet_out_1 l6_6) 
      ultimately
      show ?thesis
        by (metis Out_def ‹C ≠ B› between_trivial conga_right_comm out2__conga) 
    qed
    thus ?thesis
      by (metis conga_preserves_lta nlta ‹D ≠ E› ‹E C B LtA B E D› ‹E ≠ B› or_lta2_conga) 
  qed
  moreover
  have "B E D LtA A B C" 
  proof -
    have "Saccheri A B E D" 
    proof -
      have "Per A D E"
        by (meson "1" Col_perm ‹D ≠ C› assms(2) bet_col per_col)
      moreover 
      have "Cong A B E D"
        using "1" Cong_cases by blast 
      moreover 
      have "A D OS B E"
        by (meson "1" ‹D ≠ C› ‹D ≠ E› assms(3) bet2__out invert_one_side l5_1 
            out_out_one_side) 
      ultimately
      show ?thesis
        using assms(1) Saccheri_def by blast 
    qed
    hence "A B E CongA B E D"
      by (simp add: sac__conga) 
    moreover
    have "A B E LtA A B C" 
    proof -
      have "E InAngle A B C" 
      proof -
        have "B A ParStrict C E" 
        proof -
          have "B A ParStrict C D"
            by (simp add: ‹A B ParStrict C D› par_strict_left_comm) 
          moreover
          have "Col C D E"
            by (simp add: "1" Col_def) 
          ultimately
          show ?thesis
            using ‹E ≠ C› par_strict_col_par_strict by auto
        qed
        hence "B A OS C E"
          by (simp add: l12_6) 
        moreover
        have "B C OS A E" 
        proof -
          have "B C OS A D"
            using ‹A B ParStrict C D› assms(3) l9_9_bis par_one_or_two_sides 
              par_strict_right_comm by blast 
          moreover
          have "B C OS D E"
            by (metis "1" Col_cases ‹¬ Col B C D› bet_col between_equality_2 
                invert_one_side l6_4_2 out_one_side) 
          ultimately
          show ?thesis
            using one_side_transitivity by blast 
        qed
        ultimately
        show ?thesis
          by (simp add: os2__inangle) 
      qed
      hence "A B E LeA A B C"
        by (simp add: inangle__lea) 
      moreover
      {
        assume 2: "A B E CongA A B C"
        have "A B OS E C"
          by (meson "2" NCol_cases ‹E InAngle A B C› ‹¬ Col E C B› 
              inangle__lta lta_not_conga) 
        hence "B Out E C" 
          using "2" conga_os__out by blast 
        hence "False"
          using NCol_cases ‹¬ Col E C B› out_col by blast  
      }
      hence "¬ A B E CongA A B C" 
        by auto
      ultimately
      show ?thesis
        by (simp add: LtA_def) 
    qed
    ultimately
    show ?thesis
      by (meson conga__lea456123 lea123456_lta__lta) 
  qed
  ultimately
  show ?thesis
    by (meson lta_trans) 
qed

lemma lt4321_os_per2__lta:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C" and
    "D C Lt B A"
  shows "A B C LtA B C D"
  by (meson Per_cases assms(1) assms(2) assms(3) assms(4) invert_one_side 
      lt_os_per2__lta lta_comm one_side_symmetry) 

lemma lta_os_per2__lt:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C" and
    "B C D LtA A B C" 
  shows "A B Lt C D" 
proof -
  {
    assume "A B Gt C D"
    hence "C D Lt A B"
      by (simp add: Gt_def)
    hence "D C Lt B A"
      by (simp add: lt_comm)
    hence "A B C LtA B C D"
      using assms(1) assms(2) assms(3) lt4321_os_per2__lta by blast     
    hence ?thesis
      by (meson assms(4) not_and_lta Tarski_neutral_dimensionless_axioms) 
  }
  moreover
  {
    assume "Cong A B C D"
    have "B C D LeA A B C"
      by (simp add: assms(4) lta__lea)  
    have "¬ B C D CongA A B C"
      by (simp add: assms(4) lta_not_conga) 
    hence ?thesis
      using Saccheri_def ‹Cong A B C D› assms(1) assms(2) assms(3) 
        conga_sym sac__conga by blast 
  }
  ultimately
  show ?thesis 
    using or_lt_cong_gt by blast
qed

lemma lta123234_os_per2__lt:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C" and
    "A B C LtA B C D"
  shows "D C Lt B A"
  by (meson lta_os_per2__lt Tarski_neutral_dimensionless_axioms assms(1) 
      assms(2) assms(3) assms(4) invert_one_side l8_2 lta_comm one_side_symmetry)

lemma conga_per2_os__cong:
  assumes "Per B A D" and
    "Per A D C" and
    "A D OS B C" and
    "B C D CongA A B C" 
  shows "Cong A B C D" 
proof -
  {
    assume "A B Lt C D"
    hence ?thesis 
      using lt_os_per2__lta assms(1) assms(2) assms(3) assms(4) lta_not_conga by blast 
  }
  moreover
  {
    assume "A B Gt C D"
    hence "C D Lt A B"
      by (simp add: Gt_def)
    hence "D C Lt B A"
      by (meson Lt_cases)
    hence ?thesis
      using assms(1) assms(2) assms(3) lt4321_os_per2__lta 
      by (meson assms(4) lta_not_conga not_conga_sym) 
  }
  ultimately
  show ?thesis 
    using or_lt_cong_gt by blast
qed

(** The two following lemmas constitute Theorem 21.11 *)
lemma mid2_sac__perp_lower:
  assumes "Saccheri A B C D" and
    "M Midpoint B C" and
    "N Midpoint A D" 
  shows "A D Perp M N" 
proof -
  have "A B C CongA B C D"
    using assms(1) sac__conga by blast 
  have "A ≠ B"
    using assms(1) sac_distincts by auto 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  have "C ≠ D"
    using assms(1) sac_distincts by presburger 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "A ≠ N"
    using ‹A ≠ D› assms(3) is_midpoint_id by blast 
  have "M ≠ B"
    using ‹C ≠ B› assms(2) is_midpoint_id by blast 
  have "M ≠ C"
    using ‹C ≠ B› assms(2) is_midpoint_id_2 by force 
  have "Cong A B C D" 
    using assms(1) Saccheri_def by blast
  have "M B A CongA M C D" 
  proof -
    have "C B A CongA B C D"
      by (simp add: ‹A B C CongA B C D› conga_left_comm) 
    moreover
    have "B Out M C"
      using assms(2) Midpoint_def ‹M ≠ B› bet_out by blast 
    moreover
    have "B Out A A"
      by (simp add: ‹A ≠ B› out_trivial) 
    moreover
    have "C Out M B" using assms(2) Midpoint_def ‹M ≠ C› bet_out_1 by blast
    moreover
    have "C Out D D"
      using ‹C ≠ D› out_trivial by auto 
    ultimately
    show ?thesis
      using l11_10 by blast 
  qed
  have "A D OS B M" 
  proof -
    have "A D OS B C" 
      using assms(1) Saccheri_def by blast 
    moreover
    have "Bet B M C"
      by (simp add: assms(2) midpoint_bet) 
    ultimately
    show ?thesis
      using l9_17 by blast 
  qed
  hence "¬ Col A D M"
    using col124__nos by blast 
  moreover
  have "Per M N A" 
  proof -
    have "N Midpoint A D"
      by (simp add: assms(3)) 
    moreover
    have "Cong M A M D"
      by (metis Mid_cases cong_left_commutativity ‹Cong A B C D› 
          ‹M B A CongA M C D› ‹M ≠ B› assms(2) l11_49 l7_13_R1 l7_3_2) 
    ultimately
    show ?thesis
      using Per_def by auto        
  qed
  ultimately
  show ?thesis
    by (metis ‹A ≠ D› ‹A ≠ N› assms(3) col_per_perp col_permutation_1 midpoint_col)   
qed

lemma mid2_sac__perp_upper_R1:
  assumes "Saccheri A B C D" and
    "M Midpoint B C" and
    "N Midpoint A D" 
  shows "Cong N B N C" 
proof -
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  have "D ≠ C"
    using assms(1) sac_distincts by blast
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per B A D" 
    using assms(1) Saccheri_def by blast
  have "Per A D C"
    using assms(1) Saccheri_def by blast
  have "Cong A B C D" 
    using assms(1) Saccheri_def by blast
  have "A ≠ N"
    using ‹A ≠ D› assms(3) is_midpoint_id by blast    
  have "D ≠ N"
    using ‹A ≠ N› assms(3) is_midpoint_id_2 by blast 
  have "N A B CongA N D C" 
  proof -
    have "Per N A B"
    proof -
      have "Per D A B"
        using Per_cases ‹Per B A D› by blast 
      moreover
      have "Col A D N" 
        using assms(3) by (meson midpoint_col not_col_permutation_1) 
      moreover
      have "Per N D C"
        using ‹A ≠ D› ‹Per A D C› calculation(2) col_permutation_4 l8_3 by blast
      ultimately
      show ?thesis
        using ‹A ≠ D› l8_3 by blast
    qed
    moreover
    have "Col D A N" 
      using assms(3) midpoint_col not_col_permutation_3 by blast 
    hence "Per N D C"
      using ‹A ≠ D› ‹Per A D C› l8_3 by blast 
    ultimately
    show ?thesis
      using ‹A ≠ B› ‹A ≠ N› ‹D ≠ C› ‹D ≠ N› l11_16 by auto 
  qed
  moreover
  have "Cong A N D N" 
    using assms(3) midpoint_cong not_cong_1243 by blast 
  moreover
  have "Cong A B D C"
    by (simp add: ‹Cong A B C D› cong_right_commutativity) 
  ultimately
  show ?thesis
    using Cong_cases cong2_conga_cong by blast
qed

lemma mid2_sac__perp_upper:
  assumes "Saccheri A B C D" and
    "M Midpoint B C" and
    "N Midpoint A D" 
  shows "B C Perp M N" 
proof -
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  have "Cong N B N C"
    using assms(1) assms(2) assms(3) mid2_sac__perp_upper_R1 by blast 
  have "B C Perp N M" 
  proof -
    have "Col B C M"
      using NCol_cases assms(2) midpoint_col by blast 
    moreover
    have "Col B C B"
      by (simp add: col_trivial_3) 
    moreover
    have "B ≠ M" 
      using ‹C ≠ B› assms(2) is_midpoint_id by blast 
    moreover
    {
      assume "Col B C N" 
      have "A D OS B N" 
      proof -
        have "A D OS B C"
          using assms(1) Saccheri_def by blast 
        moreover 
        have "Col B N C"
          using Col_cases ‹Col B C N› by blast 
        hence "N Midpoint B C" 
          using l7_20_bis ‹C ≠ B›  ‹Cong N B N C› by auto 
        hence "Bet B N C"
          using midpoint_bet by blast 
        ultimately 
        show ?thesis 
          using l9_17 by blast 
      qed
      hence "¬ Col A D N"
        using col124__nos by blast  
      hence "False" 
        using assms(3) Col_cases midpoint_col by blast 
    }
    hence "¬ Col B C N" 
      by auto
    moreover
    have "Per N M B" 
      using Per_def ‹Cong N B N C› assms(2) by blast 
    ultimately
    show ?thesis
      using l8_16_2 by blast 
  qed
  thus ?thesis
    by (simp add: perp_right_comm) 
qed

lemma sac__pars1423:
  assumes "Saccheri A B C D" 
  shows "A D ParStrict B C" 
proof - 
  obtain M where 1: "M Midpoint B C"
    using midpoint_existence by blast 
  obtain N where 2: "N Midpoint A D"
    using midpoint_existence by blast
  have "A D Perp M N"
    using "1" "2" assms mid2_sac__perp_lower by blast 
  moreover
  have "B C Perp M N"
    using "1" "2" assms mid2_sac__perp_upper by blast 
  moreover
  have "A D OS B M" 
  proof -
    have "A D OS B C" 
      using assms Saccheri_def by blast 
    moreover
    have "Bet B M C"
      by (simp add: "1" midpoint_bet) 
    ultimately
    show ?thesis
      using l9_17 by blast 
  qed
  hence "¬ Col A D M"
    using one_side_not_col124 by blast 
  moreover
  have "Col B C M"
    by (meson "1" col_permutation_1 midpoint_col) 
  moreover
  have "Coplanar A D B C"
    by (meson assms coplanar_perm_4 sac__coplanar) 
  ultimately
  show ?thesis using col_cop_perp2__pars by blast
qed

lemma sac__par1423:
  assumes "Saccheri A B C D" 
  shows "A D Par B C" 
proof -
  have "A D ParStrict B C" 
    using assms(1) sac__pars1423 by blast
  thus ?thesis
    by (simp add: Par_def) 
qed


(** The four following constitute Theorem 22.3 *)

lemma mid2_sac__lam6521:
  assumes "Saccheri A B C D" and
    "M Midpoint B C" and
    "N Midpoint A D" 
  shows "Lambert N M B A" 
proof -
  have "Per B A D" 
    using assms(1) Saccheri_def by blast
  have "N ≠ M"
    using assms(1) assms(2) assms(3) mid2_sac__perp_upper perp_distinct by blast 
  moreover
  have "M ≠ B"
    using assms(1) assms(2) is_midpoint_id sac_distincts by blast 
  moreover
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  moreover
  have "N ≠ A"
    using assms(1) assms(3) is_midpoint_id sac_distincts by blast 
  moreover 
  have "A D Perp M N"
    using assms(1) assms(2) assms(3) mid2_sac__perp_lower by auto
  hence "Per M N A"
    by (meson assms(3) col_permutation_1 l8_16_1 midpoint_col not_col_distincts) 
  moreover
  have "Per N A B" 
  proof -
    have "Per D A B"
      by (simp add: ‹Per B A D› l8_2) 
    moreover
    have "Col A D N"
      using assms(3) col_permutation_2 midpoint_col by blast 
    ultimately
    show ?thesis
      by (metis l8_3 midpoint_distinct_2 assms(3)) 
  qed
  moreover
  have "M N Perp B M" 
  proof -
    have "B C Perp M N"
      using assms(1) assms(2) assms(3) mid2_sac__perp_upper by blast
    hence "M N Perp B C"
      using Perp_cases by blast 
    moreover
    have "Col B C M"
      using Col_perm assms(2) midpoint_col by blast 
    ultimately
    show ?thesis
      using ‹M ≠ B› perp_col1 by auto 
  qed
  hence "Per N M B"
    by (simp add: perp_per_1) 
  moreover
  have "Coplanar N M B A" 
  proof -
    have "B ≠ C"
      using assms(1) sac_distincts by blast 
    moreover
    have "Coplanar N A B C" 
    proof -
      have "Coplanar B C A D"
        using assms(1) ncoplanar_perm_12 sac__coplanar by blast 
      moreover
      have "A ≠ D"
        using ‹A D Perp M N› perp_not_eq_1 by blast 
      moreover
      have "Col A D N" 
        using assms(3) NCol_cases midpoint_col by blast 
      ultimately
      show ?thesis
        using col_cop__cop coplanar_perm_22 by blast
    qed
    moreover
    have "Col B C M"
      using assms(2) midpoint_col not_col_permutation_2 by blast 
    ultimately
    show ?thesis
      using coplanar_perm_5 col_cop__cop by blast 
  qed
  ultimately
  show ?thesis
    using Lambert_def by blast 
qed

lemma mid2_sac__lam6534:
  assumes "Saccheri A B C D" and
    "M Midpoint B C" and
    "N Midpoint A D"
  shows "Lambert N M C D"
  by (meson assms(1) assms(2) assms(3) l7_2 mid2_sac__lam6521 sac_perm) 

lemma lam6521_mid2__sac:
  assumes "Lambert N M B A" and
    "M Midpoint B C" and
    "N Midpoint A D" 
  shows "Saccheri A B C D" 
proof -
  have "N ≠ M" 
    using assms(1) Lambert_def by blast
  have "B ≠ M" 
    using assms(1) Lambert_def by blast
  have "B ≠ A" 
    using assms(1) Lambert_def by blast
  have "N ≠ A" 
    using assms(1) Lambert_def by blast
  have "Per M N A" 
    using assms(1) Lambert_def by blast
  have "Per N A B" 
    using assms(1) Lambert_def by blast
  have "Per N M B" 
    using assms(1) Lambert_def by blast
  have "D ≠ A"
    using ‹N ≠ A› assms(3) l8_20_2 by blast 
  have "C ≠ B"
    using ‹B ≠ M› assms(2) l8_20_2 by blast 
  have "Per D A B"
    by (meson ‹N ≠ A› ‹Per N A B› assms(3) col_per2__per l8_20_1_R1 midpoint_col) 
  have "Per B A D"
    by (simp add: ‹Per D A B› l8_2) 
  moreover
  have "D A ReflectL M N" 
  proof -
    have "N Midpoint A D ∧ Col M N N"
      using assms(3) not_col_distincts by blast
    have "M N Perp A D ∨ A = D"
      by (metis Perp_perm ‹N ≠ A› ‹N ≠ M› ‹Per M N A› assms(3) 
          col_per_perp midpoint_col) 
    moreover
    show ?thesis
      by (metis Mid_cases l7_13 ‹D ≠ A› ‹N ≠ A› ‹N ≠ M› ‹Per M N A› assms(3) 
          calculation cong_cop_per2 l10_4_spec l7_3_2 midpoint_col 
          per_col perp__coplanar) 
  qed
  have "C B ReflectL M N"
  proof -
    have "M Midpoint B C ∧ Col M N M"
      using assms(2) not_col_distincts by blast
    moreover
    have "M N Perp B C ∨ B = C"
      by (metis Perp_perm ‹B ≠ M› ‹N ≠ M› ‹Per N M B› assms(2) col_per_perp midpoint_col)
    ultimately
    show ?thesis
      using ReflectL_def by blast 
  qed
  have "Per A D C" 
  proof -
    have "A D ReflectL M N"
      by (simp add: ‹D A ReflectL M N› l10_4_spec) 
    moreover
    have "B C ReflectL M N"
      by (simp add: ‹C B ReflectL M N› l10_4_spec)
    ultimately
    show ?thesis
      using image_spec_preserves_per by (meson ‹D A ReflectL M N› ‹Per D A B›) 
  qed
  moreover
  have "Cong B A C D" 
    using l10_10_spec ‹C B ReflectL M N› ‹D A ReflectL M N› by blast 
  hence "Cong A B C D"
    using Cong_cases by blast  
  moreover
  have "A D OS B C" 
  proof -
    have "Col A N D" 
      using assms(3) Midpoint_def bet_col by blast 
    moreover
    have "A N ParStrict B C" 
    proof -
      have "A N ParStrict B M"
        using assms(1) lam__pars1423 par_strict_comm by blast 
      moreover
      have "Col B M C" 
        using assms(2) Midpoint_def bet_col by blast 
      ultimately
      show ?thesis
        using ‹C ≠ B› par_strict_col_par_strict by force 
    qed
    hence "A N OS B C"
      by (simp add: l12_6) 
    ultimately
    show ?thesis
      using ‹D ≠ A› col_one_side by blast 
  qed
  ultimately
  show ?thesis
    by (simp add: Saccheri_def) 
qed

lemma lam6534_mid2__sac:
  assumes "Lambert N M C D" and
    "M Midpoint B C" and
    "N Midpoint A D"
  shows "Saccheri A B C D"
  by (meson Mid_cases assms(1) assms(2) assms(3) lam6521_mid2__sac sac_perm) 

(** The six following lemmas constitute Theorem 22.5 *)

lemma cong_lam__per:
  assumes "Lambert A B C D" and
    "Cong A D B C"
  shows "Per B C D" 
proof -
  have "Saccheri A D C B" 
  proof -
    have "A B ParStrict C D"
      using assms(1) lam__pars1234 by auto 
    hence "A B OS D C"
      by (meson l12_6 one_side_symmetry)  
    moreover
    have "Per D A B"
      using Lambert_def assms(1) l8_2 by presburger 
    moreover
    have "Per A B C"
      using Lambert_def assms(1) by presburger 
    moreover
    have "Cong A D C B"
      using assms(2) not_cong_1243 by blast 
    ultimately
    show ?thesis
      using Saccheri_def by blast 
  qed
  hence "A D C CongA D C B"
    by (simp add: sac__conga)  
  moreover
  have "Per A D C"
    using Lambert_def assms(1) by presburger 
  ultimately
  show ?thesis 
    using l11_17 l8_2 by blast 
qed

lemma lam_lt__acute:
  assumes "Lambert A B C D" and
    "A D Lt B C" 
  shows "Acute B C D" 
proof -
  have "Per B A D"
    using Lambert_def assms(1) by presburger 
  have "Per A D C" 
    using assms(1) Lambert_def by blast
  moreover
  have "B C D LtA A D C" 
  proof -
    have "Per D A B" 
      using ‹Per B A D› l8_2 by blast
    moreover
    have "Per A B C"
      using Lambert_def assms(1) by presburger 
    moreover
    have "A B OS D C"
      by (simp add: assms(1) lam__os one_side_symmetry) 
    moreover
    have "A D Lt C B"
      using assms(2) lt_right_comm by blast 
    ultimately
    show ?thesis
      by (simp add: lt_os_per2__lta lta_left_comm)
  qed
  ultimately
  show ?thesis
    using Acute_def by blast 
qed

lemma lam_lt__obtuse:
  assumes "Lambert A B C D" and 
    "B C Lt A D" 
  shows "Obtuse B C D" 
proof -
  have "Per A D C" 
    using assms(1) Lambert_def by blast
  moreover
  have "A D C LtA B C D" 
  proof -
    have "Per B A D"
      using Lambert_def assms(1) by presburger 
    moreover
    have "Per C B A"
      using Lambert_def assms(1) l8_2 by presburger
    moreover
    have "B A OS D C"
      by (meson assms(1) invert_one_side lam__os one_side_symmetry) 
    moreover
    have "B C Lt D A"
      using assms(2) lt_right_comm by blast 
    ultimately
    show ?thesis
      by (simp add: lt_os_per2__lta lta_left_comm one_side_symmetry) 
  qed
  ultimately
  show ?thesis
    using Obtuse_def by blast 
qed

lemma ngta:
  shows "¬ A B C GtA A B C" using GtA_def nlta 
  by blast

lemma lam_per__cong:
  assumes "Lambert A B C D" and
    "Per B C D"
  shows "Cong A D B C" 
proof -
  {
    assume "A D Lt B C"
    hence "Acute B C D"
      using assms(1) lam_lt__acute by blast 
    hence "B C D LtA B C D"
      using acute_not_per assms(2) by blast  
    hence "False"
      by (simp add: nlta) 
  }
  moreover
  {
    assume "A D Gt B C"
    hence "Obtuse B C D"
      using Gt_def assms(1) lam_lt__obtuse by blast
    hence "B C D GtA B C D"
      by (metis Lambert_def assms(1) assms(2) obtuse__nsams per2__sams) 
    hence "False"
      by (simp add: ngta)
  }
  ultimately
  show ?thesis
    using or_lt_cong_gt by blast 
qed

lemma acute_lam__lt:
  assumes "Lambert A B C D" and
    "Acute B C D"
  shows "A D Lt B C" 
proof -
  {
    assume "A D Gt B C"
    hence "B C Lt A D"
      by (simp add: Gt_def) 
    hence "Obtuse B C D" 
      using assms(1) lam_lt__obtuse by blast
    hence "False"
      using acute__not_obtuse assms(2) by blast 
  }
  moreover
  {
    assume "Cong A D B C"
    have "Acute B C D"
      by (simp add: assms(2)) 
    moreover
    have "B ≠ C"
      using acute_distincts calculation by auto 
    moreover
    have "C ≠ D"
      using acute_distincts calculation(1) by blast 
    moreover
    have "Per B C D"
      using ‹Cong A D B C› assms(1) cong_lam__per by auto 
    ultimately
    have "False"
      using acute_not_per by blast 
  }
  ultimately
  show ?thesis
    using or_lt_cong_gt by blast 
qed

lemma lam_obtuse__lt:
  assumes "Lambert A B C D" and
    "Obtuse B C D" 
  shows "B C Lt A D" 
proof -
  {
    assume "Cong B C A D"
    hence "Per B C D"
      using assms(1) cong_lam__per not_cong_3412 by blast 
    moreover
    have "Obtuse B C D"
      by (simp add: assms(2)) 
    moreover
    have "B ≠ C"
      using calculation obtuse_distincts by blast 
    moreover
    have "C ≠ D"
      using calculation(2) obtuse_distincts by blast 
    ultimately
    have "False"
      using obtuse__nsams per2__sams by blast 
  }
  moreover
  {
    assume "B C Gt A D"
    hence "A D Lt B C"
      by (simp add: Gt_def)
    hence "Acute B C D"
      using assms(1) lam_lt__acute by blast
    hence "False" 
      using acute__not_obtuse assms(2) by blast  
  }
  ultimately
  show ?thesis
    using or_lt_cong_gt by blast 
qed

lemma sac__ex2_mid_mid_lam_conga:
  assumes "Saccheri A B C D" 
  shows "∃ M N. M Midpoint B C ∧ N Midpoint A D ∧ Lambert N M B A ∧ A B C CongA M B A"
proof -
  obtain M where 1: "M Midpoint B C"
    using midpoint_existence by blast
  moreover
  obtain N where 2: "N Midpoint A D"
    using midpoint_existence by blast
  moreover
  have "Lambert N M B A" 
    using "1" "2" mid2_sac__lam6521 assms(1) by blast
  moreover
  have "A B C CongA M B A"
    by (metis "1" midpoint_distinct_1 out2__conga out_trivial sac_distincts 
        assms(1) bet_out conga_left_comm midpoint_bet)
  ultimately
  show ?thesis by blast
qed


(** The three following lemmas constitute Omar Khayyam's Theorem (22.6) *)

lemma cong_sac__per_aux1:
  assumes "Saccheri A B C D" and
    "Cong A D B C"
  shows "Per A B C" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  have "M ≠ B"
    using "1" assms(1) is_midpoint_id sac_distincts by blast 
  have "Cong N A M B"
    by (meson "1" assms(2) cong_cong_half_2 l7_2 not_cong_4321) 
  hence "Per A B M"
    using Per_perm "1" cong_lam__per by blast 
  moreover
  have "Col B M C" 
    using "1" bet_col midpoint_bet by blast 
  ultimately
  show ?thesis
    by (metis ‹M ≠ B› per_col) 
qed

lemma cong_sac__per_aux2:
  assumes "Saccheri A B C D" and
    "Per A B C" 
  shows "Cong A D B C" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  have "Col B C M"
    using "1" NCol_cases midpoint_col by blast 
  hence "Per M B A"
    by (metis ‹C ≠ B› assms(2) l8_2 per_col) 
  hence "Cong A N B M"
    using "1" lam_per__cong not_cong_2143 by blast  
  show ?thesis
    using "1" ‹Cong A N B M› cong_mid2__cong by blast 
qed

lemma cong_sac__per:
  assumes "Saccheri A B C D"
  shows "Cong A D B C ⟷ Per A B C"
  using assms cong_sac__per_aux1 cong_sac__per_aux2 by blast 

lemma lt_sac__acute_aux1:
  assumes "Saccheri A B C D" and
    "A D Lt B C"
  shows "Acute A B C" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  have "N A Lt M B"
    using "1" assms(2) lt_comm lt_mid2__lt12 by blast 
  hence "Acute M B A"
    using "1" lam_lt__acute by blast 
  thus ?thesis
    by (metis conga_distinct l11_17 "1" acute__not_obtuse acute_not_per 
        angle_partition conga_obtuse__obtuse) 
qed

lemma lt_sac__acute_aux2:
  assumes "Saccheri A B C D" and
    "Acute A B C"
  shows "A D Lt B C" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  hence "Acute M B A"
    using acute_conga__acute assms(2) by blast 
  hence "A N Lt M B"
    by (simp add: "1" acute_lam__lt lt_left_comm) 
  thus ?thesis
    by (meson "1" lt_mid2__lt13 lt_right_comm) 
qed

lemma lt_sac__acute:
  assumes "Saccheri A B C D" 
  shows "A D Lt B C ⟷ Acute A B C"
  by (meson assms lt_sac__acute_aux1 lt_sac__acute_aux2) 

lemma lt_sac__obtuse_aux1:
  assumes "Saccheri A B C D" and
    "B C Lt A D" 
  shows "Obtuse A B C" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  have "M Midpoint B C" 
    using 1 by blast
  have "N Midpoint A D" 
    using 1 by blast
  have "Lambert N M B A" 
    using 1 by blast
  have "A B C CongA M B A" 
    using 1 by blast
  hence "M B Lt N A"
    using "1" assms(2) lt_comm lt_mid2__lt12 by blast 
  hence "Obtuse M B A"
    using ‹Lambert N M B A› lam_lt__obtuse by blast 
  thus ?thesis
    by (meson "1" ‹Obtuse M B A› conga_obtuse__obtuse not_conga_sym) 
qed

lemma lt_sac__obtuse_aux2:
  assumes "Saccheri A B C D" and
    "Obtuse A B C" 
  shows "B C Lt A D" 
proof -
  obtain M N where 1: "M Midpoint B C ∧ N Midpoint A D ∧ 
  Lambert N M B A ∧ A B C CongA M B A"
    using assms(1) sac__ex2_mid_mid_lam_conga by blast 
  have "M Midpoint B C" 
    using 1 by blast
  have "N Midpoint A D" 
    using 1 by blast
  have "Lambert N M B A" 
    using 1 by blast
  have "A B C CongA M B A" 
    using 1 by blast
  hence "Obtuse M B A"
    using assms(2) conga_obtuse__obtuse by blast 
  hence "B M Lt A N"
    by (simp add: ‹Lambert N M B A› lam_obtuse__lt lt_comm) 
  thus ?thesis
    using "1" lt_mid2__lt13 by blast
qed

lemma lt_sac__obtuse:
  assumes "Saccheri A B C D"
  shows  "B C Lt A D ⟷ Obtuse A B C"
  using assms lt_sac__obtuse_aux1 lt_sac__obtuse_aux2 by blast 

lemma t22_7__per:
  assumes "Saccheri A B C D" and
    "Bet B P C" and 
    "Bet A Q D" and
    "A ≠ Q" and 
    "Q ≠ D" and
    "Per P Q A" and
    "Cong P Q A B" 
  shows "Per A B C" 
proof -
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast
  have "A ≠ D"
    using assms(3) assms(5) between_identity by blast 
  have "Per A D C" 
    using assms(1) Saccheri_def by blast
  have "A D OS B C" 
    using assms(1) Saccheri_def by blast
  { 
    assume "B = P" 
    have "Per B A Q" 
    proof -
      have "Per B A D" 
        using assms(1) Saccheri_def by blast
      moreover
      have "Col A D Q"
        using Bet_cases Col_def assms(3) by auto 
      ultimately
      show ?thesis
        using ‹A ≠ D› per_col by blast 
    qed
    hence "False"
      using ‹B = P› assms(4) assms(6) l8_7 by blast 
  }
  hence "B ≠ P" 
    by auto
  {
    assume "C = P"
    hence "Per C Q D"
      by (metis Per_cases per2_preserves_diff ‹Per A D C› assms(3) assms(4) 
          assms(5) assms(6) bet_col) 
    moreover
    have "Per C D Q"
      by (metis per2_preserves_diff ‹A ≠ D› ‹C = P› ‹Per A D C› assms(3) assms(5) 
          assms(6) bet_col l8_2) 
    ultimately
    have "False"
      using assms(5) l8_7 by blast 
  }
  hence "C ≠ P"
    by blast
  have "Saccheri A B P Q" 
  proof -
    have "Per B A Q" 
    proof -
      have "Per B A D" 
        using assms(1) Saccheri_def by blast
      moreover
      have "Col A D Q"
        using Col_perm assms(3) bet_col by blast
      ultimately
      show ?thesis
        using ‹A ≠ D› per_col by blast 
    qed
    moreover
    have "Per A Q P"
      using Per_perm assms(6) by blast 
    moreover
    have "Cong A B P Q"
      using assms(7) not_cong_3412 by blast 
    moreover
    have "A Q OS B P" 
    proof -
      have "Col A D Q"
        using assms(3) bet_col1 between_trivial by blast 
      moreover
      have "A D OS B P"
        using ‹A D OS B C› assms(2) l9_17 by blast 
      ultimately
      show ?thesis
        using assms(4) col_one_side by blast 
    qed
    ultimately
    show ?thesis 
      using Saccheri_def by blast
  qed
  have "Saccheri D C P Q" 
  proof -
    have "Per C D Q"
      by (metis Per_perm l5_1 ‹A ≠ D› ‹Per A D C› assms(3) bet_col1 col_per2__per l8_5) 
    moreover
    have "Per D Q P"
      by (meson Per_perm assms(3) assms(4) assms(6) bet_col col_per2__per l8_5) 
    moreover
    have "Cong A B C D" 
      using assms(1) Saccheri_def by blast
    hence "Cong D C P Q"
      by (meson assms(7) cong_transitivity not_cong_3421) 
    moreover
    have "D A OS C P"
      by (meson ‹A D OS B C› assms(2) between_symmetry invert_one_side 
          l9_17 one_side_symmetry) 
    hence "D Q OS C P"
      by (metis Col_cases assms(3) assms(5) bet_col col_one_side)  
    ultimately
    show ?thesis
      using Saccheri_def by blast 
  qed
  have "P ≠ Q"
    using ‹A ≠ B› assms(7) cong_reverse_identity by blast 
  have "A B C A B C SumA B P C" 
  proof - 
    have "B P Q CongA A B P"
      by (meson ‹Saccheri A B P Q› not_conga_sym sac__conga) 
    hence "B P Q CongA A B C" 
      by (metis CongA_def l5_1 out2__conga ‹C ≠ B› assms(2) bet2__out not_conga) 
    moreover
    have "Q P C CongA A B C" 
    proof -
      have "Q P C CongA P C D"
        by (simp add: ‹Saccheri D C P Q› sac__conga sac_perm) 
      moreover
      have "B C D CongA A B C"
        using assms(1) conga_sym sac__conga by blast 
      hence "P C D CongA A B C" 
        using l11_4_2 
        by (metis Bet_cases CongA_def Out_def ‹C = P ⟹ False› 
            assms(2) not_bet_distincts not_conga out2__conga)
      ultimately show ?thesis
        by (meson not_conga) 
    qed
    ultimately
    show ?thesis
      by (metis ‹A ≠ B› ‹B ≠ P› ‹C ≠ B› ‹C ≠ P› assms(2) bet_per2__suma 
          conga_left_comm conga_sym conga_trans l11_17 l11_18_2) 
  qed
  thus ?thesis
    using assms(2) bet_suma__per by blast 
qed

lemma t22_7__acute:
  assumes "Saccheri A B C D" and
    "Bet B P C" and
    "Bet A Q D" and
    "A ≠ Q" and
    "Per P Q A" and
    "P Q Lt A B"
  shows "Acute A B C" 
proof -
  have "Per B A D" 
    using assms(1) Saccheri_def by blast
  have "Per A D C" 
    using assms(1) Saccheri_def by blast
  have "Cong A B C D" 
    using assms(1) Saccheri_def by blast
  have "A D OS B C" 
    using assms(1) Saccheri_def by blast
  have "A D ParStrict B C"
    by (simp add: assms(1) sac__pars1423) 
  have "A B ParStrict C D"
    by (simp add: assms(1) sac__pars1234) 
  hence "¬ Col A B C"
    using par_strict_not_col_1 by auto 
  have "A ≠ B"
    using ‹¬ Col A B C› col_trivial_1 by auto 
  have "C ≠ B"
    using ‹¬ Col A B C› col_trivial_2 by blast 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "C ≠ D"
    using ‹A D OS B C› os_distincts by blast 
  have "P ≠ Q"
    by (metis ‹A D OS B C› assms(2) assms(3) bet_col not_col_permutation_4 one_side_chara) 
  have "B ≠ P" 
    by (metis l5_1 l8_3 l8_7 ‹A ≠ D› ‹Per B A D› assms(3) assms(4) assms(5) bet_col1 l8_2)
  have "C ≠ P"
    by (metis Per_cases per2_preserves_diff ‹A ≠ D› ‹Cong A B C D› ‹Per A D C› 
        assms(3) assms(4) assms(5) assms(6) bet_col cong__nlt cong_symmetry)
  have "Q ≠ D" 
    by (metis (no_types, lifting) bet_out_1 l8_2 out_col ‹A ≠ D› ‹C ≠ P› 
        ‹Per A D C› ‹Per B A D› assms(2) assms(5) col_per2__per l8_7)
  have "A B C LtA B P Q" 
  proof -
    have "A B P CongA A B C"
      by (metis conga_sym out2__conga out_trivial ‹A ≠ B› ‹B ≠ P› assms(2) bet_out) 
    moreover
    have "B P Q CongA B P Q"
      using ‹B ≠ P› ‹P ≠ Q› conga_refl by presburger 
    moreover
    have "A B P LtA B P Q" 
    proof -
      have "Col A D Q"
        by (simp add: assms(3) bet_col col_permutation_5) 
      hence "Per B A Q" 
        using ‹A ≠ D› ‹Per B A D› per_col by blast 
      moreover
      have "Per A Q P"
        using assms(5) l8_2 by blast 
      moreover
      have "Col A D Q"
        by (simp add: ‹Col A D Q›) 
      hence "A Q OS B P"
        using ‹A D OS B C› assms(2) assms(4) col_one_side l9_17 by blast 
      moreover
      have "Q P Lt B A"
        by (simp add: assms(6) lt_comm) 
      ultimately
      show ?thesis
        using lt4321_os_per2__lta by blast 
    qed
    ultimately
    show ?thesis
      using conga_preserves_lta by force 
  qed
  have "A B C LtA C P Q" 
  proof -
    have "D C P CongA A B C" 
    proof -
      let ?D = "B"
      let ?E = "C"
      let ?F = "D"
      have "A B C CongA B C D"
        using assms(1) sac__conga by blast
      hence "A ≠ B ∧ C ≠ B ∧ ?D ≠ ?E ∧ ?F ≠ ?E ∧
  (∃ A' C' D' F'. Bet B A A' ∧ Cong A A' ?E ?D ∧ Bet B C C' ∧ Cong C C' ?E ?F ∧
  Bet ?E ?D D' ∧ Cong ?D D' B A ∧ Bet ?E ?F F' ∧ Cong ?F F' B C ∧
  Cong A' C' D' F')" 
        by (simp add: CongA_def)
      then obtain A' C' D' F' where "Bet B A A'" and "Cong A A' ?E ?D" and 
        "Bet B C C'" and "Cong C C' ?E ?F" and "Bet ?E ?D D'" and 
        "Cong ?D D' B A" and "Bet ?E ?F F'" and "Cong ?F F' B C" and
        "Cong A' C' D' F'" by blast 
      moreover 
      hence "D C P CongA P C D" 
        using ‹C ≠ D› ‹C ≠ P› conga_pseudo_refl by presburger
      moreover  have "C Out P P" 
        using ‹C ≠ P› out_trivial by auto
      moreover  have "C Out B P" 
        using ‹C ≠ P› assms(2) bet_out_1 l6_6 by presburger
      moreover  have "C Out D D" 
        using ‹C ≠ D› out_trivial by fastforce
      ultimately show ?thesis 
        using l11_10 not_conga not_conga_sym by (meson ‹A B C CongA B C D›)
    qed
    moreover
    have "C P Q CongA C P Q"
      using ‹C ≠ P› ‹P ≠ Q› conga_refl by auto 
    moreover
    have "D C P LtA C P Q" 
    proof -
      have "Per C D Q"
        by (metis Per_perm col_transitivity_1 ‹A ≠ D› ‹Per A D C› assms(3) 
            bet_col bet_col1 col_per2__per l8_5) 
      moreover
      have "Per D Q P"
        by (meson Per_cases assms(3) assms(4) assms(5) bet_col col_per2__per l8_5) 
      moreover
      have "D Q OS C P" 
      proof -
        have "Col D A Q" 
          by (simp add: Col_def assms(3))
        moreover have "D ≠ Q" 
          using ‹Q ≠ D› by auto
        moreover have "D A OS C P" 
          using ‹A D OS B C› assms(2) between_symmetry invert_one_side l9_17 
            one_side_symmetry by blast
        ultimately show ?thesis 
          using col_one_side by blast
      qed
      moreover
      have "Q P Lt C D"
        by (meson ‹Cong A B C D› assms(6) cong2_lt__lt cong_reflexivity lt_left_comm) 
      ultimately
      show ?thesis
        using lt4321_os_per2__lta by blast 
    qed
    ultimately
    show ?thesis
      using conga_preserves_lta by blast 
  qed
  have "Acute B P Q ⟶ ?thesis"
    by (meson Acute_def lta_trans ‹A B C LtA B P Q›) 
  moreover
  have "Per B P Q ⟶ ?thesis"
    using Acute_def ‹A B C LtA B P Q›  by blast 
  moreover
  have "Obtuse B P Q ⟶ ?thesis"
    by (metis not_and_lta ‹A B C LtA C P Q› ‹A ≠ B› ‹C ≠ P› 
        acute_obtuse__lta acute_per__lta angle_partition assms(2) bet_obtuse__acute) 
  ultimately 
  show ?thesis
    using ‹B ≠ P› ‹P ≠ Q› angle_partition by blast
qed

lemma t22_7__obtuse:
  assumes "Saccheri A B C D" and
    "Bet B P C" and
    "Bet A Q D" and
    "A ≠ Q" and
    "Per P Q A" and
    "A B Lt P Q"
  shows "Obtuse A B C" 
proof -
  have "Per B A D" 
    using assms(1) Saccheri_def by blast
  have "Per A D C" 
    using assms(1) Saccheri_def by blast
  have "Cong A B C D" 
    using assms(1) Saccheri_def by blast
  have "A D OS B C" 
    using assms(1) Saccheri_def by blast
  have "A D ParStrict B C"
    by (simp add: assms(1) sac__pars1423) 
  have "A B ParStrict C D"
    by (simp add: assms(1) sac__pars1234) 
  hence "¬ Col A B C"
    using par_strict_not_col_1 by auto 
  have "A ≠ B"
    using ‹¬ Col A B C› col_trivial_1 by auto 
  have "C ≠ B"
    using ‹¬ Col A B C› col_trivial_2 by blast 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "C ≠ D"
    using ‹A D OS B C› os_distincts by blast 
  have "P ≠ Q"
    by (metis ‹A D OS B C› assms(2) assms(3) bet_col not_col_permutation_4 one_side_chara) 
  have "B ≠ P" 
    by (metis Per_cases ‹P ≠ Q› assms(4) assms(5) assms(6) not_and_lt per_lt)
  have "C ≠ P"
    by (metis Per_cases per2_preserves_diff ‹A ≠ D› ‹Cong A B C D› 
        ‹Per A D C› assms(3) assms(4) assms(5) assms(6) bet_col cong__nlt)
  have "Q ≠ D" 
    by (metis col_per2__per l8_2 l8_7 ‹A ≠ D› ‹C ≠ P› ‹Per A D C› ‹Per B A D› 
        assms(2) assms(5) bet_col between_symmetry)
  have "B P Q LtA A B C" 
  proof -
    have "A B P CongA A B C"
      by (metis conga_sym out2__conga out_trivial ‹A ≠ B› ‹B ≠ P› assms(2) bet_out) 
    moreover
    have "B P Q CongA B P Q"
      using ‹B ≠ P› ‹P ≠ Q› conga_refl by presburger 
    moreover
    have "B P Q LtA A B P" 
    proof -
      have "Col A D Q"
        by (simp add: assms(3) bet_col col_permutation_5) 
      hence "Per B A Q" 
        using ‹A ≠ D› ‹Per B A D› per_col by blast 
      moreover
      have "Per A Q P"
        using assms(5) l8_2 by blast 
      moreover
      have "Col A D Q"
        by (simp add: ‹Col A D Q›) 
      hence "A Q OS B P"
        using ‹A D OS B C› assms(2) assms(4) col_one_side l9_17 by blast 
      moreover
      have "B A Lt Q P"
        by (simp add: assms(6) lt_comm) 
      ultimately
      show ?thesis
        using assms(6) lt_os_per2__lta by blast 
    qed
    ultimately
    show ?thesis
      using conga_preserves_lta by force 
  qed
  have "C P Q LtA A B C" 
  proof -
    have "Q P C CongA C P Q"
      using ‹C ≠ P› ‹P ≠ Q› conga_pseudo_refl by auto 
    moreover
    have "P C D CongA A B C" 
    proof -
      have "B C D CongA A B C" 
        by (simp add: assms(1) conga_sym_equiv sac__conga)
      moreover have "C Out P B" 
        using ‹C ≠ P› assms(2) bet_out_1 by auto
      moreover have "C Out D D" 
        using ‹C ≠ D› out_trivial by auto
      moreover have "B Out A A" 
        using ‹A ≠ B› out_trivial by blast
      moreover have "B Out C C" 
        using ‹C ≠ B› out_trivial by auto
      ultimately show ?thesis 
        by (meson l6_6 not_conga out2__conga)
    qed
    moreover
    have "Q P C LtA P C D" 
    proof -
      have "Per P Q D"
        by (metis assms(3) assms(4) assms(5) bet_col col_permutation_4 per_col) 
      moreover
      have "Per Q D C" 
        by (meson ‹A ≠ D› ‹Per A D C› assms(3) bet_col1 between_trivial 
            col_per2__per l8_20_1_R1)
      moreover
      have "Q D OS P C" 
        by (metis ‹A D OS B C› ‹Q ≠ D› assms(2) assms(3) bet_col between_symmetry 
            col2_os__os col_permutation_5 l9_17 not_col_distincts one_side_symmetry)
      moreover
      have "D C Lt P Q"
        by (meson ‹Cong A B C D› assms(6) cong2_lt__lt cong_reflexivity lt_left_comm) 
      ultimately
      show ?thesis
        using lt4321_os_per2__lta by blast 
    qed
    ultimately
    show ?thesis
      using conga_preserves_lta by blast 
  qed
  have "Acute B P Q ⟶ ?thesis"
    by (metis not_and_lta ‹A ≠ B› ‹C P Q LtA A B C› ‹C ≠ B› ‹C ≠ P› 
        acute_bet__obtuse acute_obtuse__lta angle_partition assms(2) 
        obtuse_per__lta) 
  moreover
  have "Per B P Q ⟶ ?thesis"
    using Obtuse_def ‹B P Q LtA A B C› by blast 
  moreover
  have "Obtuse B P Q ⟶ ?thesis"
    using Obtuse_def ‹B P Q LtA A B C› lta_trans by blast 
  ultimately 
  show ?thesis
    using ‹B ≠ P› ‹P ≠ Q› angle_partition by blast
qed

lemma t22_7__cong:
  assumes "Saccheri A B C D" and
    "Bet B P C" and
    "Bet A Q D" and
    "A ≠ Q" and
    "Per P Q A" and
    "Per A B C"
  shows  "Cong P Q A B" 
proof -
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  {
    assume "¬ Cong P Q A B"
    {
      assume "P Q Le A B"
      hence "P Q Lt A B"
        using Lt_def ‹¬ Cong P Q A B› by blast 
      hence "Acute A B C"
        using assms(1) assms(2) assms(3) assms(4) assms(5) t22_7__acute by blast 
      hence "A B C LtA A B C"
        using acute_not_per assms(6) by blast 
    }
    moreover
    {
      assume "A B Le P Q"
      hence "A B Lt P Q"
        using ‹¬ Cong P Q A B› le_anti_symmetry nlt__le by blast 
      hence "Obtuse A B C"
        using assms(1) assms(2) assms(3) assms(4) assms(5) t22_7__obtuse by blast 
      hence "A B C LtA A B C"
        using ‹A ≠ B› ‹C ≠ B› assms(6) obtuse_per__lta by auto 
    }
    ultimately
    have "False"
      using local.le_cases nlta by auto
  }
  thus ?thesis by blast
qed

lemma t22_7__lt5612:
  assumes "Saccheri A B C D" and
    "Bet B P C" and
    "Bet A Q D" and
    "A ≠ Q" and
    "Q ≠ D" and
    "Per P Q A" and
    "Acute A B C" 
  shows "P Q Lt A B"
proof -
  {
    assume "Cong P Q A B"
    have "P Q Lt A B"
      using ‹Cong P Q A B› acute_not_per assms(1) assms(2) assms(3) assms(4) 
        assms(5) assms(6) assms(7) t22_7__per by blast 
  }
  moreover
  {
    assume "¬ Cong P Q A B"
    {
      assume "A B Le P Q"
      hence "Obtuse A B C"
        by (meson ‹¬ Cong P Q A B› assms(1) assms(2) assms(3) assms(4) assms(6) 
            le_anti_symmetry nle__lt t22_7__obtuse) 
      hence "A B C LtA A B C"
        using acute__not_obtuse assms(7) by blast 
      hence "False"
        by (simp add: nlta) 
    }
    hence "P Q Le A B"
      using local.le_cases by blast 
    hence "P Q Lt A B"
      by (simp add: Lt_def ‹¬ Cong P Q A B›) 
  }
  ultimately
  show ?thesis 
    by blast
qed

lemma t22_7__lt1256:
  assumes "Saccheri A B C D" and
    "Bet B P C" and
    "Bet A Q D" and
    "A ≠ Q" and
    "Q ≠ D" and
    "Per P Q A" and
    "Obtuse A B C"
  shows "A B Lt P Q" 
proof -
  have "A ≠ B"
    using assms(7) obtuse_distincts by blast 
  have "C ≠ B"
    using assms(7) obtuse_distincts by blast 
  have "¬ Cong P Q A B"
    by (metis ‹A ≠ B› ‹C ≠ B› assms(1) assms(2) assms(3) assms(4) assms(5) 
        assms(6) assms(7) obtuse__nsams per2__sams t22_7__per) 
  moreover
  {
    assume "¬ Cong P Q A B"
    {
      assume "P Q Le A B"
      hence "P Q Lt A B"
        by (simp add: Lt_def calculation) 
      hence "Acute A B C"
        using assms(1) assms(2) assms(3) assms(4) assms(6) t22_7__acute by blast 
      hence "A B C LtA A B C"
        by (simp add: acute_obtuse__lta assms(7)) 
      hence "False"
        by (simp add: nlta) 
    }
    hence "A B Le P Q"
      using local.le_cases by blast  
    hence "A B Lt P Q"
      using calculation le_anti_symmetry nlt__le by blast 
  }
  ultimately
  show ?thesis by blast
qed

lemma t22_8_aux_1:
  assumes "Saccheri A B C D" and
    (*"Bet B C R" and *)
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" (*and
  "S Out R J" and
  "Cong S J A B"*)
  shows "C ≠ R" 
proof -
  have "A ≠ S"
    using assms(3) assms(2) bet_neq23__neq by presburger
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per A D C"
    using Saccheri_def assms(1) by blast 
  thus ?thesis
    by (metis NCol_perm Per_cases ‹A ≠ D› ‹A ≠ S› ‹Per A D C› assms(3) 
        assms(4) assms(2) bet_col1 bet_out_1 col_per2_cases out_col) 
qed

lemma t22_8_aux_2:
  assumes"Saccheri A B C D" and 
    "Bet B C R" and 
    "Bet A D S" and
    (*"D ≠ D" and*)
    "Per A S R" and
    "S Out R J" and
    "Cong S J A B"
  shows "Saccheri A B J S" 
proof -
  have "A ≠ S"
    using assms(1) assms(3) bet_neq12__neq sac_distincts by presburger 
  have "R ≠ S"
    using assms(5) between_trivial2 not_bet_and_out by blast 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per B A D"
    using Saccheri_def assms(1) by blast 
  have "A D ParStrict B C"
    by (simp add: assms(1) sac__pars1423) 
  have "Per B A S"
    using ‹A ≠ D› ‹Per B A D› assms(3) bet_col per_col by blast 
  have "A S OS B J" 
  proof -
    have "A S OS B R" 
    proof -
      have "Col A D S"
        by (simp add: Col_def assms(3)) 
      moreover
      have "A D OS B R"
        using ‹A D ParStrict B C› assms(2) bet_col par_strict_all_one_side by blast 
      ultimately
      show ?thesis
        by (meson ‹A ≠ S› col_one_side) 
    qed
    moreover
    have "A S OS R J"
      by (meson assms(5) calculation invert_one_side one_side_not_col124 out_one_side) 
    ultimately
    show ?thesis
      using one_side_transitivity by blast 
  qed
  thus ?thesis
    by (metis Saccheri_def ‹Per B A S› ‹R ≠ S› assms(5) assms(6) assms(4) 
        cong_3421 out_col per_col) 
qed

lemma t22_8_aux_3:
  assumes"Saccheri A B C D" and 
    "Bet B C R" and 
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "S Out R J" and
    "Cong S J A B"
  shows "Saccheri D C J S"
proof -
  have "A ≠ S"
    using assms(3) assms(4) between_identity by auto 
  have "R ≠ S"
    using assms(6) out_distinct by auto 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per A D C"  
    using Saccheri_def assms(1) by blast 
  have "Cong A B C D"
    using Saccheri_def assms(1) by blast 
  have "A D ParStrict B C"
    by (simp add: assms(1) sac__pars1423) 
  have "Per D S J"
    by (metis NCol_cases ‹A ≠ S› ‹R ≠ S› assms(3) assms(5) assms(6) bet_col 
        l8_3 out_col per_col) 
  have "Per C D S"
    by (meson ‹A ≠ D› ‹Per A D C› assms(3) bet_col col_per2__per l8_2 l8_5) 
  have "Cong D C A B"
    using Cong_cases ‹Cong A B C D› by blast 
  hence "Cong D C J S"
    by (meson ‹Cong A B C D› assms(7) cong_transitivity not_cong_4321) 
  moreover
  have "D S OS C J" 
  proof -
    have "D S OS C R" 
    proof -
      have "Col D A S"
        by (simp add: assms(3) bet_col col_permutation_4) 
      moreover
      have "D A OS C R"
        using NCol_perm Par_strict_perm ‹A D ParStrict B C› assms(2) bet_col 
          par_strict_all_one_side by blast 
      ultimately
      show ?thesis
        using assms(4) col_one_side by blast 
    qed
    moreover
    have "D S OS R J"
      by (meson one_side_not_col124 assms(6) calculation invert_one_side out_one_side) 
    ultimately
    show ?thesis
      using one_side_transitivity by blast 
  qed
  ultimately
  show ?thesis
    by (simp add: Saccheri_def ‹Per C D S› ‹Per D S J›) 
qed

lemma t22_8_aux_4:
  assumes"Saccheri A B C D" and 
    "Bet B C R" and 
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "S Out R J" and
    "Cong S J A B"
  shows "S J OS C B" 
proof -
  have "A ≠ S"
    using assms(3) assms(4) between_identity by blast 
  have "R ≠ S"
    using assms(6) l6_3_1 by blast 
  have "J ≠ S"
    using assms(6) out_diff2 by auto 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per A D C" 
    using Saccheri_def assms(1) by blast 
  have "Per D S J"
    by (metis NCol_cases ‹A ≠ S› ‹R ≠ S› assms(3) assms(5) assms(6) 
        bet_col l8_3 out_col per_col) 
  have "Per C D S"
    by (meson ‹A ≠ D› ‹Per A D C› assms(3) bet_col col_per2__per l8_2 l8_5) 
  thus ?thesis
    by (metis Per_cases l8_3 ‹J ≠ S› ‹Per D S J› assms(2) assms(4) assms(6) 
        bet_out_1 l6_6 l8_7 out_col out_one_side_1) 
qed

lemma t22_8_aux_5:
  assumes"Saccheri A B C D" and 
    "Bet B C R" and 
    "Bet A D S" and
    (*"D ≠ S" and*)
    "Per A S R" and
    "S Out R J" and
    "Cong S J A B"
  shows "Coplanar A B C J"
proof -
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per B A D"
    using Saccheri_def assms(1) by blast 
  have "Per B A S"
    using ‹A ≠ D› ‹Per B A D› assms(3) bet_col per_col by blast 
  hence "Per S A B"
    by (simp add: l8_2) 
  hence "¬ Col S A B"
    using assms(1) assms(3) bet_neq12__neq l8_9 sac_distincts by blast 
  moreover
  have "Coplanar S A B C" 
  proof -
    have "Coplanar B C A D"
      by (meson sac__coplanar Tarski_neutral_dimensionless_axioms 
          assms(1) coplanar_perm_8) 
    moreover
    have "Col A D S"
      by (simp add: Col_def assms(3)) 
    ultimately
    show ?thesis
      by (metis ‹A ≠ D› col2_cop__cop coplanar_perm_23 l6_16_1 ncoplanar_perm_6) 
  qed
  moreover
  have "Coplanar S A B J"
    using t22_8_aux_2 assms(1) assms(2) assms(3) assms(5) assms(6) assms(4) 
      ncoplanar_perm_9 sac__coplanar by blast
  ultimately
  show ?thesis
    using coplanar_trans_1 by presburger 
qed

lemma t22_8_aux:
  assumes"Saccheri A B C D" and 
    "Bet B C R" and 
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "S Out R J" and
    "Cong S J A B"
  shows "C ≠ R ∧ Saccheri A B J S ∧ Saccheri D C J S ∧ S J OS C B ∧ Coplanar A B C J"
  by (metis assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) assms(7) 
      t22_8_aux_1 t22_8_aux_2 t22_8_aux_3 t22_8_aux_4 t22_8_aux_5) 

lemma t22_8__per:
  assumes "Saccheri A B C D" and
    "Bet B C R" and
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "Cong R S A B"
  shows "Per A B C" 
proof -
  have "A ≠ B"
    using assms(1) sac_distincts by auto 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "Per A D C" 
    using Saccheri_def assms(1) by blast 
  have "Cong A B C D" 
    using Saccheri_def assms(1) by blast 
  have "B ≠ R"
    using assms(1) assms(2) bet_neq12__neq sac_distincts by blast
  have "Saccheri A B R S"
    by (metis ‹A ≠ B› assms(1) assms(2) assms(3) assms(5) assms(6) 
        cong_reverse_identity not_cong_2134 out_trivial t22_8_aux_2) 
  have "Per A B R"
    by (metis t22_7__per ‹A ≠ D› ‹Cong A B C D› ‹Per A D C› 
        ‹Saccheri A B R S› assms(2) assms(3) assms(4) l8_2 not_cong_3412) 
  thus ?thesis
    by (meson Per_cases ‹B ≠ R› assms(2) bet_col col_per2__per 
        l8_5 not_col_permutation_5)  
qed

lemma t22_8__acute:
  assumes "Saccheri A B C D" and
    "Bet B C R" and
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "A B Lt R S"
  shows "Acute A B C"
proof -
  have "A ≠ B" 
    using assms(1) sac_distincts by blast 
  have "B ≠ C" 
    using assms(1) sac_distincts by blast 
  have "A B Lt S R" 
    using assms(6) Lt_cases by blast
  then obtain J where "Bet S J R ∧ Cong A B S J" 
    using Lt_def Le_def by blast 
  hence "Bet S J R" 
    by auto
  have "Cong A B S J"
    by (simp add: ‹Bet S J R ∧ Cong A B S J›)
  {
    assume "B = R" 
    hence "C = B" 
      using assms(2) between_identity by blast 
  }
  hence "B ≠ R" 
    using ‹B ≠ C› by blast
  have "J ≠ S"
    using ‹A ≠ B› ‹Cong A B S J› cong_diff by blast 
  have "R ≠ S"
    using ‹A B Lt S R› lt_diff by blast 
  have "J ≠ R"
    using ‹A B Lt S R› ‹Cong A B S J› cong__nlt by blast
  have "A B C CongA B C D"
    using assms(1) sac__conga by force
  have "S Out R J"
    by (simp add: Out_def ‹Bet S J R› ‹J ≠ S› ‹R ≠ S›) 
  have "Cong S J A B"
    using ‹Bet S J R ∧ Cong A B S J› not_cong_3412 by blast 
  have "C ≠ R" 
    using t22_8_aux_1 ‹Cong S J A B› ‹S Out R J› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Saccheri A B J S" 
    using t22_8_aux_2 ‹Cong S J A B› ‹S Out R J› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Saccheri D C J S" 
    using t22_8_aux_3 ‹Cong S J A B› ‹S Out R J› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "S J OS C B" 
    using t22_8_aux_4 ‹Cong S J A B› ‹S Out R J› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Coplanar A B C J" 
    using t22_8_aux_5 ‹Cong S J A B› ‹S Out R J› assms(1) assms(2) assms(3) 
      assms(5) by blast  
  have "B C D LtA R C D" 
  proof -
    have "A B J CongA B J S"
      by (simp add: ‹Saccheri A B J S› sac__conga)
    have "D C J CongA C J S"
      by (simp add: ‹Saccheri D C J S› sac__conga)
    have "J ≠ B"
      using ‹S J OS C B› os_distincts by blast 
    have "A B ParStrict J S"
      by (simp add: ‹Saccheri A B J S› sac__pars1234)
    have "D S ParStrict C J"
      by (simp add: ‹Saccheri D C J S› sac__pars1423)
    have "¬ Col B J S"
      using ‹A B ParStrict J S› par_strict_not_col_2 by blast
    have "C J TS D R" 
    proof -
      have "C J TS S R"
        by (metis Par_strict_cases ‹Bet S J R› ‹D S ParStrict C J› ‹J ≠ R› 
            bet__ts invert_two_sides par_strict_not_col_1) 
      moreover
      have "C J OS S D"
        using Par_strict_cases ‹D S ParStrict C J› l12_6 by blast 
      ultimately
      show ?thesis
        using l9_8_2 by blast 
    qed
    have "J B TS C S" 
    proof -
      have "J B TS R S"
        by (metis Col_perm ‹Bet S J R› ‹J ≠ R› ‹¬ Col B J S› bet__ts l9_2)
      moreover
      have "J B OS R C"
        by (metis TS_def ‹B ≠ C› ‹B ≠ R› assms(2) bet2__out calculation 
            invert_one_side l5_1 not_col_permutation_3 out_one_side) 
      ultimately
      show ?thesis
        using l9_8_2 by blast 
    qed
    have "¬ Col J B C"
      by (metis ‹B ≠ C› ‹Bet S J R› ‹J ≠ R› ‹¬ Col B J S› assms(2) bet_col 
          bet_col1 l6_21 not_col_permutation_2) 
    have "S J B LtA S J C" 
    proof -
      have "B InAngle S J C"
        by (simp add: ‹J B TS C S› ‹S J OS C B› invert_one_side l9_2 os_ts__inangle) 
      hence "S J B LeA S J C"
        by (simp add: inangle__lea) 
      moreover
      {
        assume "S J B CongA S J C" 
        have "S J OS B C"
          by (simp add: ‹S J OS C B› one_side_symmetry) 
        hence "J Out B C"
          using ‹S J B CongA S J C› conga_os__out by blast 
        hence "Col J B C"
          using out_col by auto 
        hence "False"
          using ‹¬ Col J B C› by auto 
      }
      hence "¬ S J B CongA S J C" 
        by auto
      ultimately
      show ?thesis
        by (simp add: LtA_def) 
    qed
    hence "A B J LtA D C J"
      by (meson conga_preserves_lta ‹A B J CongA B J S› ‹D C J CongA C J S› 
          conga_right_comm conga_sym_equiv) 
    moreover
    have "J B C LtA J C R"
      by (simp add: ‹C ≠ R› ‹¬ Col J B C› assms(2) l11_41 lta_left_comm 
          not_col_permutation_3) 
    moreover 
    have "D C ParStrict J S"
      by (simp add: ‹Saccheri D C J S› sac__pars1234) 
    hence "D C OS J R"
      using NCol_perm ‹Bet S J R› bet_col par_strict_all_one_side by blast 
    hence "SAMS D C J J C R"
      by (simp add: os_ts__sams ‹C J TS D R›) 
    moreover
    have "A B J J B C SumA B C D" 
    proof -
      have "J B C CongA J B C"
        using ‹B ≠ C› ‹J ≠ B› conga_refl by auto 
      moreover
      have "A B C CongA B C D"
        using ‹A B C CongA B C D› by blast 
      moreover
      have "A S ParStrict B J"
        by (simp add: ‹Saccheri A B J S› sac__pars1423) 
      hence "¬ B J OS A C"
        by (meson ‹J B TS C S› invert_two_sides l9_8_2 l9_9 
            one_side_symmetry pars__os3412) 
      moreover
      have "Coplanar A B J C"
        using ‹Coplanar A B C J› ncoplanar_perm_1 by blast 
      ultimately
      show ?thesis
        using SumA_def by blast 
    qed
    moreover
    have "D C J J C R SumA R C D"
      by (meson ‹C J TS D R› suma_right_comm ts__suma_1) 
    ultimately
    show ?thesis 
      using sams_lta2_suma2__lta by blast
  qed
  hence "Acute B C D"
    using acute_chara_2 assms(2) by blast 
  thus ?thesis
    by (meson ‹A B C CongA B C D› ‹A ≠ B› ‹B ≠ C› acute__not_obtuse 
        acute_not_per angle_partition conga_obtuse__obtuse l11_17) 
qed

lemma t22_8__obtuse:
  assumes "Saccheri A B C D" and
    "Bet B C R" and 
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "R S Lt A B"
  shows "Obtuse A B C"
proof-
  have "A ≠ B" 
    using assms(1) sac_distincts by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  obtain I where "Bet S R I ∧ Cong S I A B" 
    using Lt_def by (meson Le_cases assms(6) l5_5_1)  
  hence "Bet S R I" 
    by auto
  have "Cong S I A B"
    by (simp add: ‹Bet S R I ∧ Cong S I A B›) 
  hence "I ≠ S"
    using ‹A ≠ B› cong_reverse_identity by blast 
  have "A D ParStrict B C"
    by (simp add: assms(1) sac__pars1423) 
  have "I ≠ R"
    using ‹Bet S R I ∧ Cong S I A B› assms(6) cong__nlt lt_left_comm by blast 
  have "S ≠ R"
    by (metis col124__nos ‹A D ParStrict B C› assms(2) assms(3) 
        bet_col par_strict_all_one_side) 
  have "A B C CongA B C D"
    by (meson assms(1) sac__conga)
  have "S Out R I"
    using ‹Bet S R I› ‹S ≠ R› bet_out by presburger 
  have "C ≠ R" 
    using t22_8_aux_1 ‹Cong S I A B› ‹S Out R I› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Saccheri A B I S" 
    using t22_8_aux_2 ‹Cong S I A B› ‹S Out R I› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Saccheri D C I S" 
    using t22_8_aux_3 ‹Cong S I A B› ‹S Out R I› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "S I OS C B" 
    using t22_8_aux_4 ‹Cong S I A B› ‹S Out R I› assms(1) assms(2) assms(3) 
      assms(5) assms(4) by blast 
  have "Coplanar A B C I" 
    using t22_8_aux_5 ‹Cong S I A B› ‹S Out R I› assms(1) assms(2) assms(3) 
      assms(5) by blast  
  have "R C D LtA B C D"
  proof -
    have "A B I CongA B I S"
      by (simp add: ‹Saccheri A B I S› sac__conga) 
    have "D C I CongA C I S"
      by (simp add: ‹Saccheri D C I S› sac__conga) 
    have "I ≠ C"
      using ‹S I OS C B› os_distincts by blast 
    have "I ≠ B"
      using ‹S I OS C B› os_distincts by blast 
    have "A B ParStrict I S"
      by (simp add: ‹Saccheri A B I S› sac__pars1234) 
    have "D S ParStrict C I"
      by (simp add: ‹Saccheri D C I S› sac__pars1423) 
    have "C R OS D S"
      by (meson ‹A D ParStrict B C› ‹C ≠ R› assms(2) assms(3) assms(4) 
          bet_col bet_col1 par_strict_col4__par_strict pars__os3412) 
    hence "C R OS S D"
      by (simp add: one_side_symmetry) 
    have "¬ Col C R S"
      using ‹C R OS S D› one_side_not_col123 by blast
    have "¬ Col B C I" 
      by (metis Bet_cases ‹Bet S R I› ‹C ≠ B› ‹I ≠ R› ‹¬ Col C R S› assms(2) 
          bet_col1 between_exchange2 col_transitivity_2 point_construction_different) 
    have "C R TS S I"
      using ‹Bet S R I› ‹I ≠ R› ‹¬ Col C R S› bet__ts invert_two_sides 
        not_col_permutation_4 by presburger 
    hence "C R TS I D"
      using ‹C R OS S D› l9_2 l9_8_2 by blast 
    have "I B C LtA I C R"
      by (simp add: l11_41 Tarski_neutral_dimensionless_axioms ‹C ≠ R› 
          ‹¬ Col B C I› assms(2) lta_left_comm not_col_permutation_4) 
    moreover
    have "D C I LtA A B I" 
    proof -
      have "R S OS C B"
        by (meson ‹C ≠ R› ‹¬ Col C R S› assms(2) bet_out_1 
            col_permutation_2 out_one_side)
      have "S I C CongA D C I"
        by (meson ‹D C I CongA C I S› conga_right_comm not_conga_sym) 
      moreover
      have "S I B CongA A B I"
        by (meson ‹A B I CongA B I S› conga_right_comm conga_sym) 
      moreover
      have "S I C LtA S I B" 
      proof -
        have "S I C LeA S I B" 
        proof -
          have "C InAngle S I B" 
          proof -
            have "I S OS B C"
              using ‹S I OS C B› invert_one_side one_side_symmetry by blast 
            moreover
            have "I B OS S C" 
            proof -
              have "I B OS S R"
                by (metis NCol_perm ‹Bet S R I› ‹I ≠ R› bet_out_1 calculation 
                    one_side_not_col123 one_side_symmetry out_one_side) 
              moreover
              have "I B OS R C"
                by (metis NCol_perm Out_cases ‹C ≠ B› ‹¬ Col B C I› assms(2) 
                    bet_out invert_one_side out_one_side) 
              ultimately
              show ?thesis
                using one_side_transitivity by blast 
            qed
            ultimately
            show ?thesis
              by (simp add: os2__inangle) 
          qed
          moreover
          have "S I C CongA S I C"
            using ‹I ≠ C› ‹I ≠ S› conga_refl by auto 
          ultimately
          show ?thesis
            by (simp add: inangle__lea) 
        qed
        moreover
        have "¬ S I C CongA S I B"
          by (meson Bet_cases Col_def Out_def ‹S I OS C B› ‹¬ Col B C I› conga_os__out) 
        ultimately
        show ?thesis
          by (simp add: LtA_def) 
      qed
      ultimately
      show ?thesis
        using conga_preserves_lta by auto 
    qed
    moreover
    have "I C OS R D" 
    proof -
      have "I C OS R S"
        using TS_def ‹Bet S R I› ‹C R TS S I› ‹I ≠ R› bet_out_1 out_one_side by presburger 
      moreover
      have "I C OS S D"
        using Par_strict_cases ‹D S ParStrict C I› l12_6 by blast 
      ultimately
      show ?thesis
        using one_side_transitivity by blast 
    qed
    hence "SAMS I C R R C D"
      by (simp add: os_ts__sams ‹C R TS I D›) 
    moreover
    have "I C R R C D SumA D C I"
      by (simp add: ts__suma_1 ‹C R TS I D› suma_right_comm) 
    moreover
    have "I B C B C D SumA A B I" 
    proof -
      have "C B A CongA B C D"
        by (simp add: ‹A B C CongA B C D› conga_left_comm) 
      moreover
      have "¬ B C OS I A" 
      proof -
        have "B C OS A S"
          by (meson ‹A D ParStrict B C› assms(3) bet_col par_strict_all_one_side 
              par_strict_symmetry)
        have "B C TS S I"
          by (metis ‹B C OS A S› ‹C R TS S I› assms(2) bet_col bet_col1 col3 
              col_preserves_two_sides col_trivial_3 os_distincts) 
        moreover
        have "B C OS S A"
          by (simp add: ‹B C OS A S› one_side_symmetry) 
        ultimately
        show ?thesis
          by (meson l9_2 l9_8_2 l9_9_bis) 
      qed
      moreover
      have "Coplanar I B C A"
        using ‹Coplanar A B C I› ncoplanar_perm_21 by blast 
      moreover
      have "I B A CongA A B I"
        by (simp add: ‹A ≠ B› ‹I ≠ B› conga_refl conga_right_comm) 
      ultimately
      show ?thesis
        using SumA_def by blast 
    qed
    ultimately
    show ?thesis
      by (meson sams_lta2_suma2__lta456) 
  qed
  hence "Obtuse B C D"
    using assms(2) lta_distincts obtuse_chara by blast 
  thus ?thesis
    using ‹A B C CongA B C D› conga_obtuse__obtuse not_conga_sym by blast 
qed

lemma t22_8__cong:
  assumes "Saccheri A B C D" and
    "Bet B C R" and
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "Per A B C"
  shows "Cong R S A B" 
proof -
  have "A ≠ B" 
    using assms(1) sac_distincts by blast 
  have "C ≠ B"
    using assms(1) sac_distincts by blast 
  {
    assume "¬ Cong R S A B"
    have "A B C LtA A B C" 
    proof -
      {
        assume "R S Le A B" 
        hence "Obtuse A B C" 
          using assms(1) assms(2) assms(3) assms(4) assms(5) t22_8__obtuse
          by (meson ‹¬ Cong R S A B› le_anti_symmetry nle__lt)
        hence "Cong R S A B"
          using assms(1) assms(6) obtuse__nsams per2__sams sac_distincts by blast
      }
      moreover
      {
        assume "A B Le R S" 
        hence "A B Lt R S"
          using ‹¬ Cong R S A B› le_anti_symmetry nlt__le by blast 
        hence "Acute A B C"
          using assms(1) assms(2) assms(3) assms(4) assms(5) t22_8__acute by blast 
        hence "Cong R S A B"
          using acute_not_per assms(6) by blast 
      }
      ultimately
      show ?thesis
        using ‹¬ Cong R S A B› local.le_cases by blast
    qed
    hence "False"
      by (simp add: nlta) 
  }
  thus ?thesis
    by auto 
qed

lemma t22_8__lt1256:
  assumes "Saccheri A B C D" and
    "Bet B C R" and
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "Acute A B C"
  shows "A B Lt R S" 
proof -
  have "Cong R S A B ⟶ A B Lt R S"
    using acute_not_per assms(1) assms(2) assms(3) assms(4) assms(5) 
      assms(6) t22_8__per by blast 
  moreover
  {
    assume "¬ Cong R S A B" 
    { 
      assume "R S Le A B"
      hence "R S Lt A B"
        by (simp add: Lt_def ‹¬ Cong R S A B›) 
      hence "Obtuse A B C"
        using assms(1) assms(2) assms(3) assms(4) assms(5) t22_8__obtuse by blast 
      hence "False"
        using acute__not_obtuse assms(6) by auto 
    }
    hence "A B Lt R S"
      using nlt__le by blast 
  }
  ultimately
  show ?thesis 
    by auto
qed

lemma t22_8__lt5612:
  assumes "Saccheri A B C D" and
    "Bet B C R" and
    "Bet A D S" and
    "D ≠ S" and
    "Per A S R" and
    "Obtuse A B C"
  shows "R S Lt A B" 
proof -
  have "Cong R S A B ⟶ R S Lt A B"
    by (metis Cong_perm assms(1) assms(2) assms(3) assms(4) assms(5) 
        assms(6) cong__nlt cong_sac__per_aux2 lt_sac__obtuse_aux2 t22_8__per)
  moreover
  {
    assume "¬ Cong R S A B" 
    { 
      assume "A B Le R S"
      hence "A B Lt R S"
        using ‹¬ Cong R S A B› le_anti_symmetry nlt__le by blast
      hence "Acute A B C"
        using assms(1) assms(2) assms(3) assms(4) assms(5) t22_8__acute by blast 
      hence "False"
        using acute__not_obtuse assms(6) by blast 
    }
    hence "R S Lt A B"
      using nlt__le by blast 
  }
  ultimately
  show ?thesis 
    by auto
qed

lemma t22_9_aux_1:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Per S R M"
  shows "Per Q P M" 
proof cases
  assume "Q = S"
  thus ?thesis
  proof -
    have "Per P S N" 
      using ‹Q = S› assms(1) l8_2 Lambert_def by blast
    hence "R = P"
      using Lambert_def by (meson assms(2) assms(3) bet_col between_symmetry 
          col_per2__per l8_2 l8_7)
    thus ?thesis
      using ‹Q = S› assms(5) by blast
  qed
next
  assume "Q ≠ S"
  obtain P' where "M Midpoint P P'"
    using symmetric_point_construction by blast
  hence "M Midpoint P' P"
    by (simp add: l7_2)
  obtain Q' where "N Midpoint Q Q'"
    using symmetric_point_construction by blast
  hence "N Midpoint Q' Q"
    by (simp add: l7_2)
  obtain R' where "M Midpoint R R'"
    using symmetric_point_construction by blast
  hence "M Midpoint R' R"
    by (simp add: l7_2)
  obtain S' where "N Midpoint S S'"
    using symmetric_point_construction by blast
  hence "N Midpoint S' S"
    by (simp add: l7_2)
  have "Saccheri S' R' R S"
    using ‹M Midpoint R' R› ‹N Midpoint S' S› assms(2) lam6534_mid2__sac by blast
  hence "Cong S' R' R S" 
    using Saccheri_def by simp
  have "Saccheri Q' P' P Q"
    using ‹M Midpoint P' P› ‹N Midpoint Q' Q› assms(1) lam6534_mid2__sac by blast
  hence "Cong Q' P' P Q" 
    using Saccheri_def by simp
  have "S' R' R CongA R' R S"
    by (simp add: ‹Saccheri S' R' R S› sac__conga)
  have "Q' P' P CongA P' P Q"
    by (simp add: ‹Saccheri Q' P' P Q› sac__conga)
  have "Bet P' P R"
    by (metis ‹M Midpoint P P'› assms(3) bet_out__bet between_trivial2 midpoint_out) 
  have "Bet Q' Q S"
    by (metis ‹N Midpoint Q Q'› assms(4) bet_out__bet between_trivial2 midpoint_out)
  have "Bet R' P R"
    using ‹M Midpoint R' R› assms(3) between_exchange2 midpoint_bet by blast
  have "Bet S' Q S"
    using ‹N Midpoint S' S› assms(4) between_exchange2 midpoint_bet by blast
  have "Per N S R"
    using Lambert_def assms(2) by presburger 
  hence "Per Q' S R"
    by (metis NCol_cases ‹Bet Q' Q S› ‹Q ≠ S› assms(4) bet_col bet_out_1 
        col_per2__per l8_20_1_R1 out_diff2) 
  have "Per S' Q P" 
  proof -
    have "Per N Q P"
      using Lambert_def assms(1) by auto 
    moreover
    have "N ≠ Q"
      using ‹N Midpoint Q Q'› ‹Saccheri Q' P' P Q› is_midpoint_id 
        sac_distincts by blast 
    moreover
    have "Col Q N S'"
      by (meson ‹Bet S' Q S› ‹Q ≠ S› assms(4) bet_col col_permutation_1 l6_16_1) 
    ultimately
    show ?thesis 
      using l8_3 by blast 
  qed
  have "S' ≠ Q"
    using ‹Bet Q' Q S› ‹N Midpoint Q' Q› ‹N Midpoint S S'› ‹Q ≠ S› 
      bet_neq12__neq l7_9 by blast 
  have "P ≠ P'"
    using ‹Saccheri Q' P' P Q› sac_distincts by blast 
  moreover
  have "Per S R R'"
    by (metis Mid_cases Per_perm ‹M Midpoint R R'› assms(5) col_per2__per 
        l7_3_2 l8_5 midpoint_col sym_preserve_diff) 
  hence "Per S' R' R"
    by (meson Per_cases ‹S' R' R CongA R' R S› conga_sym l11_17) 
  hence "Cong P Q S' R'"
    by (meson ‹Bet R' P R› ‹Bet S' Q S› ‹Per S' Q P› ‹S' ≠ Q› 
        ‹Saccheri S' R' R S› l8_2 t22_7__cong) 
  hence "Cong Q' P' S' R'"
    using ‹Cong Q' P' P Q› cong_transitivity by blast 
  hence "Cong Q' P' R S"
    using ‹Cong S' R' R S› cong_transitivity by blast 
  hence "Cong R S Q' P'"
    by (simp add: cong_symmetry) 
  hence "Per Q P P'" 
    using t22_8__per ‹Saccheri Q' P' P Q› ‹Bet P' P R› ‹Bet Q' Q S› ‹Q ≠ S› 
      ‹Per Q' S R› ‹Q' P' P CongA P' P Q› l11_17 l8_2 by blast
  moreover
  have "Col P P' M"
    by (simp add: Col_def ‹M Midpoint P' P› midpoint_bet) 
  ultimately
  show ?thesis
    using per_col by blast 
qed

lemma t22_9_aux_2:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Per Q P M"
  shows "Per S R M" 
proof cases
  assume "Q = S"
  thus ?thesis
  proof -
    have "Per P S N"
      using ‹Q = S› assms(1) l8_2  Lambert_def by blast
    hence "R = P"
      using Lambert_def 
      by (meson assms(2) assms(3) bet_col between_symmetry col_per2__per l8_2 l8_7)
    thus ?thesis
      using ‹Q = S› assms(5) by blast
  qed
next
  assume "Q ≠ S"
  obtain P' where "M Midpoint P P'"
    using symmetric_point_construction by blast
  hence "M Midpoint P' P"
    by (simp add: l7_2)
  obtain Q' where "N Midpoint Q Q'"
    using symmetric_point_construction by blast
  hence "N Midpoint Q' Q"
    by (simp add: l7_2)
  obtain R' where "M Midpoint R R'"
    using symmetric_point_construction by blast
  hence "M Midpoint R' R"
    by (simp add: l7_2)
  obtain S' where "N Midpoint S S'"
    using symmetric_point_construction by blast
  hence "N Midpoint S' S"
    by (simp add: l7_2)
  have "Saccheri S' R' R S"
    using ‹M Midpoint R' R› ‹N Midpoint S' S› assms(2) lam6534_mid2__sac by blast
  hence "Cong S' R' R S" 
    using Saccheri_def by simp
  have "Saccheri Q' P' P Q"
    using ‹M Midpoint P' P› ‹N Midpoint Q' Q› assms(1) lam6534_mid2__sac by blast
  hence "Cong Q' P' P Q" 
    using Saccheri_def by simp
  have "S' R' R CongA R' R S"
    by (simp add: ‹Saccheri S' R' R S› sac__conga)
  have "Q' P' P CongA P' P Q"
    by (simp add: ‹Saccheri Q' P' P Q› sac__conga)
  have "Bet P' P R"
    by (metis ‹M Midpoint P P'› assms(3) bet_out__bet between_trivial2 midpoint_out) 
  have "Bet Q' Q S"
    by (metis ‹N Midpoint Q Q'› assms(4) bet_out__bet between_trivial2 midpoint_out)
  have "Bet R' P R"
    using ‹M Midpoint R' R› assms(3) between_exchange2 midpoint_bet by blast
  have "Bet S' Q S"
    using ‹N Midpoint S' S› assms(4) between_exchange2 midpoint_bet by blast
  have "Per N S R"
    using Lambert_def assms(2) by presburger 
  hence "Per Q' S R"
    by (metis NCol_cases ‹Bet Q' Q S› ‹Q ≠ S› assms(4) bet_col bet_out_1 
        col_per2__per l8_20_1_R1 out_diff2) 
  have "Per S' Q P" 
  proof -
    have "Per N Q P"
      using Lambert_def assms(1) by auto 
    moreover
    have "N ≠ Q"
      using ‹N Midpoint Q Q'› ‹Saccheri Q' P' P Q› is_midpoint_id sac_distincts by blast 
    moreover
    have "Col Q N S'"
      by (meson ‹Bet S' Q S› ‹Q ≠ S› assms(4) bet_col col_permutation_1 l6_16_1) 
    ultimately
    show ?thesis 
      using l8_3 by blast 
  qed
  have "S' ≠ Q"
    using ‹Bet Q' Q S› ‹N Midpoint Q' Q› ‹N Midpoint S S'› ‹Q ≠ S› 
      bet_neq12__neq l7_9 by blast 
  have "R ≠ R'"
    using ‹Saccheri S' R' R S› sac_distincts by blast 
  moreover
  have "Col R R' M"
    by (simp add: Col_def ‹M Midpoint R' R› midpoint_bet) 
  moreover
  have "Per Q P P'"
    by (metis Per_cases cong_diff_2 ‹M Midpoint P P'› ‹M Midpoint P' P› 
        assms(5) col_per2__per l8_5 midpoint_col midpoint_cong) 
  hence "Per Q' P' P"
    by (meson ‹Q' P' P CongA P' P Q› l11_17 l8_2 not_conga_sym) 
  hence "Cong R S Q' P'"
    using ‹Bet P' P R› ‹Bet Q' Q S› ‹Per Q' S R› ‹Q ≠ S› ‹Saccheri Q' P' P Q› 
      t22_8__cong by blast 
  hence "Cong S' R' P' Q'"
    using ‹Cong S' R' R S› cong_transitivity not_cong_1243 by blast 
  hence "Cong S' R' P Q"
    using Cong_cases ‹Cong Q' P' P Q› cong_inner_transitivity by blast 
  hence "Cong P Q S' R'"
    using not_cong_3412 by blast 
  hence "Per S' R' R"
    using ‹Bet R' P R› ‹Bet S' Q S› ‹Per S' Q P› ‹Q ≠ S› ‹S' ≠ Q› 
      ‹Saccheri S' R' R S› l8_2 t22_7__per by blast 
  hence "Per S R R'"
    using Per_perm ‹S' R' R CongA R' R S› l11_17 by blast 
  ultimately
  show ?thesis
    using per_col by blast 
qed

lemma t22_9_aux_3:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Acute S R M"
  shows "Acute Q P M" 
proof cases
  assume "Q = S"
  thus ?thesis
  proof -
    have "Per P S N"
      using ‹Q = S› assms(1) l8_2 Lambert_def by blast
    hence "R = P"
      using Lambert_def 
      by (meson assms(2) assms(3) bet_col between_symmetry col_per2__per l8_2 l8_7)
    thus ?thesis
      using ‹Q = S› assms(5) by blast
  qed
next
  assume "Q ≠ S"
  obtain P' where "M Midpoint P P'"
    using symmetric_point_construction by blast
  hence "M Midpoint P' P"
    by (simp add: l7_2)
  obtain Q' where "N Midpoint Q Q'"
    using symmetric_point_construction by blast
  hence "N Midpoint Q' Q"
    by (simp add: l7_2)
  obtain R' where "M Midpoint R R'"
    using symmetric_point_construction by blast
  hence "M Midpoint R' R"
    by (simp add: l7_2)
  obtain S' where "N Midpoint S S'"
    using symmetric_point_construction by blast
  hence "N Midpoint S' S"
    by (simp add: l7_2)
  have "Saccheri S' R' R S"
    using ‹M Midpoint R' R› ‹N Midpoint S' S› assms(2) lam6534_mid2__sac by blast
  hence "Cong S' R' R S" 
    using Saccheri_def by simp
  have "Saccheri Q' P' P Q"
    using ‹M Midpoint P' P› ‹N Midpoint Q' Q› assms(1) lam6534_mid2__sac by blast
  hence "Cong Q' P' P Q" 
    using Saccheri_def by simp
  have "S' R' R CongA R' R S"
    by (simp add: ‹Saccheri S' R' R S› sac__conga)
  have "Q' P' P CongA P' P Q"
    by (simp add: ‹Saccheri Q' P' P Q› sac__conga)
  have "Bet P' P R"
    by (metis ‹M Midpoint P P'› assms(3) bet_out__bet between_trivial2 midpoint_out) 
  have "Bet Q' Q S"
    by (metis ‹N Midpoint Q Q'› assms(4) bet_out__bet between_trivial2 midpoint_out)
  have "Bet R' P R"
    using ‹M Midpoint R' R› assms(3) between_exchange2 midpoint_bet by blast
  have "Bet S' Q S"
    using ‹N Midpoint S' S› assms(4) between_exchange2 midpoint_bet by blast
  have "Per N S R"
    using Lambert_def assms(2) by presburger 
  hence "Per Q' S R"
    by (metis NCol_cases ‹Bet Q' Q S› ‹Q ≠ S› assms(4) bet_col 
        bet_out_1 col_per2__per l8_20_1_R1 out_diff2) 
  have "Per S' Q P" 
  proof -
    have "Per N Q P"
      using Lambert_def assms(1) by auto 
    moreover
    have "N ≠ Q"
      using ‹N Midpoint Q Q'› ‹Saccheri Q' P' P Q› is_midpoint_id sac_distincts by blast 
    moreover
    have "Col Q N S'"
      by (meson ‹Bet S' Q S› ‹Q ≠ S› assms(4) bet_col col_permutation_1 l6_16_1) 
    ultimately
    show ?thesis 
      using l8_3 by blast 
  qed
  have "S' ≠ Q"
    using ‹Bet Q' Q S› ‹N Midpoint Q' Q› ‹N Midpoint S S'› ‹Q ≠ S› 
      bet_neq12__neq l7_9 by blast 
  have "Acute  Q' P' P" 
  proof -
    have "Saccheri Q' P' P Q"
      by (simp add: ‹Saccheri Q' P' P Q›) 
    moreover
    have "Bet P' P R"
      by (simp add: ‹Bet P' P R›) 
    moreover
    have "Bet Q' Q S"
      by (simp add: ‹Bet Q' Q S›) 
    moreover
    have "Q ≠ S"
      by (simp add: ‹Q ≠ S›) 
    moreover
    have "Per Q' S R"
      by (simp add: ‹Per Q' S R›) 
    moreover
    have "S R M CongA  S' R' R" 
    proof -
      have "S R R' CongA S' R' R"
        by (meson ‹S' R' R CongA R' R S› conga_left_comm conga_sym_equiv) 
      moreover
      have "R Out S S"
        using acute_distincts assms(5) out_trivial by blast 
      moreover
      have "R Out M R'"
        using ‹M Midpoint R R'› ‹S' R' R CongA R' R S› conga_diff2 midpoint_out by blast 
      moreover
      have "R' ≠ S'"
        using calculation(1) conga_diff45 by blast 
      hence "R' Out S' S'"
        using out_trivial by presburger 
      moreover
      have "R' Out R R"
        by (metis calculation(1) conga_diff2 out_trivial) 
      moreover
      have "Q' P' P CongA Q P M" 
      proof -
        have "Q' P' P CongA Q P P'"
          by (simp add: ‹Q' P' P CongA P' P Q› conga_right_comm) 
        moreover
        have "P' ≠ Q'"
          using CongA_def calculation by blast 
        hence "P' Out Q' Q'"
          using bet_out_1 between_trivial2 by auto 
        moreover
        have "P' Out P P"
          using ‹Q' P' P CongA P' P Q› conga_diff2 out_trivial by blast 
        moreover
        have "P Out Q Q"
          using ‹Q' P' P CongA P' P Q› conga_diff56 out_trivial by force 
        moreover
        have "P Out M P'"
          using ‹M Midpoint P P'› calculation(3) midpoint_out out_diff2 by blast 
        ultimately
        show ?thesis
          using l11_10 by blast 
      qed
      ultimately
      show ?thesis
        using l11_10 by blast 
    qed
    hence "Acute S' R' R"
      using acute_conga__acute assms(5) by blast 
    hence "P Q Lt S' R'"
      using ‹Bet R' P R› ‹Bet S' Q S› ‹Per S' Q P› ‹S' ≠ Q› 
        ‹Saccheri S' R' R S› calculation(4) l8_2 t22_7__lt5612 by blast  
    hence "Q' P' Lt R S"
      by (meson ‹Cong Q' P' P Q› ‹Cong S' R' R S› cong2_lt__lt lt_right_comm 
          not_cong_3421) 
    ultimately
    show ?thesis
      using t22_8__acute by blast 
  qed
  moreover
  have "Q' P' P CongA Q P M" 
  proof -
    have "Q' P' P CongA Q P P'"
      by (simp add: ‹Q' P' P CongA P' P Q› conga_right_comm) 
    moreover
    have "P' ≠ Q'"
      using CongA_def calculation by blast 
    hence "P' Out Q' Q'"
      using bet_out_1 between_trivial2 by auto 
    moreover
    have "P' Out P P"         
      using ‹Q' P' P CongA P' P Q› conga_diff2 out_trivial by blast 
    moreover
    have "P Out Q Q" 
      using ‹Q' P' P CongA P' P Q› conga_diff56 out_trivial by force 
    moreover
    have "P Out M P'"   
      using ‹M Midpoint P P'› calculation(3) midpoint_out out_diff2 by blast 
    ultimately
    show ?thesis
      using l11_10 by blast 
  qed
  ultimately
  show ?thesis
    using acute_conga__acute by blast 
qed

lemma t22_9_aux_4:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Acute Q P M"
  shows
    "Acute S R M" 
proof cases
  assume "Q = S"
  thus ?thesis
  proof -
    have "Per P S N"
      using ‹Q = S› assms(1) l8_2  Lambert_def by blast
    hence "R = P"
      using Lambert_def 
      by (meson assms(2) assms(3) bet_col between_symmetry col_per2__per l8_2 l8_7)
    thus ?thesis
      using ‹Q = S› assms(5) by blast
  qed
next
  assume "Q ≠ S"
  obtain P' where "M Midpoint P P'"
    using symmetric_point_construction by blast
  hence "M Midpoint P' P"
    by (simp add: l7_2)
  obtain Q' where "N Midpoint Q Q'"
    using symmetric_point_construction by blast
  hence "N Midpoint Q' Q"
    by (simp add: l7_2)
  obtain R' where "M Midpoint R R'"
    using symmetric_point_construction by blast
  hence "M Midpoint R' R"
    by (simp add: l7_2)
  obtain S' where "N Midpoint S S'"
    using symmetric_point_construction by blast
  hence "N Midpoint S' S"
    by (simp add: l7_2)
  have "Saccheri S' R' R S"
    using ‹M Midpoint R' R› ‹N Midpoint S' S› assms(2) lam6534_mid2__sac by blast
  hence "Cong S' R' R S" 
    using Saccheri_def by simp
  have "Saccheri Q' P' P Q"
    using ‹M Midpoint P' P› ‹N Midpoint Q' Q› assms(1) lam6534_mid2__sac by blast
  hence "Cong Q' P' P Q" 
    using Saccheri_def by simp
  have "S' R' R CongA R' R S"
    by (simp add: ‹Saccheri S' R' R S› sac__conga)
  have "Q' P' P CongA P' P Q"
    by (simp add: ‹Saccheri Q' P' P Q› sac__conga)
  have "Bet P' P R"
    by (metis ‹M Midpoint P P'› assms(3) bet_out__bet between_trivial2 midpoint_out) 
  have "Bet Q' Q S"
    by (metis ‹N Midpoint Q Q'› assms(4) bet_out__bet between_trivial2 midpoint_out)
  have "Bet R' P R"
    using ‹M Midpoint R' R› assms(3) between_exchange2 midpoint_bet by blast
  have "Bet S' Q S"
    using ‹N Midpoint S' S› assms(4) between_exchange2 midpoint_bet by blast
  have "Per N S R"
    using Lambert_def assms(2) by presburger 
  hence "Per Q' S R"
    by (metis NCol_cases ‹Bet Q' Q S› ‹Q ≠ S› assms(4) bet_col bet_out_1 
        col_per2__per l8_20_1_R1 out_diff2) 
  have "Per S' Q P" 
  proof -
    have "Per N Q P"
      using Lambert_def assms(1) by auto 
    moreover
    have "N ≠ Q"
      using ‹N Midpoint Q Q'› ‹Saccheri Q' P' P Q› is_midpoint_id 
        sac_distincts by blast 
    moreover
    have "Col Q N S'"
      by (meson ‹Bet S' Q S› ‹Q ≠ S› assms(4) bet_col col_permutation_1 l6_16_1) 
    ultimately
    show ?thesis 
      using l8_3 by blast 
  qed
  have "S' ≠ Q"
    using ‹Bet Q' Q S› ‹N Midpoint Q' Q› ‹N Midpoint S S'› ‹Q ≠ S› 
      bet_neq12__neq l7_9 by blast 
  have "Q' P' P CongA Q P M" 
  proof -
    have "Q' P' P CongA Q P P'"
      by (simp add: ‹Q' P' P CongA P' P Q› conga_right_comm) 
    moreover
    have "P' ≠ Q'"
      using CongA_def calculation by blast 
    hence "P' Out Q' Q'"
      using bet_out_1 between_trivial2 by auto 
    moreover
    have "P' Out P P"         
      using ‹Q' P' P CongA P' P Q› conga_diff2 out_trivial by blast 
    moreover
    have "P Out Q Q" 
      using ‹Q' P' P CongA P' P Q› conga_diff56 out_trivial by force 
    moreover
    have "P Out M P'"   
      using ‹M Midpoint P P'› calculation(3) midpoint_out out_diff2 by blast 
    ultimately
    show ?thesis
      using l11_10 by blast 
  qed
  hence "Q P M CongA Q' P' P"
    using not_conga_sym by blast     
  hence "Acute Q' P' P"
    using acute_conga__acute assms(5) by blast 
  hence "Q' P' Lt R S"
    using ‹Bet P' P R› ‹Bet Q' Q S› ‹Per Q' S R› ‹Q ≠ S› 
      ‹Saccheri Q' P' P Q› t22_8__lt1256 by blast 
  hence "P Q Lt S' R'"
    by (meson ‹Cong Q' P' P Q› ‹Cong S' R' R S› cong2_lt__lt not_cong_3412) 
  hence "Acute S' R' R" 
    using t22_7__acute Per_cases ‹Bet R' P R› ‹Bet S' Q S› ‹Per S' Q P› 
      ‹S' ≠ Q› ‹Saccheri S' R' R S› by blast 
  moreover
  have "S R M CongA  S' R' R" 
  proof -
    have "S R R' CongA S' R' R"
      by (meson ‹S' R' R CongA R' R S› conga_left_comm conga_sym_equiv) 
    moreover
    have "R ≠ S"
      using ‹S' R' R CongA R' R S› conga_diff56 by blast 
    hence "R Out S S"
      using bet_out_1 between_trivial2 by auto
    moreover
    have "R Out M R'"
      using ‹M Midpoint R R'› ‹S' R' R CongA R' R S› conga_diff2 
        midpoint_out by blast 
    moreover
    have "R' ≠ S'"
      using calculation(1) conga_diff45 by blast 
    hence "R' Out S' S'"
      using out_trivial by presburger 
    moreover
    have "R' Out R R"
      by (metis calculation(1) conga_diff2 out_trivial) 
    moreover
    have "Q' P' P CongA Q P M" 
    proof -
      have "Q' P' P CongA Q P P'"
        by (simp add: ‹Q' P' P CongA P' P Q› conga_right_comm) 
      moreover
      have "P' ≠ Q'"
        using CongA_def calculation by blast 
      hence "P' Out Q' Q'"
        using bet_out_1 between_trivial2 by auto 
      moreover
      have "P' Out P P"
        using ‹Q' P' P CongA P' P Q› conga_diff2 out_trivial by blast 
      moreover
      have "P Out Q Q"
        using ‹Q' P' P CongA P' P Q› conga_diff56 out_trivial by force 
      moreover
      have "P Out M P'"
        using ‹M Midpoint P P'› calculation(3) midpoint_out out_diff2 by blast 
      ultimately
      show ?thesis
        using l11_10 by blast 
    qed
    hence "Acute S' R' R"
      using ‹Acute S' R' R› by blast
    hence "P Q Lt S' R'"
      by (simp add: ‹P Q Lt S' R'›)
    hence "Q' P' Lt R S"
      by (meson ‹Cong Q' P' P Q› ‹Cong S' R' R S› cong2_lt__lt 
          lt_right_comm not_cong_3421) 
    ultimately
    show ?thesis
      using l11_10 by blast
  qed
  hence "S' R' R CongA S R M"
    using not_conga_sym by blast 
  ultimately
  show ?thesis
    using acute_conga__acute by blast
qed

lemma t22_9_aux:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S"
  shows "(Per S R M ⟷ Per Q P M) ∧ (Acute S R M ⟷ Acute Q P M)"
  by (metis assms(1) assms(2) assms(3) assms(4) t22_9_aux_1 t22_9_aux_2 
      t22_9_aux_3 t22_9_aux_4) 

lemma t22_9__per_1:
  assumes "Lambert N M P Q" and 
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Per S R M"
  shows "Per Q P M"
  using assms(1) assms(2) assms(3) assms(4) assms(5) t22_9_aux_1 by blast 

lemma t22_9__per_2:
  assumes "Lambert N M P Q" and 
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" and
    "Per Q P M"
  shows "Per S R M"
  using assms(1) assms(2) assms(3) assms(4) assms(5) t22_9_aux_2 by blast 

lemma t22_9__per:
  assumes "Lambert N M P Q" and 
    "Lambert N M R S" and
    "Bet M P R" and 
    "Bet N Q S" 
  shows "Per S R M ⟷ Per Q P M"
  by (meson assms(1) assms(2) assms(3) assms(4) t22_9_aux_1 t22_9_aux_2) 

lemma t22_9__acute_1:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S" and
    "Acute S R M"
  shows "Acute Q P M"
  using assms(1) assms(2) assms(3) assms(4) assms(5) t22_9_aux by blast 

lemma t22_9__acute_2:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S" and
    "Acute Q P M"
  shows "Acute S R M"
  using assms(1) assms(2) assms(3) assms(4) assms(5) t22_9_aux by blast 

lemma t22_9__acute:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S"
  shows "Acute S R M ⟷ Acute Q P M"
  by (meson assms(1) assms(2) assms(3) assms(4) t22_9_aux_3 t22_9_aux_4) 

lemma t22_9__obtuse_1:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S" and
    "Obtuse S R M"
  shows "Obtuse Q P M" 
proof -
  have "Acute Q P M ∨ Per Q P M ∨ Obtuse Q P M"
    by (metis angle_partition l8_20_1_R1 l8_5)
  moreover
  {
    assume "Acute Q P M"
    hence "S R M LtA S R M"
      using acute_obtuse__lta assms(1) assms(2) assms(3) assms(4) 
        assms(5) t22_9_aux by blast 
    hence "False"
      by (simp add: nlta) 
  }
  moreover
  {
    assume "Per Q P M"
    hence "S R M LtA S R M"
      by (metis assms(1) assms(2) assms(3) assms(4) assms(5) 
          obtuse_distincts obtuse_per__lta t22_9_aux_2) 
    hence "False"
      by (simp add: nlta) 
  }
  ultimately
  show ?thesis
    by blast 
qed

lemma t22_9__obtuse_2:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S" and
    "Obtuse Q P M"
  shows "Obtuse S R M" 
proof -
  have "Acute S R M ∨ Per S R M ∨ Obtuse S R M"
    by (metis angle_partition l8_20_1_R1 l8_5)
  moreover
  {
    assume "Acute S R M"
    hence "Q P M LtA Q P M"
      using acute_obtuse__lta assms(1) assms(2) assms(3) assms(4) 
        assms(5) t22_9_aux by blast 
    hence "False"
      by (simp add: nlta) 
  }
  moreover
  {
    assume "Per S R M"
    hence "Q P M LtA Q P M"
      by (metis assms(1) assms(2) assms(3) assms(4) assms(5) 
          obtuse_distincts obtuse_per__lta t22_9_aux_1)
    hence "False"
      by (simp add: nlta) 
  }
  ultimately
  show ?thesis
    by blast 
qed

lemma t22_9__obtuse:
  assumes "Lambert N M P Q" and
    "Lambert N M R S" and
    "Bet M P R" and
    "Bet N Q S"
  shows "Obtuse S R M ⟷ Obtuse Q P M"
  by (meson assms(1) assms(2) assms(3) assms(4) t22_9__obtuse_1 t22_9__obtuse_2) 

(** The two following lemmas cong2_lam2__cong_conga & cong2_sac2__cong come from Theorem 22.4 *)

lemma cong2_lam2__cong_conga_1:
  assumes "Lambert N M P Q" and
    "Lambert N' M' P' Q'" and
    "Cong N Q N' Q'" and
    "Cong P Q P' Q'"
  shows "Cong N M N' M'" 
proof -
  have "N Q ParStrict M P"
    using assms(1) lam__pars1423 by auto 
  have "N M ParStrict P Q"
    by (simp add: assms(1) lam__pars1234) 
  have "N' Q' ParStrict M' P'"
    by (simp add: assms(2) lam__pars1423) 
  have "N' M' ParStrict P' Q'"
    by (simp add: assms(2) lam__pars1234) 
  have "¬ Col N M P"
    using ‹N M ParStrict P Q› par_strict_not_col_1 by auto 
  have "¬ Col M N Q"
    using ‹N M ParStrict P Q› col_permutation_4 par_strict_not_col_4 by blast 
  have "¬ Col M' N' Q'"
    using ‹N' M' ParStrict P' Q'› not_col_permutation_4 par_strict_not_col_4 by blast 
  {
    have "Per N Q P ∧ Per N' Q' P'"
      using Lambert_def assms(1) assms(2) by presburger 
    hence "N Q P CongA N' Q' P'"
      by (metis cong_diff_3 ‹N' M' ParStrict P' Q'› ‹N' Q' ParStrict M' P'› 
          assms(3) assms(4) l11_16 par_strict_neq1 par_strict_neq2) 
    moreover
    have "Cong Q N Q' N'"
      using assms(3) not_cong_2143 by blast 
    moreover
    have "Cong Q P Q' P'"
      using Cong_perm assms(4) by blast 
    moreover
    have "Cong N P N' P'"
      using calculation(1) calculation(2) calculation(3) l11_49 by blast 
  }
  hence "Cong N P N' P'" by auto
  have "Q N P CongA Q' N' P' ∧ Q P N CongA Q' P' N'"
  proof -
    have "Per N Q P ∧ Per N' Q' P'"
      using Lambert_def assms(1) assms(2) by presburger 
    hence "N Q P CongA N' Q' P'"
      by (metis cong_diff_3 ‹N' M' ParStrict P' Q'› ‹N' Q' ParStrict M' P'› 
          assms(3) assms(4) l11_16 par_strict_neq1 par_strict_neq2) 
    moreover
    have "Cong Q N Q' N'"
      using assms(3) not_cong_2143 by blast 
    moreover
    have "Cong Q P Q' P'"
      using Cong_perm assms(4) by blast 
    moreover
    have "N ≠ P"
      using ‹¬ Col N M P› col_trivial_3 by blast 
    ultimately
    show ?thesis 
      using l11_49 ‹Cong N P N' P'› by blast
  qed
  have "M N P CongA M' N' P'" 
  proof -
    have "N Q OS M P"
      by (simp add: ‹N Q ParStrict M P› l12_6) 
    moreover
    have "N' Q' OS M' P'"
      by (simp add: ‹N' Q' ParStrict M' P'› l12_6) 
    moreover
    have "Per M N Q ∧ Per M' N' Q'" 
      using Lambert_def assms(1) assms(2) by presburger 
    hence "M N Q CongA M' N' Q'"
      using ‹N M ParStrict P Q› ‹N Q ParStrict M P› ‹N' M' ParStrict P' Q'› 
        ‹N' Q' ParStrict M' P'› l11_16 par_strict_neq1 by blast 
    moreover
    have "Q N P CongA Q' N' P'"
      by (simp add: ‹Q N P CongA Q' N' P' ∧ Q P N CongA Q' P' N'›) 
    ultimately
    show ?thesis
      using l11_22b by blast 
  qed
  have "¬ Col P N M"
    using ‹¬ Col N M P› col_permutation_1 by blast 
  moreover
  have "Per N M P ∧ Per N' M' P'"
    using Lambert_def assms(1) assms(2) by presburger 
  hence "N M P CongA N' M' P'"
    by (metis ‹N M ParStrict P Q› ‹N Q ParStrict M P› ‹N' M' ParStrict P' Q'› 
        ‹N' Q' ParStrict M' P'› l11_16 par_strict_neq1 par_strict_neq2) 
  moreover
  have "P N M CongA P' N' M'"
    by (simp add: ‹M N P CongA M' N' P'› conga_comm) 
  moreover
  have "Cong P N P' N'"
    using ‹Cong N P N' P'› not_cong_2143 by blast
  ultimately
  show ?thesis
    using l11_50_2 by blast 
qed

lemma cong2_lam2__cong_conga_2:
  assumes "Lambert N M P Q" and
    "Lambert N' M' P' Q'" and
    "Cong N Q N' Q'" and
    "Cong P Q P' Q'"
  shows "M P Q CongA M' P' Q'" 
proof -
  have "N Q ParStrict M P"
    using assms(1) lam__pars1423 by auto 
  have "N M ParStrict P Q"
    by (simp add: assms(1) lam__pars1234) 
  have "N' Q' ParStrict M' P'"
    by (simp add: assms(2) lam__pars1423) 
  have "N' M' ParStrict P' Q'"
    by (simp add: assms(2) lam__pars1234) 
  have "¬ Col N M P"
    using ‹N M ParStrict P Q› par_strict_not_col_1 by auto 
  have "¬ Col M N Q"
    using ‹N M ParStrict P Q› col_permutation_4 par_strict_not_col_4 by blast 
  have "¬ Col M' N' Q'"
    using ‹N' M' ParStrict P' Q'› not_col_permutation_4 
      par_strict_not_col_4 by blast 
  {
    have "Per N Q P ∧ Per N' Q' P'"
      using Lambert_def assms(1) assms(2) by presburger 
    hence "N Q P CongA N' Q' P'"
      by (metis cong_diff_3 ‹N' M' ParStrict P' Q'› ‹N' Q' ParStrict M' P'› 
          assms(3) assms(4) l11_16 par_strict_neq1 par_strict_neq2) 
    moreover
    have "Cong Q N Q' N'"
      using assms(3) not_cong_2143 by blast 
    moreover
    have "Cong Q P Q' P'"
      using Cong_perm assms(4) by blast 
    moreover
    have "Cong N P N' P'"
      using calculation(1) calculation(2) calculation(3) l11_49 by blast 
  }
  hence "Cong N P N' P'" by auto
  have "Q N P CongA Q' N' P' ∧ Q P N CongA Q' P' N'"
  proof -
    have "Per N Q P ∧ Per N' Q' P'"
      using Lambert_def assms(1) assms(2) by presburger 
    hence "N Q P CongA N' Q' P'"
      by (metis cong_diff_3 ‹N' M' ParStrict P' Q'› ‹N' Q' ParStrict M' P'› 
          assms(3) assms(4) l11_16 par_strict_neq1 par_strict_neq2) 
    moreover
    have "Cong Q N Q' N'"
      using assms(3) not_cong_2143 by blast 
    moreover
    have "Cong Q P Q' P'"
      using Cong_perm assms(4) by blast 
    moreover
    have "N ≠ P"
      using ‹¬ Col N M P› col_trivial_3 by blast 
    ultimately
    show ?thesis 
      using l11_49 ‹Cong N P N' P'› by blast
  qed
  have "M N P CongA M' N' P'" 
  proof -
    have "N Q OS M P"
      by (simp add: ‹N Q ParStrict M P› l12_6) 
    moreover
    have "N' Q' OS M' P'"
      by (simp add: ‹N' Q' ParStrict M' P'› l12_6) 
    moreover
    have "Per M N Q ∧ Per M' N' Q'" 
      using Lambert_def assms(1) assms(2) by presburger 
    hence "M N Q CongA M' N' Q'"
      using ‹N M ParStrict P Q› ‹N Q ParStrict M P› ‹N' M' ParStrict P' Q'› 
        ‹N' Q' ParStrict M' P'› l11_16 par_strict_neq1 by blast 
    moreover
    have "Q N P CongA Q' N' P'"
      by (simp add: ‹Q N P CongA Q' N' P' ∧ Q P N CongA Q' P' N'›) 
    ultimately
    show ?thesis
      using l11_22b by blast 
  qed
  {
    have "¬ Col P N M"
      using ‹¬ Col N M P› col_permutation_1 by blast 
    moreover
    have "Per N M P ∧ Per N' M' P'"
      using Lambert_def assms(1) assms(2) by presburger 
    hence "N M P CongA N' M' P'"
      by (metis ‹N M ParStrict P Q› ‹N Q ParStrict M P› ‹N' M' ParStrict P' Q'›
          ‹N' Q' ParStrict M' P'› l11_16 par_strict_neq1 par_strict_neq2) 
    moreover
    have "P N M CongA P' N' M'"
      by (simp add: ‹M N P CongA M' N' P'› conga_comm) 
    moreover
    have "Cong P N P' N'"
      using ‹Cong N P N' P'› not_cong_2143 by blast
    ultimately
    have "M P N CongA M' P' N'"
      using l11_50_2 by blast 
  }
  moreover
  have "P N TS M Q"
    by (metis Par_strict_cases ‹N M ParStrict P Q› ‹N Q ParStrict M P›
        l9_31 pars__os3412) 
  moreover
  have "P' N' TS M' Q'"
    by (meson ‹N' M' ParStrict P' Q'› ‹N' Q' ParStrict M' P'›
        invert_two_sides l12_6 l9_31 one_side_symmetry) 
  moreover 
  have "N P Q CongA N' P' Q'"
    by (simp add: ‹Q N P CongA Q' N' P' ∧ Q P N CongA Q' P' N'› conga_comm) 
  ultimately
  show ?thesis
    using l11_22a by blast 
qed

lemma cong2_lam2__cong_conga:
  assumes "Lambert N M P Q" and
    "Lambert N' M' P' Q'" and
    "Cong N Q N' Q'" and
    "Cong P Q P' Q'"
  shows "Cong N M N' M' ∧ M P Q CongA M' P' Q'"
  by (meson assms(1) assms(2) assms(3) assms(4) cong2_lam2__cong_conga_1
      cong2_lam2__cong_conga_2) 


lemma cong2_sac2__cong:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "Cong A B A' B'" and
    "Cong A D A' D'"
  shows "Cong B C B' C'"
proof -
  have "Cong B D B' D' ∧ A B D CongA A' B' D' ∧ A D B CongA A' D' B'"
  proof -
    have "Per B A D ∧ Per B' A' D'"
      using Saccheri_def assms(1) assms(2) by blast 
    hence "B A D CongA B' A' D'"
      by (metis l11_16 assms(1) assms(2) sac_distincts) 
    moreover
    have "Cong A B A' B'"
      by (simp add: assms(3)) 
    moreover
    have "Cong A D A' D'"
      by (meson assms(4)) 
    moreover
    have "B ≠ D"
      using assms(1) sac_distincts by blast 
    ultimately
    show ?thesis
      using l11_49 by blast 
  qed
  hence "Cong B D B' D'"
    by simp
  have "A B D CongA A' B' D'"
    by (simp add: ‹Cong B D B' D' ∧ A B D CongA A' B' D' ∧ A D B CongA A' D' B'›) 
  have "A D B CongA A' D' B'"
    by (simp add: ‹Cong B D B' D' ∧ A B D CongA A' B' D' ∧ A D B CongA A' D' B'›) 
  have "Cong D B D' B'"
    using ‹Cong B D B' D'› not_cong_2143 by blast 
  moreover
  have "Cong D C D' C'" 
  proof -
    have "Cong A B D C" 
      using Saccheri_def assms(1) not_cong_1243 by blast 
    moreover
    have "Cong A' B' D' C'"
      using Saccheri_def assms(2) not_cong_1243 by blast 
    ultimately
    show ?thesis
      by (meson assms(3) cong_inner_transitivity) 
  qed
  moreover
  have "B D C CongA B' D' C'" 
  proof -
    have "D A OS B C" 
      using Saccheri_def assms(1) invert_one_side by blast 
    moreover
    have "D' A' OS B' C'"
      using Saccheri_def assms(2) invert_one_side by blast 
    moreover
    have "B D A CongA B' D' A'"
      by (simp add: ‹A D B CongA A' D' B'› conga_comm) 
    moreover
    have "A D C CongA A' D' C'"
      by (metis Saccheri_def l11_16 assms(1) assms(2) sac_distincts) 
    ultimately
    show ?thesis
      by (meson l11_22b Tarski_neutral_dimensionless_axioms) 
  qed
  ultimately
  show ?thesis
    using l11_49 by blast 
qed

lemma sac__perp1214:
  assumes "Saccheri A B C D"
  shows "A B Perp A D" 
proof -
  have "B A Perp A D" 
  proof -
    have "A ≠ B"
      using assms sac_distincts by blast 
    moreover
    have "A ≠ D"
      using assms sac_distincts by blast 
    moreover
    have "Per B A D"
      using Saccheri_def assms by blast 
    ultimately
    show ?thesis
      using per_perp by presburger 
  qed
  thus ?thesis
    by (simp add: perp_left_comm) 
qed

lemma sac__perp3414:
  assumes "Saccheri A B C D"
  shows "C D Perp A D"
  by (meson assms perp_comm sac__perp1214 sac_perm) 

lemma cop_sac2__sac:
  assumes "Saccheri A B C D" and
    "Saccheri A B E F" and
    "D ≠ F" and
    "Coplanar A B D F"
  shows "Saccheri D C E F" 
proof -
  have "A B Perp A D"
    using assms(1) sac__perp1214 by blast 
  have "A B Perp A F"
    using assms(2) sac__perp1214 by blast 
  have "C D Perp A D"
    using assms(1) sac__perp3414 by blast 
  have "E F Perp A F"
    using assms(2) sac__perp3414 by blast 
  have "Col A D F" 
  proof -
    have "A D Perp A B"
      using Perp_perm ‹A B Perp A D› by blast 
    moreover
    have "A F Perp A B"
      using Perp_perm ‹A B Perp A F› by blast 
    ultimately
    show ?thesis
      using assms(4) cop_perp2__col by blast 
  qed
  have "Per C D F" 
  proof -
    have "D A Perp D C"
      using Perp_cases ‹C D Perp A D› by blast 
    moreover
    have "Col D A F"
      using NCol_cases ‹Col A D F› by blast 
    moreover
    have "Col D A D"
      by (simp add: col_trivial_3) 
    ultimately
    show ?thesis
      using Perp_cases l8_16_1 by blast 
  qed
  moreover
  have "Per D F E" 
  proof -
    have "F A Perp E F"
      using Perp_perm ‹E F Perp A F› by blast 
    moreover
    have "Col F A F"
      by (simp add: col_trivial_3) 
    moreover
    have "Col F A D"
      by (simp add: ‹Col A D F› col_permutation_2) 
    ultimately
    show ?thesis
      using Per_perm l8_16_1 by blast 
  qed
  moreover
  have "Cong D C E F" 
  proof -
    have "Cong D C A B" 
      using Saccheri_def assms(1) Cong_perm by blast 
    moreover
    have "Cong A B E F" 
      using Saccheri_def assms(2) by auto
    ultimately
    show ?thesis
      using cong_transitivity by blast 
  qed
  moreover
  have "D F OS C E" 
  proof -
    have "D F OS C B" 
    proof -
      have "Col D A F"
        using Col_perm ‹Col A D F› by blast 
      moreover
      have "D A OS C B"
        by (meson Saccheri_def sac_perm assms(1)) 
      ultimately
      show ?thesis
        using assms(3) col_one_side by blast 
    qed
    moreover
    have "D F OS B E" 
    proof -
      have "Col F A D"
        using ‹Col A D F› not_col_permutation_1 by blast 
      moreover
      have "F A OS B E"
        using Saccheri_def assms(2) invert_one_side by blast 
      ultimately
      show ?thesis
        using assms(3) col_one_side invert_one_side by presburger 
    qed
    ultimately
    show ?thesis
      using one_side_transitivity by blast 
  qed
  ultimately
  show ?thesis
    using Saccheri_def by blast 
qed

(** This comes from Martin's proof in Theorem 22.10 *)

lemma three_hypotheses_aux:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "M Midpoint B C" and
    "M' Midpoint B' C'" and
    "N Midpoint A D" and
    "N' Midpoint A' D'" and
    "M N Le M' N'" 
  shows "(Per A B C ⟷ Per A' B' C') ∧ (Acute A B C ⟷ Acute A' B' C')" 
proof -
  have "Lambert N M C D"
    using assms(1) assms(3) assms(5) mid2_sac__lam6534 by blast
  have "Lambert N' M' C' D'"
    using assms(2) assms(4) assms(6) mid2_sac__lam6534 by blast 
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  have "C ≠ B" 
    using assms(1) sac_distincts by blast 
  have "C ≠ D"
    using assms(1) sac_distincts by blast 
  have "A ≠ D"
    using assms(1) sac_distincts by blast 
  have "A' ≠ B'" 
    using assms(2) sac_distincts by blast 
  have "C' ≠ B'" 
    using assms(2) sac_distincts by blast 
  have "C' ≠ D'"
    using assms(2) sac_distincts by blast 
  have "A' ≠ D'" 
    using assms(2) sac_distincts by blast 
  have "¬ Col C D A"
    using Saccheri_def assms(1) col124__nos col_permutation_3 by blast 
  obtain H where "N Out D H ∧ Cong N H N' D'"
    by (metis Mid_cases ‹A ≠ D› ‹A' ≠ D'› assms(5) assms(6) 
        is_midpoint_id segment_construction_3) 
  have "Col A D H"
    by (metis col124__nos ‹A ≠ D› ‹N Out D H ∧ Cong N H N' D'› 
        assms(5) midpoint_out_1 one_side_reflexivity out_col out_out_one_side) 
  obtain G0 where "A D Perp G0 H ∧ A D OS C G0"
    using NCol_perm ‹Col A D H› ‹¬ Col C D A› l10_15 by blast 
  have "N ≠ H"
    using ‹N Out D H ∧ Cong N H N' D'› out_diff2 by blast 
  have "G0 ≠ H"
    using ‹A D Perp G0 H ∧ A D OS C G0› ‹Col A D H› l8_16_1 by blast 
  obtain G where "H Out G0 G ∧ Cong H G C' D'"
    using ‹C' ≠ D'› ‹G0 ≠ H› segment_construction_3 by presburger
  have "H ≠ G"
    by (metis ‹C' ≠ D'› ‹H Out G0 G ∧ Cong H G C' D'› cong_diff_4) 
  have "N D OS C G" 
  proof -
    have "D N OS C G" 
    proof -
      have "Col D A N"
        by (meson Mid_cases assms(5) l7_3_2 mid_two_sides not_two_sides_id) 
      moreover
      have "D ≠ N"
        using ‹A ≠ D› assms(5) midpoint_not_midpoint by blast 
      moreover
      have "A D OS C G" 
      proof -
        have "A D OS C G0"
          by (simp add: ‹A D Perp G0 H ∧ A D OS C G0›) 
        moreover
        have "¬ Col A D G0"
          using calculation col_one_side os_distincts by blast 
        hence "A D OS G0 G" 
          using l9_19_R2 ‹Col A D H› ‹H Out G0 G ∧ Cong H G C' D'› by blast 
        ultimately
        show ?thesis
          using one_side_transitivity by blast 
      qed
      hence "D A OS C G"
        by (simp add: invert_one_side) 
      ultimately
      show ?thesis
        using col_one_side by blast 
    qed
    thus ?thesis
      using invert_one_side by blast 
  qed
  have "A D Perp H G" 
  proof -
    have "A D Perp H G0"
      by (simp add: ‹A D Perp G0 H ∧ A D OS C G0› perp_right_comm) 
    moreover
    have "Col H G0 G"
      by (simp add: ‹H Out G0 G ∧ Cong H G C' D'› out_col) 
    ultimately
    show ?thesis
      using perp_col1 ‹H ≠ G› by blast 
  qed
  have "¬ Col M N H" 
  proof -
    have "M ≠ N" 
      using Lambert_def ‹Lambert N M C D› by blast 
    moreover
    have "Per M N H" 
    proof -
      have "N ≠ D"
        using ‹N D OS C G› os_distincts by blast 
      moreover
      have "Per M N D" 
        using Lambert_def ‹Lambert N M C D› by presburger 
      moreover
      have "Col N D H"
        by (simp add: ‹N Out D H ∧ Cong N H N' D'› out_col) 
      ultimately
      show ?thesis
        using per_col by blast 
    qed
    ultimately
    show ?thesis
      using l8_9  ‹N ≠ H› by blast 
  qed
  have "Coplanar A D M G"
  proof -
    have "¬ Col C A D"
      by (simp add: ‹¬ Col C D A› not_col_permutation_5) 
    moreover
    have "Coplanar C A D M" 
    proof -
      have "Coplanar A D C B"
        by (meson assms(1) par__coplanar par_right_comm sac__par1423) 
      moreover
      have "Col C B M"
        by (meson Mid_cases assms(3) l7_3_2 mid_two_sides not_two_sides_id) 
      ultimately
      show ?thesis
        using col_cop__cop coplanar_perm_12 ‹C ≠ B› by blast 
    qed
    moreover
    have "Coplanar C A D G" 
    proof -
      have "Coplanar C G D N"
        by (meson ‹N D OS C G› coplanar_perm_17 os__coplanar) 
      moreover
      have "D ≠ N"
        using ‹N D OS C G› os_distincts by blast 
      moreover
      have "Col D N A"
        using Mid_cases ‹A ≠ D› assms(5) midpoint_out out_col by presburger 
      ultimately
      show ?thesis
        by (meson col_cop__cop coplanar_perm_5) 
    qed
    ultimately
    show ?thesis
      using coplanar_trans_1 by blast 
  qed
  have "¬ Col M N G" 
  proof -
    have "M N ParStrict G H" 
    proof -
      have "M N Par G H" 
      proof -
        have "Coplanar A D M H"
          using ‹Col A D H› ncop__ncols by blast 
        moreover
        have "Coplanar A D N G"
          by (meson Col_cases assms(5) midpoint_col ncop__ncol) 
        moreover
        have "Coplanar A D N H"
          by (meson ‹Col A D H› col__coplanar col_permutation_5 ncoplanar_perm_4) 
        moreover
        have "M N Perp A D" 
        proof -
          have "M N Perp D N" 
            using Lambert_def 
            by (metis ‹Lambert N M C D› per_perp perp_right_comm) 
          moreover
          have "Col D N A"
            by (metis Out_cases assms(5) ‹A ≠ D› midpoint_out_1 out_col) 
          ultimately
          show ?thesis
            using col_trivial_3 perp_col2_bis ‹A ≠ D› by blast 
        qed
        moreover
        have "G H Perp A D"
          using Perp_perm ‹A D Perp H G› by blast 
        ultimately
        show ?thesis
          using l12_9 ‹Coplanar A D M G› by blast 
      qed
      moreover
      have "Col G H H"
        by (simp add: col_trivial_2) 
      ultimately
      show ?thesis
        using par_not_col_strict ‹¬ Col M N H› by blast 
    qed
    hence "M N OS G H"
      by (simp add: l12_6) 
    thus ?thesis
      by (meson col123__nos) 
  qed
  have "M ≠ N"
    using ‹¬ Col M N G› col_trivial_1 by force 
  have "A ≠ H"
    using Mid_cases ‹N Out D H ∧ Cong N H N' D'› assms(5) 
      midpoint_bet not_bet_and_out by blast 
  have "Col H A N"
    by (metis OS_def Out_cases TS_def ‹A ≠ D› ‹N Out D H ∧ Cong N H N' D'› 
        assms(5) invert_one_side midpoint_out_1 one_side_reflexivity 
        out_col out_out_one_side) 
  obtain L where "Col M N L ∧ M N Perp G L"
    using ‹¬ Col M N G› l8_18_existence by blast 
  have "¬ Col M A D" 
  proof -
    have "B C ParStrict A D"
      using Par_strict_cases assms(1) sac__pars1423 by blast 
    moreover
    have "Col M B C"
      by (simp add: assms(3) midpoint_col) 
    ultimately
    show ?thesis
      using par_not_col by blast 
  qed
  have "Lambert N L G H" 
  proof -
    have "Per N H G" 
    proof -
      have "H A Perp H G"
        by (metis ‹A D Perp H G› ‹A ≠ H› ‹Col A D H› col_trivial_3 perp_col2) 
      hence "H A Perp G H"
        using Perp_cases by blast 
      hence "Per A H G"
        by (simp add: perp_per_1) 
      thus ?thesis
        using ‹A ≠ H› ‹Col H A N› l8_3 by blast 
    qed
    moreover
    have "¬ Col N H G"
      using ‹H ≠ G› ‹N ≠ H› calculation l8_9 by blast 
    have "Per A N M" 
    proof -
      have "A D Perp M N" 
        using mid2_sac__perp_lower assms(1) assms(3) assms(5) by auto 
      hence "A N Perp M N"
        by (metis NCol_perm midpoint_distinct_1 assms(5) midpoint_col perp_col) 
      thus ?thesis
        by (simp add: perp_left_comm perp_per_1) 
    qed
    have "Per L N H" 
    proof -
      have "Per M N H" 
      proof -
        have "N ≠ A"
          using ‹A ≠ D› assms(5) is_midpoint_id by blast 
        moreover
        have "Per M N A"
          by (simp add: ‹Per A N M› l8_2) 
        moreover
        have "Col N A H"
          using ‹Col H A N› not_col_permutation_3 by blast 
        ultimately
        show ?thesis
          using per_col by blast  
      qed
      moreover
      have "Col N M L"
        by (simp add: ‹Col M N L ∧ M N Perp G L› col_permutation_4) 
      ultimately
      show ?thesis
        using l8_3 ‹M ≠ N› by blast 
    qed
    moreover
    {
      assume "L = N"
      have "Col G H N" 
      proof -
        have "Coplanar M G H N" 
        proof -
          have "¬ Col A D M"
            using ‹¬ Col M A D› col_permutation_2 by blast 
          moreover
          have "Coplanar A D M M"
            using ncop_distincts by blast 
          moreover
          have "Coplanar A D M H"
            using ‹Col A D H› coplanar_perm_1 ncop__ncol by blast 
          moreover
          have "Coplanar A D M N"
            by (meson ‹A ≠ H› ‹Col H A N› calculation(3) col_cop__cop 
                coplanar_perm_8 not_col_permutation_4) 
          ultimately
          show ?thesis
            by (meson coplanar_pseudo_trans ‹Coplanar A D M G›) 
        qed
        moreover
        have "Per G N M"
          using Perp_cases ‹Col M N L ∧ M N Perp G L› ‹L = N› perp_per_1 by blast 
        moreover
        have "Per H N M"
          by (metis ‹A ≠ D› ‹Col H A N› ‹Per A N M› assms(5) ‹M ≠ N› 
              col_col_per_per col_trivial_1 is_midpoint_id) 
        ultimately
        show ?thesis
          using cop_per2__col ‹M ≠ N› by blast 
      qed
      hence "False"
        using Col_cases ‹¬ Col N H G› by blast 
    }
    hence "L ≠ N" by auto
    moreover
    have "L ≠ G"
      using ‹Col M N L ∧ M N Perp G L› ‹¬ Col M N G› by fastforce 
    moreover
    have "Per N L G" 
    proof -
      have "N ≠ L"
        using calculation(3) by auto 
      moreover
      have "N M Perp G L"
        by (simp add: ‹Col M N L ∧ M N Perp G L› perp_left_comm) 
      moreover
      have "Col N M L"
        by (simp add: ‹Col M N L ∧ M N Perp G L› col_permutation_4) 
      ultimately
      show ?thesis
        by (metis Perp_cases perp_col1 perp_per_1) 
    qed
    moreover  
    have "Coplanar N L G H" 
    proof -
      have "¬ Col A D M"
        using Col_cases ‹¬ Col M A D› by blast 
      moreover
      have "Coplanar A D M N"
        by (meson ‹A ≠ H› ‹Col A D H› ‹Col H A N› col_transitivity_1 
            coplanar_perm_1 ncop__ncol not_col_permutation_4 not_col_permutation_5) 
      moreover
      have "Col A D N ∧ Col M L N"
        using Col_cases Col_def ‹Col M N L ∧ M N Perp G L› 
          assms(5) midpoint_bet by blast 
      hence "Coplanar A D M L"
        using Coplanar_def by blast 
      moreover
      have "Coplanar A D M H"
        using ‹Col A D H› coplanar_perm_1 ncop__ncol by blast 
      ultimately
      show ?thesis
        by (meson coplanar_pseudo_trans ‹Coplanar A D M G›) 
    qed
    ultimately
    show ?thesis
      using Lambert_def ‹H ≠ G› ‹N ≠ H› by blast
  qed
  have "N D ParStrict M C"
    by (simp add: ‹Lambert N M C D› lam__pars1423) 
  have "Bet N M L" 
  proof -
    have "Cong N' M' N L ∧ M' C' D' CongA L G H"
    proof -
      have "Cong N' D' N H"
        by (simp add: ‹N Out D H ∧ Cong N H N' D'› cong_symmetry) 
      moreover
      have "Cong C' D' G H"
        using ‹H Out G0 G ∧ Cong H G C' D'› not_cong_4312 by blast 
      ultimately
      show ?thesis
        using cong2_lam2__cong_conga ‹Lambert N L G H› ‹Lambert N' M' C' D'› by blast 
    qed
    show ?thesis 
    proof -
      have "N Out M L" 
      proof -
        have "Col N M L"
          by (simp add: ‹Col M N L ∧ M N Perp G L› col_permutation_4) 
        moreover
        have "N D OS M L" 
        proof -
          have "N D OS M G"
            using ‹N D OS C G› ‹N D ParStrict M C› l12_6 
              one_side_transitivity by blast 
          moreover
          have "N D OS G L" 
          proof -
            have "Col N H D"
              using Out_cases ‹N Out D H ∧ Cong N H N' D'› out_col by blast 
            moreover
            have "N ≠ D"
              using ‹N D OS C G› os_distincts by blast 
            moreover
            have "N H OS G L"
              by (meson Par_strict_cases ‹Lambert N L G H› l12_6 lam__pars1423) 
            ultimately
            show ?thesis
              using col_one_side by blast 
          qed
          ultimately
          show ?thesis
            using one_side_transitivity by blast 
        qed
        ultimately
        show ?thesis
          using col_one_side_out by blast 
      qed
      moreover
      have "N M Le N L" 
      proof -
        have "Cong M N N M"
          by (simp add: cong_pseudo_reflexivity) 
        moreover 
        have "Cong M' N' N L"
          using ‹Cong N' M' N L ∧ M' C' D' CongA L G H› not_cong_2134 by blast 
        ultimately
        show ?thesis
          using l5_6 assms(7) by blast
      qed
      ultimately
      show ?thesis
        by (simp add: l6_13_1) 
    qed
  qed
  have "¬ Col N M C"
    using Lambert_def ‹Lambert N M C D› per_not_col by presburger 
  have "¬ Col N D M"
    using ‹N D ParStrict M C› par_strict_not_col_1 by auto 
  have "Coplanar M C D A"
  proof -
    have "M C ParStrict D N"
      using Par_strict_perm ‹N D ParStrict M C› by blast 
    moreover
    have "Col D N A"
      by (metis ‹Col H A N› ‹N Out D H ∧ Cong N H N' D'› ‹N ≠ H› 
          col2__eq col_permutation_1 out_col) 
    ultimately
    show ?thesis
      using os__coplanar par_strict_all_one_side ‹A ≠ D› by blast 
  qed
  have "∃ K. Col K M C ∧ Bet G K H" 
  proof cases
    assume "L = M"
    have "Col G C M" 
    proof -
      have "Coplanar N G C M"
      proof -
        have "¬ Col A D M"
          using Col_cases ‹¬ Col M A D› by blast 
        moreover
        have "Coplanar A D M N"
          using Col_cases assms(5) midpoint_col ncop__ncols by blast 
        moreover
        have "Coplanar A D M C"
          using ‹Coplanar M C D A› ncoplanar_perm_17 by blast 
        moreover
        have "Coplanar A D M M"
          using ncop_distincts by blast 
        ultimately
        show ?thesis
          using coplanar_pseudo_trans ‹Coplanar A D M G› by presburger  
      qed
      moreover
      have "N ≠ M"
        using ‹¬ Col N M C› col_trivial_1 by blast 
      moreover
      have "Per G M N"
        using ‹Col M N L ∧ M N Perp G L› ‹L = M› l8_2 perp_per_1 by blast 
      moreover
      have "Per C M N"
        using Lambert_def ‹Lambert N M C D› l8_2 by presburger 
      ultimately
      show ?thesis
        using cop_per2__col by blast 
    qed
    hence "Col G M C"
      using col_permutation_5 by blast 
    moreover
    have "Bet G G H"
      by (simp add: between_trivial2) 
    ultimately
    show ?thesis
      by blast 
  next
    assume "L ≠ M"
    hence "¬ Col L M C"
      using ‹Bet N M L› ‹¬ Col N M C› bet_col col2__eq col_permutation_3 by blast 
    have "M C TS G H" 
    proof -
      have "M C TS H L" 
      proof -
        have "M C TS N L"
          using ‹Bet N M L› ‹L ≠ M› ‹¬ Col N M C› bet__ts 
            not_col_permutation_1 by presburger 
        moreover
        have "M C OS N H" 
        proof -
          have "M C ParStrict N D"
            using Par_strict_cases ‹N D ParStrict M C› by blast 
          moreover
          have "Col N D H"
            by (metis ‹A ≠ H› ‹Col A D H› ‹Col H A N› col3 
                col_trivial_3 not_col_permutation_1) 
          ultimately
          show ?thesis
            using par_strict_one_side ‹N ≠ H› by blast
        qed
        ultimately
        show ?thesis
          using l9_8_2 by blast
      qed
      hence "M C TS L H"
        by (simp add: l9_2) 
      moreover
      have "M C OS L G"
      proof -
        have "M C Par L G" 
        proof -
          have "Coplanar M N M L" 
            using ncop_distincts by blast 
          moreover
          have "Coplanar M N M G"
            using ncop_distincts by blast 
          moreover
          have "Coplanar M N C L"
            by (simp add: ‹Bet N M L› bet_col col__coplanar coplanar_perm_7) 
          moreover
          have "Coplanar M N C G"
            by (metis ‹N D OS C G› ‹N D ParStrict M C› coplanar_perm_10 
                coplanar_perm_8 coplanar_trans_1 not_col_permutation_1 
                one_side_not_col123 os__coplanar pars__coplanar) 
          moreover
          have "M C Perp M N" 
            using Lambert_def by (metis Perp_perm ‹Lambert N M C D› per_perp) 
          moreover
          have "L G Perp M N" 
            by (simp add: Perp_perm ‹Col M N L ∧ M N Perp G L›)
          ultimately
          show ?thesis
            using l12_9 by blast 
        qed
        moreover
        have "Col L G L"
          by (simp add: col_trivial_3) 
        moreover
        have "¬ Col M C L"
          using Col_cases ‹¬ Col L M C› by blast 
        ultimately
        show ?thesis
          using l12_6 par_not_col_strict by blast 
      qed
      ultimately
      show ?thesis
        using l9_8_2 by blast 
    qed
    thus ?thesis
      by (simp add: TS_def)
  qed
  then obtain K where "Col K M C ∧ Bet G K H" 
    by auto
  hence "Col K M C" 
    by auto
  have "Bet G K H"
    by (simp add: ‹Col K M C ∧ Bet G K H›) 
  have "¬ Col H M C" 
  proof -
    have "Col H N D"
      using NCol_cases ‹N Out D H ∧ Cong N H N' D'› out_col by blast 
    thus ?thesis
      using par_not_col ‹N D ParStrict M C› by blast 
  qed
  have "K ≠ H"
    using ‹Col K M C› ‹¬ Col H M C› by blast 
  have "N M ParStrict C D"
    by (simp add: ‹Lambert N M C D› lam__pars1234) 
  hence "¬ Col N C D"
    using Col_cases par_strict_not_col_3 by blast
  have "M N ParStrict H K" 
  proof -
    have "G H ParStrict N L"
      by (metis Par_strict_cases lam__pars1234 ‹Lambert N L G H›) 
    hence "G H ParStrict N M"
      by (metis Col_cases ‹Bet N M L› ‹M ≠ N› bet_col par_strict_col_par_strict) 
    hence "M N ParStrict H G"
      using Par_strict_perm by blast 
    moreover
    have "Col H G K"
      by (simp add: Col_def ‹Bet G K H›) 
    ultimately
    show ?thesis
      using par_strict_col_par_strict ‹K ≠ H› by auto  
  qed
  have "¬ Col N H K"
    using ‹M N ParStrict H K› par_strict_not_col_2 by blast 
  have "M N OS D K" 
  proof -
    have "M N OS D H" 
    proof -
      have "¬ Col N M D ∨ ¬ Col N M H"
        using ‹¬ Col N D M› col_permutation_5 by blast 
      moreover
      have "N Out D H"
        by (simp add: ‹N Out D H ∧ Cong N H N' D'›) 
      ultimately
      show ?thesis
        using invert_one_side out_one_side by blast  
    qed
    moreover
    have "M N OS H K"
      by (simp add: ‹M N ParStrict H K› l12_6) 
    ultimately
    show ?thesis
      using one_side_transitivity by blast 
  qed
  hence "M N OS C K"
    using ‹N M ParStrict C D› invert_one_side l12_6 one_side_transitivity by blast
  hence "M Out C K"
    using ‹Col K M C› col_one_side_out col_permutation_1 by blast 
  have "N ≠ L"
    using ‹Bet N M L› ‹M ≠ N› bet_neq23__neq by blast 
  have "M ≠ K"
    using ‹M Out C K› out_diff2 by blast
  have "Lambert N M K H" 
  proof -
    have "Per M N H" 
    proof -
      have "Per L N H" 
        using Lambert_def ‹Lambert N L G H› by auto 
      moreover
      have "Col N L M"
        by (meson ‹Bet N M L› bet_col1 between_trivial) 
      ultimately
      show ?thesis
        using l8_3 ‹N ≠ L› by blast 
    qed
    moreover
    have "Per N H K" 
    proof -
      have "Per N H G"
        using Lambert_def ‹Lambert N L G H› by presburger 
      moreover
      have "Col H G K"
        by (simp add: Col_def ‹Bet G K H›) 
      ultimately
      show ?thesis
        using per_col ‹H ≠ G› by blast 
    qed
    moreover
    have "Per N M K" 
    proof -
      have "M ≠ C"
        using ‹¬ Col H M C› col_trivial_2 by blast 
      moreover
      have "Per N M C" 
        using Lambert_def ‹Lambert N M C D› by presburger 
      moreover
      have "Col M C K"
        using Col_cases ‹Col K M C› by blast 
      ultimately
      show ?thesis
        using per_col by blast 
    qed
    moreover
    have "Coplanar N M K H"
      by (simp add: ‹M N ParStrict H K› l12_6 os__coplanar par_strict_comm) 
    ultimately
    show ?thesis
      using Lambert_def ‹K ≠ H› ‹M ≠ K› ‹M ≠ N› ‹N ≠ H› by blast 
  qed
  have "A B C CongA B C D"
    using assms(1) sac__conga by blast
  have "A' B' C' CongA H G L" 
  proof -
    have "A' B' C' CongA M' C' D'" 
    proof -
      have "A' B' C' CongA B' C' D'"
        by (simp add: assms(2) sac__conga) 
      moreover
      have "B' Out A' A'"
        by (simp add: ‹A' ≠ B'› out_trivial) 
      moreover
      have "B' Out C' C'"
        by (simp add: ‹C' ≠ B'› out_trivial) 
      moreover
      have "C' Out M' B'"
        using ‹C' ≠ B'› assms(4) l7_2 midpoint_out by blast 
      moreover
      have "C' Out D' D'"
        using ‹C' ≠ D'› out_trivial by auto 
      ultimately
      show ?thesis
        using l11_10 by blast 
    qed
    moreover
    have "M' C' D' CongA H G L"
    proof -
      have "Cong N' D' N H"
        by (simp add: ‹N Out D H ∧ Cong N H N' D'› cong_symmetry) 
      moreover
      have "Cong C' D' G H"
        by (simp add: ‹H Out G0 G ∧ Cong H G C' D'› cong_3421) 
      ultimately
      show ?thesis
        using cong2_lam2__cong_conga conga_right_comm ‹Lambert N' M' C' D'›
          ‹Lambert N L G H› by fastforce 
    qed
    ultimately
    show ?thesis
      by (meson not_conga Tarski_neutral_dimensionless_axioms) 
  qed
  {
    assume "D ≠ H"
    assume "¬ C D ParStrict K H"
    have "C D Par K H" 
    proof -
      have "Coplanar N D C K" 
      proof -
        have "N D ParStrict C M"
          using Par_strict_cases ‹N D ParStrict M C› by blast 
        moreover
        have "Col C M K"
          using Col_cases ‹Col K M C› by blast 
        ultimately
        show ?thesis
          using os__coplanar par_strict_all_one_side by blast 
      qed
      moreover
      have "Coplanar N D C H"
        by (metis ‹A ≠ H› ‹Col A D H› ‹Col H A N› col3 col_trivial_2 
            col_trivial_3 coplanar_perm_1 ncop__ncol) 
      moreover
      have "Coplanar N D D K"
        by (meson ncop_distincts) 
      moreover
      have "Coplanar N D D H"
        using ncop_distincts by blast 
      moreover
      have "C D Perp N D" 
        using Lambert_def 
        by (metis ‹Lambert N M C D› col_per_perp col_trivial_3) 
      moreover
      have "K H Perp N D" 
      proof -
        have "H G Perp D N" 
        proof -
          have "D ≠ N"
            using ‹M N OS D K› os_distincts by blast 
          moreover
          have "H G Perp D A"
            using Perp_perm ‹A D Perp H G› by blast 
          moreover
          have "Col D A N"
            by (meson ‹A ≠ H› ‹Col A D H› ‹Col H A N› col_permutation_5 
                col_transitivity_1 not_col_permutation_4) 
          ultimately
          show ?thesis
            using perp_col1 by blast 
        qed
        moreover
        have "Col H G K"
          by (simp add: Col_def ‹Bet G K H›) 
        ultimately
        show ?thesis
          by (metis Perp_cases perp_col1 ‹K ≠ H›) 
      qed
      ultimately
      show ?thesis
        using l12_9 by blast 
    qed
    have "Col C K H" using ‹C D Par K H›
      by (simp add: Par_def ‹¬ C D ParStrict K H›) 
    have "Col D K H"  using ‹C D Par K H›
      by (simp add: Par_def ‹¬ C D ParStrict K H›)
    have "D = H" 
    proof -
      have "C D Perp N D" 
        using Lambert_def 
        by (metis ‹Lambert N M C D› col_per_perp col_trivial_3) 
      moreover
      have "Col C D H"
        using ‹Col C K H› ‹Col D K H› ‹K ≠ H› col2__eq col_permutation_5 by blast 
      moreover
      have "C D Perp N H"
      proof -
        have "C H Perp N H"
          by (metis ‹N Out D H ∧ Cong N H N' D'› calculation(1) 
              calculation(2) col_trivial_2 l8_16_1 out_col per_col_eq) 
        moreover
        have "Col C H D"
          using Col_cases ‹Col C D H› by blast 
        ultimately
        show ?thesis
          using perp_col ‹C ≠ D› by blast 
      qed
      ultimately
      show ?thesis
        using col_trivial_2 l8_18_uniqueness by blast 
    qed
    hence "False"
      using ‹D ≠ H› by auto 
    hence "C D ParStrict K H"
      by simp 
  }
  {
    assume "Bet M C K"
    have "Bet N D H" 
    proof cases
      assume "D = H"
      thus ?thesis
        by (simp add: between_trivial) 
    next
      assume "D ≠ H"
      hence "C D ParStrict K H"
        using ‹⟦D ≠ H; ¬ C D ParStrict K H⟧ ⟹ C D ParStrict K H› by blast
      have "Bet H D N" 
      proof -
        have "Col H D N"
          by (meson ‹A ≠ H› ‹Col A D H› ‹Col H A N› col_permutation_4 
              col_transitivity_2 not_col_permutation_3)
        moreover
        {
          assume "D Out H N"
          have "C Out K M" 
          proof -
            have "Col C K M"
              by (simp add: Col_def ‹Bet M C K›) 
            moreover
            have "C D OS K M" 
            proof -
              have "C D OS K N" 
              proof -
                have "C D OS K H"
                  using ‹C D ParStrict K H› l12_6 by blast 
                moreover
                have "C D OS H N"
                  by (metis Col_cases ‹D Out H N› ‹¬ Col N C D› 
                      invert_one_side out_one_side) 
                ultimately
                show ?thesis
                  by (meson one_side_transitivity) 
              qed
              moreover
              have "C D OS N M"
                by (simp add: ‹N M ParStrict C D› pars__os3412) 
              ultimately
              show ?thesis
                using one_side_transitivity by blast 
            qed
            ultimately
            show ?thesis
              using col_one_side_out by blast 
          qed
          hence "False"
            using ‹Bet M C K› l6_6 not_bet_and_out by blast 
        }
        hence "¬ D Out H N" 
          by auto
        ultimately
        show ?thesis
          using l6_4_2 by blast 
      qed
      thus ?thesis
        using Bet_cases by blast 
    qed
  }
  {
    assume "Bet M K C" 
    have "Bet N H D" 
    proof cases
      assume "D = H"
      thus ?thesis
        by (simp add: between_trivial) 
    next
      assume "D ≠ H"
      hence "C D ParStrict K H"
        using ‹⟦D ≠ H; ¬ C D ParStrict K H⟧ ⟹ C D ParStrict K H› by blast
      have "Bet D H N" 
      proof -
        have "Col D H N"
          by (metis ‹A ≠ H› ‹Col A D H› ‹Col H A N› col2__eq col_permutation_1) 
        moreover
        {
          assume "H Out D N" 
          have "K Out C M" 
          proof -
            have "Col K C M"
              by (simp add: Col_def ‹Bet M K C›) 
            moreover
            have "K H OS C M" 
            proof -
              have "K H OS C N" 
              proof -
                have "K H OS C D"
                  by (simp add: ‹C D ParStrict K H› pars__os3412) 
                moreover
                have "K H OS D N"
                  using ‹H Out D N› ‹¬ Col N H K› col_permutation_2 
                    invert_one_side out_one_side by blast 
                ultimately
                show ?thesis
                  using one_side_transitivity by blast 
              qed
              moreover
              have "K H OS N M"
                using Par_strict_perm ‹M N ParStrict H K› l12_6 by blast 
              ultimately
              show ?thesis
                using one_side_transitivity by blast 
            qed
            ultimately
            show ?thesis
              using col_one_side_out by blast 
          qed
          hence "False"
            using ‹Bet M K C› bet_col l6_4_1 l6_6 by blast 
        }
        ultimately
        show ?thesis
          using l6_4_2 by blast 
      qed
      thus ?thesis
        using Bet_cases by blast 
    qed
  }
  {
    assume "Per A B C"
    have "Per A' B' C'" 
    proof -
      have "Per L G H" 
      proof -
        have "Lambert N H K M"
          by (simp add: ‹Lambert N M K H› lam_perm) 
        moreover
        have "Lambert N H G L"
          by (simp add: ‹Lambert N L G H› lam_perm) 
        moreover
        have "Bet H K G"
          using Bet_cases ‹Bet G K H› by blast 
        moreover
        have "Bet N M L"
          by (simp add: ‹Bet N M L›) 
        moreover
        have "Per H K M"         
        proof -
          have "A B C CongA D C M" 
          proof -
            have "A B C CongA D C B"
              by (simp add: ‹A B C CongA B C D› conga_right_comm) 
            moreover
            have "B Out A A"
              by (simp add: ‹A ≠ B› bet_out_1 between_trivial2)
            moreover
            have "B Out C C"
              using ‹C ≠ B› out_trivial by blast 
            moreover
            have "C Out D D"
              using ‹C ≠ D› out_trivial by auto 
            moreover
            have "C Out M B"
              by (simp add: ‹C ≠ B› assms(3) l7_2 midpoint_out) 
            ultimately
            show ?thesis
              using l11_10 by blast 
          qed
          hence "Per D C M"
            using ‹Per A B C› l11_17 by blast
          {
            assume "Bet M C K" 
            hence "Bet N D H"
              by (simp add: ‹Bet M C K ⟹ Bet N D H›) 
            hence "Per H K M"          
              using t22_9_aux_2 ‹Per D C M› ‹Bet M C K› ‹Lambert N M K H› 
                ‹Lambert N M C D› by blast  
          }
          moreover
          {
            assume "Bet M K C" 
            hence "Bet N H D"
              by (simp add: ‹Bet M K C ⟹ Bet N H D›) 
            hence "Per H K M"
              using ‹Per D C M› ‹Bet M K C› ‹Lambert N M K H› 
                ‹Lambert N M C D› t22_9_aux_1 by blast 
          }
          ultimately
          show ?thesis
            using Out_def ‹M Out C K› by blast 
        qed
        hence "Per M K H"
          by (simp add: l8_2) 
        ultimately
        show ?thesis
          using t22_9__per by blast 
      qed
      moreover
      have "L G H CongA A' B' C'"
        by (simp add: ‹A' B' C' CongA H G L› conga_right_comm conga_sym_equiv) 
      ultimately
      show ?thesis
        using l11_17 by blast 
    qed
  }
  moreover
  {
    assume "Per A' B' C'"
    have "Per A B C" 
    proof -
      have "Per D C M" 
      proof -
        have "Per H K M" 
        proof -
          have "Bet H K G"
            using Bet_cases ‹Bet G K H› by blast
          moreover
          have "A' B' C' CongA L G H"
            by (simp add: ‹A' B' C' CongA H G L› conga_right_comm) 
          hence "Per L G H" 
            using l11_17 ‹Per A' B' C'› by blast 
          ultimately
          show ?thesis 
            using ‹Bet N M L› ‹Lambert N M K H› ‹Lambert N L G H› 
            by (meson Per_perm lam_perm t22_9_aux_1) 
        qed
        {
          assume "Bet M C K"
          hence "Bet N D H"
            using ‹Bet M C K ⟹ Bet N D H› by blast
          hence "Per D C M" 
            using ‹Per H K M› ‹Bet M C K› ‹Lambert N M K H› 
              ‹Lambert N M C D› t22_9_aux_1 by blast 
        }
        moreover
        {
          assume "Bet M K C"
          hence "Bet N H D"
            by (simp add: ‹Bet M K C ⟹ Bet N H D›) 
          hence "Per D C M"
            using ‹Bet M K C› ‹Lambert N M C D› ‹Lambert N M K H› 
              ‹Per H K M› t22_9_aux_2 by blast 
        }
        ultimately
        show ?thesis 
          using Out_def ‹M Out C K› by blast 
      qed
      moreover
      have "D C M CongA A B C" 
      proof -
        have "D C B CongA A B C"
          by (meson ‹A B C CongA B C D› conga_left_comm not_conga_sym)  
        moreover
        have "C Out D D"
          using ‹C ≠ D› out_trivial by force 
        moreover
        have "C Out M B"
          by (metis ‹¬ Col N M C› assms(3) bet_out_1 col_trivial_2 midpoint_bet) 
        moreover
        have "B Out A A"
          by (simp add: ‹A ≠ B› out_trivial) 
        moreover
        have "B Out C C"
          by (simp add: ‹C ≠ B› out_trivial) 
        ultimately
        show ?thesis
          using l11_10 by blast 
      qed
      ultimately
      show ?thesis
        using l11_17 by blast 
    qed
  }
  moreover
  {
    assume "Acute A B C" 
    have "Acute A' B' C'" 
    proof -
      have "Acute L G H" 
      proof -
        have "Lambert N H K M"
          by (simp add: ‹Lambert N M K H› lam_perm) 
        moreover
        have "Lambert N H G L"
          by (simp add: ‹Lambert N L G H› lam_perm) 
        moreover
        have "Bet H K G"
          using Bet_cases ‹Bet G K H› by blast 
        moreover
        have "A B C CongA D C M" 
        proof -
          have "A B C CongA D C B"
            by (simp add: ‹A B C CongA B C D› conga_right_comm) 
          moreover
          have "B Out A A" 
            by (simp add: ‹A ≠ B› out_trivial) 
          moreover
          have "B Out C C" 
            by (simp add: ‹C ≠ B› out_trivial) 
          moreover
          have "C Out D D"
            using ‹C ≠ D› out_trivial by auto 
          moreover
          have "C Out M B" 
            by (metis ‹¬ Col N M C› assms(3) bet_out_1 col_trivial_2 midpoint_bet) 
          ultimately
          show ?thesis
            using l11_10 by blast 
        qed
        hence "Acute D C M" 
          using acute_conga__acute ‹Acute A B C› by blast 
        have "Acute H K M" 
        proof -
          have "Bet M C K ⟶ Acute H K M" 
            using t22_9_aux_4 ‹Acute D C M› ‹Bet M C K ⟹ Bet N D H› 
              ‹Lambert N M C D› ‹Lambert N M K H› by blast 
          moreover
          have "Bet M K C ⟶ Acute H K M"
            using t22_9_aux_3 ‹Acute D C M› ‹Bet M K C ⟹ Bet N H D› 
              ‹Lambert N M C D› ‹Lambert N M K H› by blast 
          ultimately
          show ?thesis
            using Out_def ‹M Out C K› by blast 
        qed
        hence "Acute M K H"
          by (meson acute_sym)
        ultimately
        show ?thesis
          using t22_9_aux_4 ‹Bet N M L› by blast 
      qed
      moreover
      have "L G H CongA A' B' C'"
        by (meson ‹A' B' C' CongA H G L› conga_left_comm conga_sym)
      ultimately
      show ?thesis
        using acute_conga__acute by blast 
    qed
  }
  moreover
  {
    assume "Acute A' B' C'" 
    have "Acute A B C" 
    proof -
      have "Acute D C M" 
      proof -
        have "A' B' C' CongA L G H"
          by (simp add: ‹A' B' C' CongA H G L› conga_right_comm) 
        hence"Acute L G H"
          using ‹Acute A' B' C'› acute_conga__acute by blast 
        hence "Acute M K H" 
          using ‹Lambert N M K H› ‹Lambert N L G H› 
          by (meson ‹Bet G K H› ‹Bet N M L› between_symmetry lam_perm t22_9_aux_3) 
        hence "Acute H K M"
          by (simp add: acute_sym) 
        have "Bet M C K ⟶ Acute D C M" 
          using ‹Lambert N M C D› ‹Lambert N M K H› ‹Acute H K M› 
            ‹Bet M C K ⟹ Bet N D H› t22_9_aux_3 by blast 
        moreover
        have "Bet M K C ⟶ Acute D C M"
          using ‹Lambert N M C D› ‹Lambert N M K H› ‹Acute H K M› 
            ‹Bet M K C ⟹ Bet N H D› t22_9_aux_4 by blast
        ultimately
        show ?thesis
          using Out_def ‹M Out C K› by blast 
      qed
      moreover
      have "D C M CongA A B C"
      proof -
        have "D C B CongA A B C"
          by (meson ‹A B C CongA B C D› conga_left_comm conga_sym_equiv) 
        moreover
        have "C Out D D"
          using ‹C ≠ D› out_trivial by auto 
        moreover
        have "C Out M B" 
          by (metis ‹¬ Col N M C› assms(3) bet_out_1 col_trivial_2 midpoint_bet) 
        moreover
        have "B Out A A"
          by (simp add: ‹A ≠ B› out_trivial) 
        moreover
        have "B Out C C"
          by (simp add: ‹C ≠ B› out_trivial) 
        ultimately
        show ?thesis
          using l11_10 by blast 
      qed
      ultimately
      show ?thesis
        using acute_conga__acute by blast 
    qed
  }
  ultimately
  show ?thesis by auto
qed

lemma three_hypotheses_aux_1:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "M Midpoint B C" and
    "M' Midpoint B' C'" and
    "N Midpoint A D" and
    "N' Midpoint A' D'" and
    "M N Le M' N'" and
    "Per A B C"
  shows "Per A' B' C'"
  using three_hypotheses_aux assms(1) assms(2) assms(3) assms(4) 
    assms(5) assms(6) assms(7) assms(8) by blast

lemma three_hypotheses_aux_2:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "M Midpoint B C" and
    "M' Midpoint B' C'" and
    "N Midpoint A D" and
    "N' Midpoint A' D'" and
    "M N Le M' N'" and
    "Per A' B' C'"
  shows "Per A B C"
  using three_hypotheses_aux assms(1) assms(2) assms(3) assms(4) 
    assms(5) assms(6) assms(7) assms(8) by blast

lemma three_hypotheses_aux_3:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "M Midpoint B C" and
    "M' Midpoint B' C'" and
    "N Midpoint A D" and
    "N' Midpoint A' D'" and
    "M N Le M' N'" and
    "Acute A B C"
  shows "Acute A' B' C'"
  using three_hypotheses_aux assms(1) assms(2) assms(3) assms(4) 
    assms(5) assms(6) assms(7) assms(8) by blast

lemma three_hypotheses_aux_4:
  assumes "Saccheri A B C D" and
    "Saccheri A' B' C' D'" and
    "M Midpoint B C" and
    "M' Midpoint B' C'" and
    "N Midpoint A D" and
    "N' Midpoint A' D'" and
    "M N Le M' N'" and
    "Acute A' B' C'"
  shows "Acute A B C" 
  using three_hypotheses_aux assms(1) assms(2) assms(3) assms(4) 
    assms(5) assms(6) assms(7) assms(8) by blast


(** Saccheri's three hypotheses *)

lemma per_sac__rah:
  assumes "Saccheri A B C D" and
    "Per A B C"
  shows "HypothesisRightSaccheriQuadrilaterals" 
proof -
  {
    fix A' B' C' D'
    assume "Saccheri A' B' C' D'"
    obtain M where "M Midpoint B C"
      using midpoint_existence by blast 
    obtain M' where "M' Midpoint B' C'"
      using midpoint_existence by blast 
    obtain N where "N Midpoint A D"
      using midpoint_existence by blast 
    obtain N' where "N' Midpoint A' D'"
      using midpoint_existence by blast 
    {
      assume "M N Le M' N'"
      hence "Per A' B' C'"
        using ‹M Midpoint B C› ‹M' Midpoint B' C'› ‹N Midpoint A D› 
          ‹N' Midpoint A' D'› ‹Saccheri A' B' C' D'› assms(1) assms(2) 
          three_hypotheses_aux_1 by blast 
    }
    moreover
    {
      assume "M' N' Le M N"
      hence "Per A' B' C'"
        using ‹M Midpoint B C› ‹M' Midpoint B' C'› ‹M' N' Le M N› 
          ‹N Midpoint A D› ‹N' Midpoint A' D'› ‹Saccheri A' B' C' D'› 
          assms(1) assms(2) three_hypotheses_aux_2 by blast 
    }
    ultimately
    have "Per A' B' C'"
      using local.le_cases by blast 
  }
  thus ?thesis using hypothesis_of_right_saccheri_quadrilaterals_def by blast
qed

lemma acute_sac__aah:
  assumes "Saccheri A B C D" and
    "Acute A B C"
  shows "hypothesis_of_acute_saccheri_quadrilaterals" 
proof -
  {
    fix A' B' C' D'
    assume "Saccheri A' B' C' D'"
    obtain M where "M Midpoint B C"
      using midpoint_existence by blast 
    obtain M' where "M' Midpoint B' C'"
      using midpoint_existence by blast 
    obtain N where "N Midpoint A D"
      using midpoint_existence by blast 
    obtain N' where "N' Midpoint A' D'"
      using midpoint_existence by blast 
    {
      assume "M N Le M' N'"
      hence "Acute A' B' C'"
        using ‹M Midpoint B C› ‹M' Midpoint B' C'› ‹N Midpoint A D› 
          ‹N' Midpoint A' D'› ‹Saccheri A' B' C' D'› assms(1) assms(2) 
          three_hypotheses_aux_3 by blast 
    }
    moreover
    {
      assume "M' N' Le M N"
      hence "Acute A' B' C'"
        using ‹M Midpoint B C› ‹M' Midpoint B' C'› ‹M' N' Le M N› 
          ‹N Midpoint A D› ‹N' Midpoint A' D'› ‹Saccheri A' B' C' D'› 
          assms(1) assms(2) three_hypotheses_aux_4 by blast 
    }
    ultimately
    have "Acute A' B' C'"
      using local.le_cases by blast 
  }
  thus ?thesis using hypothesis_of_acute_saccheri_quadrilaterals_def by blast
qed

lemma obtuse_sac__oah:
  assumes "Saccheri A B C D" and
    "Obtuse A B C"
  shows "hypothesis_of_obtuse_saccheri_quadrilaterals"
proof -
  have "A ≠ B"
    using assms(2) obtuse_distincts by auto 
  have "C ≠ B"
    using assms(2) obtuse_distincts by blast 
  {
    fix A' B' C' D'
    assume "Saccheri A' B' C' D'"
    {
      assume "Acute A' B' C'"
      hence "hypothesis_of_acute_saccheri_quadrilaterals" 
        using acute_sac__aah ‹Saccheri A' B' C' D'› by blast
      hence "Acute A B C"
        using assms(1) hypothesis_of_acute_saccheri_quadrilaterals_def by blast 
      hence "A B C LtA A B C"
        by (simp add: acute_obtuse__lta assms(2)) 
      hence "False"
        using nlta by blast 
    }
    moreover
    {
      assume "Per A' B' C'"
      hence "hypothesis_of_right_saccheri_quadrilaterals" 
        using per_sac__rah ‹Saccheri A' B' C' D'› by blast
      hence "Per A B C"
        using assms(1) hypothesis_of_right_saccheri_quadrilaterals_def by blast 
      hence "A B C LtA A B C"
        using ‹A ≠ B› ‹C ≠ B› assms(2) obtuse_per__lta by auto 
      hence "False"
        using nlta by blast 
    }
    ultimately
    have "Obtuse A' B' C'"
      by (metis angle_partition l8_20_1_R1 l8_5) 
  }
  thus ?thesis
    using hypothesis_of_obtuse_saccheri_quadrilaterals_def by blast 
qed

lemma per__ex_saccheri:
  assumes "Per B A D" and 
    "A ≠ B" and 
    "A ≠ D"
  shows "∃ C. Saccheri A B C D"
proof -
  have "¬ Col B A D"
    using assms(1) assms(2) assms(3) not_col_permutation_4 per_col_eq by blast
  obtain C0 where "A D Perp C0 D ∧ A D OS B C0"
    using NCol_perm ‹¬ Col B A D› col_trivial_2 l10_15 by blast 
  have "¬ Col A D C0"
    using ‹A D Perp C0 D ∧ A D OS B C0› one_side_not_col124 by blast
  obtain C where "D Out C0 C ∧ Cong D C A B"
    by (metis ‹¬ Col A D C0› assms(2) col_trivial_2 segment_construction_3)
  hence "Cong A B C D"
    using cong_3421 by blast 
  moreover
  have "Per A D C" 
  proof -
    have "D ≠ C0"
      using ‹¬ Col A D C0› col_trivial_2 by force 
    moreover
    have "Per A D C0"
      using Perp_cases ‹A D Perp C0 D ∧ A D OS B C0› perp_per_2 by blast 
    moreover
    have "Col D C0 C"
      by (simp add: ‹D Out C0 C ∧ Cong D C A B› out_col) 
    ultimately
    show ?thesis
      using per_col by blast 
  qed
  moreover
  have "A D OS B C"
    by (meson ‹A D Perp C0 D ∧ A D OS B C0› ‹D Out C0 C ∧ Cong D C A B› 
        invert_one_side out_out_one_side) 
  ultimately
  show ?thesis
    using Saccheri_def assms(1) by blast 
qed

lemma ex_saccheri:
  "∃ A B C D. Saccheri A B C D" 
proof -
  obtain A D  E where "¬ (Bet A D E ∨ Bet D E A ∨ Bet E A D)"
    using lower_dim_ex by blast
  hence "¬ Col A D E"
    by (simp add: Col_def)
  obtain B where "A D Perp B A ∧ A D OS E B"
    using ‹¬ Col A D E› col_trivial_3 l10_15 by blast 
  thus ?thesis
    using ‹A D Perp B A ∧ A D OS E B› l8_2 os_distincts 
      per__ex_saccheri perp_per_1 by metis  
qed

lemma ex_lambert:
  "∃ A B C D. Lambert A B C D" 
proof -
  obtain D C C' D' where "Saccheri D C C' D'"
    using ex_saccheri by blast
  obtain A where "A Midpoint D D'"
    using midpoint_existence by blast 
  obtain B where "B Midpoint C C'"
    using midpoint_existence by blast 
  thus ?thesis 
    using ‹Saccheri D C C' D'› sac__ex2_mid_mid_lam_conga by blast 
qed

lemma saccheri_s_three_hypotheses:
  "hypothesis_of_acute_saccheri_quadrilaterals ∨
  hypothesis_of_right_saccheri_quadrilaterals ∨
  hypothesis_of_obtuse_saccheri_quadrilaterals" 
proof -
  obtain A B C D where "Saccheri A B C D"
    using ex_saccheri by blast
  {
    assume "Acute A B C"
    hence "hypothesis_of_acute_saccheri_quadrilaterals"
      using ‹Saccheri A B C D› acute_sac__aah by blast 
  }
  moreover
  {
    assume "Per A B C"
    hence "hypothesis_of_right_saccheri_quadrilaterals"
      using ‹Saccheri A B C D› per_sac__rah by blast
  }
  moreover
  {
    assume "Obtuse A B C"
    hence "hypothesis_of_obtuse_saccheri_quadrilaterals"
      using ‹Saccheri A B C D› obtuse_sac__oah by blast 
  }
  ultimately
  show ?thesis
    using acute_sac__aah angle_partition 
      hypothesis_of_right_saccheri_quadrilaterals_def 
      obtuse_sac__oah sac_distincts by blast
qed

lemma not_aah:
  assumes "hypothesis_of_right_saccheri_quadrilaterals ∨
  hypothesis_of_obtuse_saccheri_quadrilaterals"
  shows "¬ hypothesis_of_acute_saccheri_quadrilaterals" 
proof -
  obtain A B C D where "Saccheri A B C D"
    using ex_saccheri by blast
  {
    assume "hypothesis_of_acute_saccheri_quadrilaterals" 
    have "Acute A B C"
      using ‹HypothesisAcuteSaccheriQuadrilaterals› ‹Saccheri A B C D› 
        hypothesis_of_acute_saccheri_quadrilaterals_def by blast
    {
      assume "hypothesis_of_right_saccheri_quadrilaterals"
      hence "Per A B C"
        using ‹Saccheri A B C D› hypothesis_of_right_saccheri_quadrilaterals_def 
        by blast 
      hence "A B C LtA A B C"
        using ‹Acute A B C› acute_not_per by blast
    }
    moreover
    {
      assume "hypothesis_of_obtuse_saccheri_quadrilaterals"
      hence "Obtuse A B C"
        using ‹Saccheri A B C D› hypothesis_of_obtuse_saccheri_quadrilaterals_def 
        by blast 
      hence "A B C LtA A B C"
        using ‹Acute A B C› acute__not_obtuse by blast 
    }
    ultimately
    have "A B C LtA A B C"
      using assms by blast 
    hence "False"
      by (meson nlta) 
  }
  thus ?thesis by auto
qed

lemma not_rah:
  assumes "hypothesis_of_acute_saccheri_quadrilaterals ∨ 
  hypothesis_of_obtuse_saccheri_quadrilaterals"
  shows "¬ hypothesis_of_right_saccheri_quadrilaterals"
proof -
  obtain A B C D where "Saccheri A B C D"
    using ex_saccheri by blast
  {
    assume "hypothesis_of_right_saccheri_quadrilaterals" 
    have "Per A B C"
      using ‹HypothesisRightSaccheriQuadrilaterals› ‹Saccheri A B C D› 
        hypothesis_of_right_saccheri_quadrilaterals_def by blast 
    {
      assume "hypothesis_of_acute_saccheri_quadrilaterals"
      hence "Acute A B C"
        using ‹Saccheri A B C D› ‹HypothesisRightSaccheriQuadrilaterals› 
          not_aah by blast 
      hence "A B C LtA A B C"
        using ‹Per A B C› acute_not_per by blast
    }
    moreover
    {
      assume "hypothesis_of_obtuse_saccheri_quadrilaterals"
      hence "Obtuse A B C"
        using ‹Saccheri A B C D› hypothesis_of_obtuse_saccheri_quadrilaterals_def 
        by blast 
      hence "A B C LtA A B C"
        using ‹Per A B C› ‹Saccheri A B C D› obtuse_per__lta sac_distincts 
        by blast 
    }
    ultimately
    have "A B C LtA A B C"
      using assms by blast 
    hence "False"
      by (meson nlta) 
  }
  thus ?thesis by auto
qed

lemma not_oah:
  assumes "hypothesis_of_acute_saccheri_quadrilaterals ∨ 
  hypothesis_of_right_saccheri_quadrilaterals"
  shows "¬ hypothesis_of_obtuse_saccheri_quadrilaterals"
proof -
  obtain A B C D where "Saccheri A B C D"
    using ex_saccheri by blast
  {
    assume "hypothesis_of_obtuse_saccheri_quadrilaterals" 
    have "Obtuse A B C"
      using ‹HypothesisObtuseSaccheriQuadrilaterals› assms not_aah 
        not_rah by blast
    {
      assume "hypothesis_of_acute_saccheri_quadrilaterals"
      hence "Acute A B C"
        using ‹Saccheri A B C D› ‹HypothesisObtuseSaccheriQuadrilaterals› 
          not_aah by blast
      hence "A B C LtA A B C"
        using ‹HypothesisAcuteSaccheriQuadrilaterals› 
          ‹HypothesisObtuseSaccheriQuadrilaterals› not_aah by blast
    }
    moreover
    {
      assume "hypothesis_of_right_saccheri_quadrilaterals"
      hence "Per A B C"
        using ‹Saccheri A B C D› ‹HypothesisObtuseSaccheriQuadrilaterals› 
          not_rah by blast 
      hence "A B C LtA A B C"
        using ‹Per A B C› ‹Saccheri A B C D› 
          ‹HypothesisObtuseSaccheriQuadrilaterals› 
          ‹HypothesisRightSaccheriQuadrilaterals› not_rah by blast 
    }
    ultimately
    have "A B C LtA A B C"
      using assms by blast 
    hence "False"
      by (meson nlta) 
  }
  thus ?thesis by auto
qed

lemma lam_per__rah_1:
  assumes "Lambert A B C D" and
    "Per B C D" 
  shows "hypothesis_of_right_saccheri_quadrilaterals"
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast 
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) lam6521_mid2__sac by auto 
  moreover
  have "Per D C C'"
    by (metis Per_perm ‹B Midpoint C C'› assms(2) col_per2__per 
        l8_20_1_R1 midpoint_col midpoint_distinct_1) 
  ultimately
  show ?thesis
    using per_sac__rah by blast 
qed

lemma lam_per__rah_2:
  assumes "Lambert A B C D" and
    "hypothesis_of_right_saccheri_quadrilaterals"
  shows "Per B C D"
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) lam6521_mid2__sac by blast 
  hence "Per D C C'"
    using assms(2) hypothesis_of_right_saccheri_quadrilaterals_def by blast 
  hence "Per C' C D"
    using Per_perm by blast 
  moreover
  have "C ≠ C'"
    by (metis Lambert_def ‹B Midpoint C C'› assms(1) l8_20_2) 
  moreover
  have "Col C C' B"
    using ‹B Midpoint C C'› col_permutation_1 midpoint_col by blast 
  ultimately
  show ?thesis
    using l8_3 by blast 
qed

lemma lam_per__rah:
  assumes "Lambert A B C D" 
  shows "Per B C D ⟷ hypothesis_of_right_saccheri_quadrilaterals"
  by (meson lam_per__rah_1 lam_per__rah_2 assms) 

lemma lam_acute__aah_1:
  assumes "Lambert A B C D" and
    "Acute B C D" 
  shows "hypothesis_of_acute_saccheri_quadrilaterals" 
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) lam6521_mid2__sac by blast 
  moreover
  have "Acute D C C'"
    by (metis l11_17 sac_distincts ‹B Midpoint C C'› acute__not_obtuse 
        acute_not_per angle_partition assms(2) calculation 
        conga_obtuse__obtuse l7_17_bis l7_2 sac__ex2_mid_mid_lam_conga) 
  ultimately
  show ?thesis
    using acute_sac__aah by blast 
qed


lemma lam_acute__aah_2:
  assumes "Lambert A B C D" and
    "hypothesis_of_acute_saccheri_quadrilaterals"
  shows "Acute B C D" 
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) lam6521_mid2__sac by auto 
  hence "Acute D C C'"
    using assms(2) hypothesis_of_acute_saccheri_quadrilaterals_def by blast 
  moreover
  have "D C C' CongA B C D"
    using ‹B Midpoint C C'› ‹Saccheri D C C' D'› l7_17_bis l7_2 
      sac__ex2_mid_mid_lam_conga by blast 
  ultimately
  show ?thesis
    using acute_conga__acute by blast 
qed

lemma lam_acute__aah:
  assumes "Lambert A B C D" 
  shows "Acute B C D ⟷ hypothesis_of_acute_saccheri_quadrilaterals"
  by (meson lam_acute__aah_1 lam_acute__aah_2 assms) 

lemma lam_obtuse__oah_1:
  assumes "Lambert A B C D" and
    "Obtuse B C D"
  shows "hypothesis_of_obtuse_saccheri_quadrilaterals" 
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) lam6521_mid2__sac by blast 
  moreover
  have "B C D CongA D C C'"
    by (metis ‹B Midpoint C C'› calculation l7_17_bis l7_2 
        not_conga_sym sac__ex2_mid_mid_lam_conga) 
  hence "Obtuse D C C'"
    using assms(2) conga_obtuse__obtuse by blast 
  ultimately
  show ?thesis
    using obtuse_sac__oah by blast 
qed

lemma lam_obtuse__oah_2:
  assumes "Lambert A B C D" and
    "hypothesis_of_obtuse_saccheri_quadrilaterals"
  shows "Obtuse B C D"
proof -
  obtain C' where "B Midpoint C C'"
    using symmetric_point_construction by blast 
  obtain D' where "A Midpoint D D'"
    using symmetric_point_construction by blast
  have "Saccheri D C C' D'"
    using ‹A Midpoint D D'› ‹B Midpoint C C'› assms(1) 
      lam6521_mid2__sac by blast 
  hence "Obtuse D C C'"
    using assms(2) hypothesis_of_obtuse_saccheri_quadrilaterals_def by blast 
  moreover
  have "D C C' CongA B C D" 
  proof -
    have "C Out B C'"
      using ‹B Midpoint C C'› ‹Saccheri D C C' D'› midpoint_out 
        sac_distincts by presburger 
    moreover
    have "C Out D D"
      by (metis assms(1) lam__pars1234 out_trivial par_strict_neq2) 
    ultimately
    show ?thesis
      by (meson conga_left_comm out2__conga)
  qed
  ultimately
  show ?thesis
    using conga_obtuse__obtuse by blast 
qed

lemma lam_obtuse__oah:
  assumes "Lambert A B C D"
  shows "Obtuse B C D ⟷ hypothesis_of_obtuse_saccheri_quadrilaterals"
  by (meson lam_obtuse__oah_1 lam_obtuse__oah_2 assms) 

lemma t22_11__per_1:
  assumes "Saccheri A B C D" and
    "A B D CongA B D C"
  shows "Per A B C" 
proof -
  have "Cong A D B C" 
  proof -
    have "A B D CongA C D B"
      by (simp add: assms(2) conga_right_comm) 
    moreover
    have "Cong A B C D" 
      using Saccheri_def assms(1) by blast
    hence "Cong B A D C"
      using Cong_cases by blast 
    moreover
    have "Cong B D D B"
      by (simp add: cong_pseudo_reflexivity) 
    ultimately
    show ?thesis
      using Cong_cases cong2_conga_cong by blast 
  qed
  thus ?thesis
    using assms(1) cong_sac__per_aux1 by blast
qed

lemma t22_11__per_2:
  assumes "Saccheri A B C D" and
    "Per A B C"
  shows "A B D CongA B D C" 
proof -
  have "Cong A D B C"
    by (simp add: assms(1) assms(2) cong_sac__per)
  have "A ≠ B"
    using assms(1) sac_distincts by blast 
  moreover
  have "A ≠ D" 
    using assms(1) sac_distincts by blast 
  moreover
  have "B ≠ D" 
    using assms(1) sac_distincts by blast 
  moreover
  have "Cong A B C D"
    using assms(1) Saccheri_def by blast 
  moreover
  have "Cong A D C B"
    using ‹Cong A D B C› not_cong_1243 by blast 
  moreover
  have "Cong B D D B"
    by (simp add: cong_pseudo_reflexivity) 
  ultimately
  show ?thesis
    by (simp add: conga_right_comm l11_51) 
qed

lemma t22_11__per:
  assumes "Saccheri A B C D"
  shows "A B D CongA B D C ⟷ Per A B C"
  using assms t22_11__per_1 t22_11__per_2 by blast 

lemma t22_11__acute_1:
  assumes "Saccheri A B C D" and
    "A B D LtA B D C"
  shows "Acute A B C" 
proof -
  have "A D Lt C B" 
  proof -
    have "Cong D C B A" 
      using assms(1) Saccheri_def not_cong_4321 by blast 
    moreover
    have "Cong D B B D"
      by (simp add: cong_pseudo_reflexivity) 
    moreover
    have "D B A LtA B D C"
      by (simp add: assms(2) lta_left_comm) 
    ultimately
    show ?thesis
      using t18_18 by blast 
  qed
  hence "A D Lt B C"
    using Lt_cases by blast
  thus ?thesis
    using assms(1) lt_sac__acute_aux1 by blast 
qed

lemma t22_11__acute_2:
  assumes "Saccheri A B C D" and
    "Acute A B C"
  shows "A B D LtA B D C" 
proof -
  have "D B A LtA B D C"
  proof -
    have "D ≠ C" 
      using assms(1) sac_distincts by blast 
    moreover
    have "D ≠ B"
      using assms(1) sac_distincts by blast 
    moreover
    have "Cong D C B A"
      using Cong_cases Saccheri_def assms(1) by blast 
    moreover
    have "Cong D B B D"
      by (simp add: cong_pseudo_reflexivity) 
    moreover
    have "A D Lt B C"
      by (simp add: assms(1) assms(2) lt_sac__acute_aux2)
    hence "A D Lt C B"
      by (simp add: lt_right_comm) 
    ultimately
    show ?thesis
      by (simp add: t18_19) 
  qed
  thus ?thesis
    using lta_left_comm by blast
qed

lemma t22_11__acute:
  assumes "Saccheri A B C D" 
  shows "A B D LtA B D C ⟷ Acute A B C"
  using assms t22_11__acute_1 t22_11__acute_2 by blast

lemma t22_11__obtuse_1:
  assumes "Saccheri A B C D" and
    "B D C LtA A B D" 
  shows "Obtuse A B C" 
proof -
  have "B C Lt D A" 
  proof -
    have "Cong B D D B"
      by (simp add: cong_pseudo_reflexivity) 
    moreover
    have "Cong B A D C" 
      using assms(1) Saccheri_def cong_commutativity by blast 
    moreover
    have "C D B LtA A B D"
      using assms(2) lta_left_comm by blast 
    ultimately
    show ?thesis
      using t18_18 by blast 
  qed
  hence "B C Lt A D"
    using Lt_cases by blast 
  thus ?thesis
    using assms(1) lt_sac__obtuse by blast 
qed

lemma t22_11__obtuse_2:
  assumes "Saccheri A B C D" and
    "Obtuse A B C"
  shows "B D C LtA A B D" 
proof -
  have "C D B LtA A B D" 
  proof -
    have "B ≠ D"  
      using assms(1) sac_distincts by blast 
    moreover
    have "B ≠ A" 
      using assms(1) sac_distincts by blast 
    moreover
    have "Cong B D D B"
      by (simp add: cong_pseudo_reflexivity) 
    moreover
    have "Cong B A D C" 
      using assms(1) Saccheri_def cong_commutativity by blast 
    moreover
    have "B C Lt A D"
      by (simp add: lt_sac__obtuse_aux2 assms(1) assms(2))
    hence "B C Lt D A"
      using Lt_cases by blast
    ultimately
    show ?thesis
      by (simp add: t18_19) 
  qed
  thus ?thesis
    by (meson lta_left_comm) 
qed

lemma t22_11__obtuse:
  assumes "Saccheri A B C D" 
  shows "B D C LtA A B D ⟷ Obtuse A B C"
  using assms t22_11__obtuse_1 t22_11__obtuse_2 by blast 

lemma t22_12__rah_1:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C" and
    "B C A C A B SumA A B C" 
  shows "hypothesis_of_right_saccheri_quadrilaterals" 
proof -
  obtain D where "Saccheri B A D C"
    using assms(1) assms(2) assms(3) per__ex_saccheri by blast
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234)
  hence "C A TS B D"
    by (meson Par_strict_cases ‹B C ParStrict A D› l9_31 pars__os3412)
  have "B C D CongA A B C" 
    using Saccheri_def by (metis ‹Saccheri B A D C› l11_16 sac_distincts) 
  have "C A B CongA A C D" 
  proof -
    have"SAMS B C A C A B"
      by (metis assms(4) sams123231 suma_distincts) 
    moreover
    have "SAMS B C A A C D"
      by (simp add: os_ts__sams ‹B C ParStrict A D› ‹C A TS B D› l12_6) 
    moreover
    have "B C A A C D SumA A B C"
      by (meson ‹B C D CongA A B C› ‹C A TS B D› calculation(2) 
          conga3_suma__suma sams2_suma2__conga123 sams2_suma2__conga456 ts__suma_1) 
    ultimately
    show ?thesis
      using sams2_suma2__conga456 assms(4) by blast
  qed
  hence "B A C CongA A C D"
    by (simp add: conga_left_comm) 
  hence "Per B A D"
    using ‹Saccheri B A D C› t22_11__per_1 by blast 
  thus ?thesis
    using ‹Saccheri B A D C› per_sac__rah by blast 
qed

lemma t22_12__rah_2:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C" and
    "hypothesis_of_right_saccheri_quadrilaterals"
  shows "B C A C A B SumA A B C" 
proof -
  obtain D where "Saccheri B A D C"
    using assms(1) assms(2) assms(3) per__ex_saccheri by blast
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234)
  hence "C A TS B D"
    by (meson Par_strict_cases ‹B C ParStrict A D› l9_31 pars__os3412)
  have "B C D CongA A B C" 
    using Saccheri_def by (metis ‹Saccheri B A D C› l11_16 sac_distincts) 
  have "B C A A C D SumA B C D"
    by (simp add: ‹C A TS B D› ts__suma_1) 
  moreover
  have "B C A CongA B C A"
    by (simp add: assms(1) assms(2) assms(3) cong2_per2__cong_conga2 
        cong_reflexivity) 
  moreover
  have "A C D CongA C A B"
    using ‹Saccheri B A D C› assms(4) conga_left_comm conga_sym 
      hypothesis_of_right_saccheri_quadrilaterals_def t22_11__per_2 by blast 
  ultimately
  show ?thesis
    by (meson conga3_suma__suma ‹B C D CongA A B C›) 
qed

lemma t22_12__rah:
  assumes "A ≠ B" and
    "B ≠ C" and
    "Per A B C"
  shows "B C A C A B SumA A B C ⟷ hypothesis_of_right_saccheri_quadrilaterals"
  by (meson t22_12__rah_1 t22_12__rah_2 assms(1) assms(2) assms(3)) 

lemma t22_12__aah_1:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R" and
    "Acute P Q R"
  shows "hypothesis_of_acute_saccheri_quadrilaterals"
proof -
  have "A ≠ B"
    using assms(2) suma_distincts by blast 
  have "B ≠ C"
    using assms(2) suma_distincts by blast 
  then obtain D where "Saccheri B A D C"
    using assms(1) ‹A ≠ B› per__ex_saccheri by blast 
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234) 
  have "C A TS B D"
    by (meson Par_strict_cases ‹B A ParStrict D C› 
        ‹B C ParStrict A D› l12_6 l9_31)
  have "B C D CongA A B C"
    by (metis Perp_cases par_not_col ‹A ≠ B› ‹B C ParStrict A D› ‹B ≠ C› 
        ‹Saccheri B A D C› assms(1) col_permutation_1 cong_perp_conga 
        l11_16 l7_2 l8_21_aux midpoint_cong perp_per_2 sac__perp3414 
        symmetric_point_construction ts_distincts) 
  have "C A B LtA A C D" 
  proof -
    have "B C A LeA B C A"
      using ‹B ≠ C› assms(1) lea_refl per_distinct_1 by presburger 
    moreover
    have "P Q R LtA B C D"
      by (metis ‹B C D CongA A B C› ‹C A TS B D› acute_conga__acute 
          acute_not_per acute_obtuse__lta acute_per__lta angle_partition 
          assms(1) assms(3) ts_distincts) 
    moreover
    have "SAMS B C A C A B"
      by (metis ‹A ≠ B› ‹B ≠ C› assms(1) per_distinct_1 sams123231) 
    moreover
    have "B C A C A B SumA P Q R"
      by (simp add: assms(2)) 
    moreover
    have "B C A A C D SumA B C D"
      by (simp add: ‹C A TS B D› ts__suma_1) 
    ultimately
    show ?thesis
      by (meson sams_lea_lta789_suma2__lta456) 
  qed
  hence "B A C LtA A C D"
    using lta_left_comm by blast 
  hence "Acute B A D"
    using ‹Saccheri B A D C› t22_11__acute_1 by blast
  thus ?thesis
    using ‹Saccheri B A D C› acute_sac__aah by blast 
qed

lemma t22_12__aah_2:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R" and
    "hypothesis_of_acute_saccheri_quadrilaterals"
  shows "Acute P Q R" 
proof -
  have "A ≠ B"
    using assms(2) suma_distincts by blast 
  have "B ≠ C"
    using assms(2) suma_distincts by blast 
  then obtain D where "Saccheri B A D C"
    using assms(1) ‹A ≠ B› per__ex_saccheri by blast 
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234) 
  have "C A TS B D"
    by (meson Par_strict_cases ‹B A ParStrict D C› ‹B C ParStrict A D› l12_6 l9_31)
  have "B C D CongA A B C"
    by (metis Perp_cases par_not_col  ‹A ≠ B› ‹B C ParStrict A D› 
        ‹B ≠ C› ‹Saccheri B A D C› assms(1) col_permutation_1 
        cong_perp_conga l11_16 l7_2 l8_21_aux midpoint_cong perp_per_2
        sac__perp3414 symmetric_point_construction ts_distincts) 
  have "Per B C D"
    using ‹B C D CongA A B C› assms(1) l11_17 not_conga_sym by blast 
  moreover
  have "P Q R LtA B C D" 
  proof -
    have "B C A LeA B C A"
      using assms(2) lea_total suma_distincts by blast 
    moreover
    have "C A B LtA A C D"
      using ‹Saccheri B A D C› assms(3) 
        hypothesis_of_acute_saccheri_quadrilaterals_def 
        lta_left_comm t22_11__acute by blast 
    moreover
    have "SAMS B C A A C D"
      by (simp add: os_ts__sams ‹B C ParStrict A D› ‹C A TS B D› l12_6) 
    moreover
    have "B C A C A B SumA P Q R"
      by (simp add: assms(2)) 
    moreover
    have "B C A A C D SumA B C D"
      by (simp add: ‹C A TS B D› ts__suma_1) 
    ultimately
    show ?thesis
      using sams_lea_lta456_suma2__lta by blast 
  qed
  ultimately
  show ?thesis
    using Acute_def by blast 
qed

lemma t22_12__aah:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R"
  shows "Acute P Q R ⟷ hypothesis_of_acute_saccheri_quadrilaterals"
  by (meson assms(1) assms(2) t22_12__aah_1 t22_12__aah_2) 

lemma t22_12__oah_1:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R" and
    "Obtuse P Q R" 
  shows "hypothesis_of_obtuse_saccheri_quadrilaterals" 
proof -
  have "A ≠ B"
    using assms(2) suma_distincts by blast 
  have "B ≠ C"
    using assms(2) suma_distincts by blast 
  then obtain D where "Saccheri B A D C"
    using assms(1) ‹A ≠ B› per__ex_saccheri by blast 
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234) 
  have "C A TS B D"
    by (meson Par_strict_cases ‹B A ParStrict D C› ‹B C ParStrict A D› l12_6 l9_31)
  have "B C D CongA A B C"
    by (metis Perp_cases par_not_col ‹A ≠ B› ‹B C ParStrict A D› 
        ‹B ≠ C› ‹Saccheri B A D C› assms(1) col_permutation_1 
        cong_perp_conga l11_16 l7_2 l8_21_aux midpoint_cong 
        perp_per_2 sac__perp3414 symmetric_point_construction ts_distincts) 
  have "Per B C D"
    using ‹B C D CongA A B C› assms(1) l11_17 not_conga_sym by blast 
  have "A C D LtA C A B" 
  proof -
    have "B C A LeA B C A"
      using ‹B ≠ C› assms(1) lea_refl per_distinct_1 by presburger 
    moreover
    have "B C D LtA P Q R"
      by (metis ‹B A ParStrict D C› ‹B ≠ C› ‹Per B C D› 
          assms(3) obtuse_per__lta par_strict_neq2) 
    moreover
    have "SAMS B C A A C D"
      by (simp add: os_ts__sams ‹B C ParStrict A D› ‹C A TS B D› l12_6) 
    moreover
    have "B C A A C D SumA B C D"
      by (simp add: ‹C A TS B D› ts__suma_1) 
    moreover
    have "B C A C A B SumA P Q R"
      by (simp add: assms(2)) 
    ultimately
    show ?thesis
      by (meson sams_lea_lta789_suma2__lta456) 
  qed
  hence "A C D LtA B A C"
    by (meson lta_comm lta_left_comm) 
  hence "Obtuse B A D"
    using ‹Saccheri B A D C› t22_11__obtuse_1 by blast 
  thus ?thesis
    using ‹Saccheri B A D C› obtuse_sac__oah by blast 
qed

lemma t22_12__oah_2:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R" and
    "hypothesis_of_obtuse_saccheri_quadrilaterals"
  shows "Obtuse P Q R" 
proof -
  have "A ≠ B"
    using assms(2) suma_distincts by blast 
  have "B ≠ C"
    using assms(2) suma_distincts by blast 
  then obtain D where "Saccheri B A D C"
    using assms(1) ‹A ≠ B› per__ex_saccheri by blast 
  have "B C ParStrict A D"
    by (simp add: ‹Saccheri B A D C› sac__pars1423)
  have "B A ParStrict D C"
    by (simp add: ‹Saccheri B A D C› sac__pars1234) 
  have "C A TS B D"
    by (meson Par_strict_cases ‹B A ParStrict D C› 
        ‹B C ParStrict A D› l12_6 l9_31)
  have "B C D CongA A B C"
    by (metis Perp_cases par_not_col ‹A ≠ B› ‹B C ParStrict A D› 
        ‹B ≠ C› ‹Saccheri B A D C› assms(1) col_permutation_1 
        cong_perp_conga l11_16 l7_2 l8_21_aux midpoint_cong 
        perp_per_2 sac__perp3414 symmetric_point_construction ts_distincts) 
  have "Per B C D"
    using ‹B C D CongA A B C› assms(1) l11_17 not_conga_sym by blast 
  moreover
  have "B C D LtA P Q R" 
  proof -
    have "B C A LeA B C A"
      using ‹B ≠ C› assms(1) lea_refl per_distinct_1 by presburger 
    moreover
    have "Obtuse B A D"
      using ‹Saccheri B A D C› assms(3) 
        hypothesis_of_obtuse_saccheri_quadrilaterals_def by blast 
    hence " A C D LtA C A B" 
      using ‹Saccheri B A D C› lta_right_comm 
        t22_11__obtuse_2 by blast 
    moreover
    have "SAMS B C A C A B"
      by (metis ‹A ≠ B› ‹B ≠ C› assms(1) per_distinct_1 sams123231) 
    moreover
    have "B C A A C D SumA B C D"
      by (simp add: ‹C A TS B D› ts__suma_1) 
    moreover
    have "B C A C A B SumA P Q R"
      using assms(2) by blast 
    ultimately
    show ?thesis
      by (meson sams_lea_lta456_suma2__lta) 
  qed
  ultimately
  show ?thesis
    using Obtuse_def by blast 
qed

lemma t22_12__oah:
  assumes "Per A B C" and
    "B C A C A B SumA P Q R"
  shows "Obtuse P Q R ⟷ hypothesis_of_obtuse_saccheri_quadrilaterals"
  using assms(1) assms(2) t22_12__oah_1 t22_12__oah_2 by blast 

lemma t22_14_aux:
  assumes "¬ Col A B C" and
    "Acute A B C" and
    "Acute A C B"
  shows "∃ A'. Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
  B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
  B C A CongA A' C A ∧ A A' TS B C"
proof -
  have "¬ Col B C A"
    using Col_cases assms(1) by blast 
  then obtain A' where "Col B C A' ∧ B C Perp A A'" 
    using l8_18_existence by blast 
  have "B Out A' C"
    by (meson acute_col_perp__out ‹Col B C A' ∧ B C Perp A A'› assms(2))
  have "C Out A' B" 
  proof -
    have "Acute A C B"
      by (simp add: assms(3)) 
    moreover
    have "Col C B A'"
      using NCol_cases ‹B Out A' C› out_col by blast 
    moreover
    have "C B Perp A A'"
      by (simp add: ‹Col B C A' ∧ B C Perp A A'› perp_left_comm) 
    ultimately
    show ?thesis
      by (meson acute_col_perp__out) 
  qed
  hence "Bet B A' C"
    by (simp add: ‹B Out A' C› l6_6 out2__bet) 
  moreover
  have "Per B A' A"
    using Per_perm ‹Col B C A' ∧ B C Perp A A'› col_trivial_3 l8_16_1 by blast 
  moreover
  have "Per C A' A"
    by (metis l8_3 ‹B Out A' C› ‹Col B C A' ∧ B C Perp A A'› 
        calculation(2) not_col_permutation_1 out_diff1) 
  moreover
  have "B A' A CongA C A' A"
    by (metis Out_def ‹B Out A' C› ‹C Out A' B› 
        ‹Col B C A' ∧ B C Perp A A'› ‹¬ Col B C A› 
        calculation(2) calculation(3) l11_16) 
  moreover
  have "A B C CongA A B A'"
    by (metis CongA_def out2__conga out_trivial ‹B Out A' C›
        ‹C Out A' B› calculation(3) l8_9 out_col) 
  moreover
  have "B C A CongA A' C A"
    by (metis CongA_def out2__conga out_trivial 
        ‹B Out A' C› ‹C Out A' B› calculation(2) l8_9 out_col) 
  moreover
  have "A A' TS B C"
    by (metis Out_def ‹B Out A' C› ‹C Out A' B› 
        ‹Col B C A' ∧ B C Perp A A'› assms(1) bet__ts calculation(1) 
        invert_two_sides l6_16_1 not_col_permutation_3 not_col_permutation_4) 
  ultimately
  show ?thesis
    by blast 
qed

lemma t22_14__bet_aux:
  assumes "hypothesis_of_right_saccheri_quadrilaterals" and
    " ¬ Col A B C" and
    "A B C TriSumA P Q R" and
    "Acute A B C" and 
    "Acute A C B"
  shows "Bet P Q R" 
proof -
  have "C A B TriSumA P Q R"
    by (simp add: assms(3) trisuma_perm_312)
  obtain D E F where "C A B A B C SumA D E F ∧ D E F B C A SumA P Q R"
    using TriSumA_def ‹C A B TriSumA P Q R› by blast
  obtain A' where "Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
  B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
  B C A CongA A' C A ∧ A A' TS B C"
    using assms(2) assms(4) assms(5) t22_14_aux by blast
  have "Per B A' A"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "Per C A' A" 
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "B A' A CongA C A' A" 
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "A B C CongA A B A'" 
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "B C A CongA A' C A" 
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "A A' TS B C"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "Bet B A' C" 
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  moreover
  have "B A' C CongA P Q R" 
  proof -
    have "D E F B C A SumA B A' C" 
    proof -
      have "SAMS B A' A C A A'" 
      proof -
        have "C A' A CongA B A' A"
          by (simp add: ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧ 
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› conga_sym) 
        moreover
        have "A' A C CongA C A A'"
          by (metis assms(2) calculation col_trivial_3 conga_distinct conga_pseudo_refl) 
        ultimately
        show ?thesis
          using conga2_sams__sams conga_distinct sams123231 by presburger 
      qed
      moreover
      have "SAMS C A A' B C A" 
      proof -
        have "A' A C CongA C A A'"
          using calculation conga_pseudo_refl sams_distincts by presburger 
        moreover
        have lem_acute_not_bet: "∀ x y z. Acute x y z ⟶ ¬ Bet x y z" 
          using acute_col__out assms bet_col not_bet_and_out by blast
        have "SAMS A' A C A C A'"
          by (metis ‹B A' A CongA C A' A› calculation conga_distinct sams123231) 
        hence "A C A' CongA B C A"
          by (metis out2__conga‹Bet B A' C› lem_acute_not_bet 
              acute_trivial bet_col bet_col1 between_equality_2 
              col_transitivity_1 col_trivial_3 conga_right_comm 
              or_bet_out sams_distincts) 
        ultimately
        show ?thesis
          using conga2_sams__sams conga_distinct sams123231 by auto 
      qed
      moreover
      have "B A' A C A A' SumA D E F" 
      proof -
        have "C A OS A' B"
          by (metis ‹A A' TS B C› ‹Bet B A' C› assms(2) 
              bet_out_1 not_col_permutation_2 out_one_side ts_distincts) 
        hence "SAMS C A A' A' A B"
          by (metis ‹A B C CongA A B A'› ‹Bet B A' C› assms(2) 
              bet_out col_permutation_4 conga_diff56 os2__sams out_one_side) 
        moreover
        have "SAMS A' A B A B C" 
        proof -
          have "A' A B CongA A' A B"
            using ‹Per B A' A› ‹SAMS B A' A C A A'› conga_refl 
              per_distinct sams_distincts by presburger 
          moreover
          have "A B A' CongA A B C"
            using ‹A B C CongA A B A'› conga_sym_equiv by auto 
          moreover
          have "SAMS A' A B A B A'"
            by (metis ‹B A' A CongA C A' A› calculation(2) 
                conga_distinct sams123231) 
          ultimately
          show ?thesis
            by (meson conga2_sams__sams) 
        qed
        moreover
        have "C A A' A' A B SumA C A B"
          by (simp add: ‹A A' TS B C› l9_2 ts__suma_1) 
        moreover
        have "A' A B A B C SumA B A' A" 
        proof -
          have "A' A B A B A' SumA B A' A"
            by (metis ‹B A' A CongA C A' A› ‹Per B A' A› 
                assms(1) conga_distinct t22_12__rah_2) 
          moreover
          have "A' A B CongA A' A B"
            using ‹C A A' A' A B SumA C A B› ‹SAMS C A A' A' A B› 
              sams2_suma2__conga456 by auto 
          moreover
          have "A B A' CongA A B C"
            by (simp add: ‹A B C CongA A B A'› conga_sym) 
          moreover
          have "B A' A CongA B A' A"
            by (meson suma2__conga calculation(1)) 
          ultimately
          show ?thesis
            by (meson conga3_suma__suma) 
        qed
        moreover
        have "C A B A B C SumA D E F"
          using ‹C A B A B C SumA D E F ∧ D E F B C A SumA P Q R› by blast 
        ultimately
        show ?thesis
          by (meson suma_assoc_1 suma_sym) 
      qed
      moreover
      have "C A A' B C A SumA A A' C" 
      proof -
        have "A' A C A C A' SumA C A' A"
          using ‹B A' A CongA C A' A› ‹Per C A' A› assms(1) 
            calculation(1) conga_diff45 sams_distincts t22_12__rah by blast 
        moreover
        have "A' A C CongA C A A'"
          by (metis calculation conga_pseudo_refl suma_distincts) 
        moreover
        have "A C A' CongA B C A"
          by (meson ‹B C A CongA A' C A› conga_right_comm conga_sym) 
        moreover
        have "C A' A CongA A A' C"
          using ‹B A' A CongA C A' A› conga_distinct 
            conga_pseudo_refl by blast 
        ultimately
        show ?thesis
          by (meson conga3_suma__suma) 
      qed
      moreover
      have "B A' A A A' C SumA B A' C"
        by (simp add: ‹A A' TS B C› ts__suma) 
      ultimately
      show ?thesis
        using suma_assoc by blast 
    qed
    moreover
    have "D E F B C A SumA P Q R"
      by (simp add: ‹C A B A B C SumA D E F ∧ D E F B C A SumA P Q R›) 
    ultimately
    show ?thesis
      by (meson suma2__conga) 
  qed
  ultimately
  show ?thesis
    using bet_conga__bet by blast 
qed

(** Under the Right angle hypothesis,
  the sum of the three angles of a triangle is equal to 180
  *)

lemma t22_14__bet:
  assumes "hypothesis_of_right_saccheri_quadrilaterals" and
    "A B C TriSumA P Q R"
  shows "Bet P Q R" 
proof cases
  assume "Col A B C"
  thus ?thesis
    using assms(2) col_trisuma__bet by blast 
next
  assume "¬ Col A B C"
  hence "Acute A B C ∨ Per A B C ∨ Obtuse A B C"
    using angle_partition not_col_distincts by presburger 
  have "Acute A C B ∨ Per A C B ∨ Obtuse A C B"
    by (metis ‹¬ Col A B C› angle_partition not_col_distincts)
  {
    assume "Acute A B C"
    assume "Acute A C B" 
    have "Bet P Q R" 
      using ‹¬ Col A B C› ‹Acute A B C› ‹Acute A C B› assms(1) assms(2) 
        t22_14__bet_aux by blast
  }
  moreover
  {
    assume "Acute A B C"
    assume "Per A C B ∨ Obtuse A C B" 
    hence "Acute C A B" 
      using l11_43 by (metis ‹¬ Col A B C› not_col_distincts)
    have "Acute C B A"
      by (simp add: ‹Acute A B C› acute_sym) 
    have "C A B TriSumA P Q R"
      by (simp add: assms(2) trisuma_perm_312) 
    hence "Bet P Q R"
      using ‹Acute C A B› ‹Acute C B A› assms(1) col_trisuma__bet 
        t22_14__bet_aux by blast 
  }
  moreover
  {
    assume "Per A B C ∨ Obtuse A B C"
    hence "Acute B C A"
      by (metis ‹¬ Col A B C› l11_43 not_col_distincts)
    have "Acute B A C" using l11_43
      by (metis ‹Per A B C ∨ Obtuse A B C› ‹¬ Col A B C› not_col_distincts) 
    have "B A C TriSumA P Q R"
      by (simp add: assms(2) trisuma_perm_213) 
    hence "Bet P Q R"
      using ‹Acute B A C› ‹Acute B C A› assms(1) col_trisuma__bet 
        t22_14__bet_aux by blast 
  }
  ultimately
  show ?thesis
    using ‹Acute A B C ∨ Per A B C ∨ Obtuse A B C› 
      ‹Acute A C B ∨ Per A C B ∨ Obtuse A C B› by fastforce 
qed

lemma t22_14__sams_nbet_aux:
  assumes "hypothesis_of_acute_saccheri_quadrilaterals" and
    "¬ Col A B C" and
    "C A B A B C SumA D E F" and
    "D E F B C A SumA P Q R" and
    "Acute A B C" and
    "Acute A C B" 
  shows "SAMS D E F B C A ∧ ¬ Bet P Q R"
proof -
  obtain A' where
    "Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
  B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
  B C A CongA A' C A ∧ A A' TS B C"
    using assms(2) assms(5) assms(6) t22_14_aux by blast
  have "Bet B A' C"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "Per B A' A"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "Per C A' A"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "B A' A CongA C A' A"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "A B C CongA A B A'"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "B C A CongA A' C A"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "A A' TS B C"
    using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C› by auto
  have "A ≠ B"
    using assms(2) col_trivial_1 by auto 
  have "C ≠ B"
    using assms(2) col_trivial_2 by blast 
  have "A ≠ C"
    using assms(2) col_trivial_3 by auto 
  have "A ≠ A'"
    using ‹B A' A CongA C A' A› conga_diff56 by auto 
  have "A' ≠ B"
    using ‹A B C CongA A B A'› conga_diff56 by auto 
  have "A' ≠ C"
    using ‹B C A CongA A' C A› conga_diff45 by auto 
  have "P ≠ Q"
    using assms(4) suma_distincts by blast 
  have "R ≠ Q"
    using assms(4) suma_distincts by blast 
  obtain G H I where "B A' A C A A' SumA G H I"
    using ‹A ≠ A'› ‹A ≠ C› ‹A' ≠ B› ex_suma by presburger
  have "D E F LtA G H I" 
  proof -
    obtain V W X where "A' A B A B C SumA V W X"
      using ‹A ≠ A'› ‹A ≠ B› ‹C ≠ B› ex_suma by presburger
    have "V ≠ W"
      using ‹A' A B A B C SumA V W X› suma_distincts by presburger 
    have "X ≠ W"
      using ‹A' A B A B C SumA V W X› suma_distincts by blast 
    have "A' A B A B A' SumA V W X"
      using ‹A ≠ A'› ‹A ≠ B› ‹A' A B A B C SumA V W X› 
        ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧ B A' A CongA C A' A ∧ 
    A B C CongA A B A' ∧ B C A CongA A' C A ∧ A A' TS B C› 
        ‹V ≠ W› ‹X ≠ W› conga3_suma__suma conga_refl by presburger 
    hence "V W X LtA B A' A" 
      using ‹Per B A' A› assms(1) ‹A ≠ A'› ‹A' ≠ B› acute_per__lta 
        t22_12__aah_2 by presburger 
    moreover
    have "SAMS C A A' B A' A"
      by (metis ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Per B A' A› ‹Per C A' A› 
          acute_per__sams acute_sym l11_43 sams_sym) 
    moreover
    have "C A A' V W X SumA D E F" 
    proof -
      have "SAMS C A A' A' A B"
        by (meson os_ts__sams ‹A A' TS B C› ‹A' ≠ C› ‹Bet B A' C› 
            assms(2) bet_out_1 l9_2 not_col_permutation_2 out_one_side) 
      moreover
      have "SAMS A' A B A B C"
        using ‹A ≠ A'› ‹A' ≠ B› ‹Per B A' A› acute2__sams assms(5) 
          l11_43 by force 
      moreover
      have "C A A' A' A B SumA C A B"
        by (metis ‹A' ≠ B› ‹B C A CongA A' C A› ‹Bet B A' C› assms(2) 
            bet__ts between_symmetry col_permutation_3 col_permutation_5 
            ncol_conga_ncol ts__suma) 
      ultimately
      show ?thesis
        by (meson suma_assoc ‹A' A B A B C SumA V W X› assms(3)) 
    qed
    ultimately
    show ?thesis
      by (metis not_and_lta ‹B A' A C A A' SumA G H I› nlta__lea 
          sams_lea_lta456_suma2__lta123 suma_distincts suma_sym) 
  qed
  obtain J K L where "C A A' B C A SumA J K L"
    using ‹A ≠ A'› ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
  have "J ≠ K"
    using ‹C A A' B C A SumA J K L› suma_distincts by presburger 
  have "L ≠ K"
    using ‹C A A' B C A SumA J K L› suma_distincts by blast 
  have "J K L LtA A A' C"
  proof -
    have "Acute J K L" 
    proof -
      have "Per C A' A"
        by (simp add: ‹Per C A' A›) 
      moreover
      have "A' A C A C A' SumA J K L" 
      proof -
        have "C A A' CongA A' A C"
          using ‹A ≠ A'› ‹A ≠ C› conga_pseudo_refl by force 
        moreover
        have "B C A CongA A C A'"
          by (simp add: ‹B C A CongA A' C A› conga_right_comm) 
        moreover
        have "J K L CongA J K L"
          by (simp add: ‹J ≠ K› ‹L ≠ K› conga_refl) 
        ultimately
        show ?thesis
          by (meson conga3_suma__suma ‹C A A' B C A SumA J K L›) 
      qed
      ultimately
      show ?thesis
        using assms(1) t22_12__aah by blast 
    qed
    moreover
    have "Per A A' C"
      by (simp add: ‹Per C A' A› l8_2) 
    ultimately
    show ?thesis
      by (simp add: ‹A ≠ A'› ‹A' ≠ C› acute_per__lta) 
  qed
  have "SAMS G H I B C A"
  proof -
    have "SAMS B A' A C A A'"
      by (metis ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Per B A' A› 
          ‹Per C A' A› acute_per__sams acute_sym l11_43) 
    moreover
    have "SAMS C A A' B C A"
      by (metis ‹A ≠ A'› ‹A' ≠ C› ‹Per C A' A› acute2__sams 
          acute_sym assms(6) l11_43) 
    moreover
    have "SAMS B A' A J K L"
      by (metis ‹A' ≠ B› ‹A' ≠ C› ‹Bet B A' C› ‹J K L LtA A A' C› 
          lta__lea sams_chara) 
    ultimately
    show ?thesis
      using ‹B A' A C A A' SumA G H I› ‹C A A' B C A SumA J K L› 
        sams_assoc by blast 
  qed
  obtain S T U where "G H I B C A SumA S T U"
    using ‹SAMS G H I B C A› ex_suma sams_distincts by presburger
  have "S ≠ T"
    using ‹G H I B C A SumA S T U› suma_distincts by blast
  have "U ≠ T" 
    using ‹G H I B C A SumA S T U› suma_distincts by blast
  have "S T U LtA  B A' C" 
  proof -
    have "B A' A LeA B A' A"
      using ‹A ≠ A'› ‹A' ≠ B› lea_refl by auto 
    moreover
    have "J K L LtA A A' C"
      by (simp add: ‹J K L LtA A A' C›) 
    moreover
    have "SAMS B A' A A A' C"
      using ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Bet B A' C› 
        bet__sams by force 
    moreover
    have "B A' A J K L SumA S T U" 
    proof -
      have "SAMS B A' A C A A'"
        by (metis ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Per B A' A› 
            ‹Per C A' A› acute_per__sams acute_sym l11_43) 
      moreover
      have "SAMS C A A' B C A"
        by (metis ‹A ≠ A'› ‹A' ≠ C› ‹Per C A' A› acute2__sams 
            acute_sym assms(6) l11_43) 
      ultimately
      show ?thesis
        by (meson ‹G H I B C A SumA S T U› ‹C A A' B C A SumA J K L› 
            ‹B A' A C A A' SumA G H I› suma_assoc_1) 
    qed
    moreover
    have "B A' A A A' C SumA B A' C"
      using ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Bet B A' C› 
        bet__suma by auto 
    ultimately
    show ?thesis
      by (meson sams_lea_lta456_suma2__lta) 
  qed
  have "SAMS D E F B C A"
  proof -
    have "D E F LeA G H I"
      by (simp add: ‹D E F LtA G H I› lta__lea) 
    moreover
    have "B C A LeA B C A"
      using ‹A ≠ C› ‹C ≠ B› lea_refl by auto 
    ultimately
    show ?thesis
      using ‹SAMS G H I B C A› sams_lea2__sams by blast 
  qed
  moreover
  {
    assume "Bet P Q R"
    have "P Q R LtA P Q R" 
    proof -
      have "P Q R CongA P Q R"
        by (simp add: ‹P ≠ Q› ‹R ≠ Q› conga_refl) 
      moreover
      have "B A' C CongA P Q R"
        by (metis conga_line ‹A' ≠ B› ‹A' ≠ C› ‹Bet B A' C› 
            ‹Bet P Q R› ‹P ≠ Q› ‹R ≠ Q›) 
      moreover
      have "B C A LeA B C A"
        using ‹A ≠ C› ‹C ≠ B› lea_refl by auto 
      hence "P Q R LtA S T U" 
        using ‹D E F LtA G H I› ‹SAMS G H I B C A› assms(4) 
          ‹G H I B C A SumA S T U› sams_lea_lta123_suma2__lta by blast 
      hence "P Q R LtA B A' C" 
        using lta_trans ‹S T U LtA B A' C› by blast 
      ultimately
      show ?thesis
        using conga_preserves_lta by blast 
    qed
    hence "False"
      using nlta by blast 
  }
  hence "¬ Bet P Q R" 
    by blast
  ultimately
  show ?thesis
    by auto
qed


(** Under the Acute angle hypothesis,
  the sum of the three angles of a triangle is less than 180
  *)

lemma t22_14__sams_nbet:
  assumes "hypothesis_of_acute_saccheri_quadrilaterals" and
    "¬ Col A B C" and
    "C A B A B C SumA D E F" and
    "D E F B C A SumA P Q R"
  shows "SAMS D E F B C A ∧ ¬ Bet P Q R" 
proof -
  have "A ≠ B"
    using assms(2) col_trivial_1 by blast
  have "A ≠ C"
    using assms(2) col_trivial_3 by blast 
  have "B ≠ C"
    using assms(2) col_trivial_2 by blast 
  {
    assume "Acute A B C"
    assume "Acute A C B"
    hence "SAMS D E F B C A ∧ ¬ Bet P Q R"
      using ‹Acute A B C› assms(1) assms(2) assms(3) assms(4) 
        t22_14__sams_nbet_aux by blast 
  }
  moreover
  {
    assume "Acute A B C"
    assume "Per A C B ∨ Obtuse A C B"
    have "Acute C A B" 
      using l11_43 by (metis ‹A ≠ C› ‹Acute A B C› 
          ‹Per A C B ∨ Obtuse A C B› acute__not_obtuse acute_not_per) 
    have "Acute C B A"
      by (simp add: ‹Acute A B C› acute_sym)
    obtain G H I where "B C A C A B SumA G H I"
      using ‹A ≠ B› ‹A ≠ C› ‹B ≠ C› ex_suma by presburger
    have "G ≠ H"
      using ‹B C A C A B SumA G H I› suma_distincts by blast
    have "H ≠ I"
      using ‹B C A C A B SumA G H I› suma_distincts by presburger
    have "G H I A B C SumA P Q R" 
    proof -
      have "SAMS B C A C A B"
        using ‹A ≠ B› ‹A ≠ C› ‹B ≠ C› sams123231 by auto 
      moreover
      have "SAMS C A B A B C"
        using ‹A ≠ B› ‹A ≠ C› ‹B ≠ C› sams123231 by presburger 
      moreover
      have "B C A D E F SumA P Q R"
        by (meson assms(4) suma_sym) 
      ultimately
      show ?thesis
        using ‹B C A C A B SumA G H I› assms(3) suma_assoc by blast 
    qed
    hence "SAMS D E F B C A ∧ ¬ Bet P Q R"
      by (metis ‹A ≠ B› ‹A ≠ C› ‹Acute C A B› ‹Acute C B A› 
          ‹B C A C A B SumA G H I› ‹B ≠ C› assms(1) assms(2) assms(3) 
          not_col_permutation_2 sams123231 sams_assoc sams_sym 
          t22_14__sams_nbet_aux) 
  }
  moreover
  {
    assume "Per A B C ∨ Obtuse A B C"
    have "Acute B A C" 
      using l11_43 ‹A ≠ B› ‹B ≠ C› ‹Per A B C ∨ Obtuse A B C› by auto 
    have "Acute B C A" 
      using l11_43 ‹A ≠ B› ‹B ≠ C› ‹Per A B C ∨ Obtuse A B C› by auto 
    hence "SAMS D E F B C A ∧ ¬ Bet P Q R"
      by (meson Bet_cases ‹Acute B A C› assms(1) assms(2) assms(3) 
          assms(4) col_permutation_4 sams_comm suma_comm suma_sym 
          t22_14__sams_nbet_aux) 
  }
  ultimately
  show ?thesis
    by (metis angle_partition l8_2 l8_5) 
qed

lemma t22_14__nsams_aux:
  assumes "hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "¬ Col A B C" and
    "C A B A B C SumA D E F" and
    "Acute A B C" and
    "Acute A C B" 
  shows "¬ SAMS D E F B C A" 
proof -
  {
    assume "SAMS D E F B C A" 
    obtain A' where
      "Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
    B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
    B C A CongA A' C A ∧ A A' TS B C"
      using assms(2) assms(5) assms(4) t22_14_aux by blast
    have "Bet B A' C"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "Per B A' A"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "Per C A' A"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "B A' A CongA C A' A"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "A B C CongA A B A'"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "B C A CongA A' C A"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "A A' TS B C"
      using ‹Bet B A' C ∧ Per B A' A ∧ Per C A' A ∧
      B A' A CongA C A' A ∧ A B C CongA A B A' ∧ 
      B C A CongA A' C A ∧ A A' TS B C› by auto
    have "A ≠ B"
      using assms(2) col_trivial_1 by auto 
    have "C ≠ B"
      using assms(2) col_trivial_2 by blast 
    have "A ≠ C"
      using assms(2) col_trivial_3 by auto 
    have "A ≠ A'"
      using ‹B A' A CongA C A' A› conga_diff56 by auto 
    have "A' ≠ B"
      using ‹A B C CongA A B A'› conga_diff56 by auto 
    have "A' ≠ C"
      using ‹B C A CongA A' C A› conga_diff45 by auto 
    have "D ≠ E"
      using ‹SAMS D E F B C A› sams_distincts by blast
    have "E ≠ F"
      using assms(3) suma_distincts by blast
    obtain P Q R where "D E F B C A SumA P Q R"
      using ‹A ≠ C› ‹C ≠ B› ‹D ≠ E› ‹E ≠ F› ex_suma by presburger
    have "P ≠ Q"
      using ‹D E F B C A SumA P Q R› suma_distincts by blast
    have "R ≠ Q"
      using ‹D E F B C A SumA P Q R› suma_distincts by blast
    have "B A' C LtA P Q R" 
    proof -
      obtain G H I where "B A' A C A A' SumA G H I"
        using ‹A ≠ A'› ‹A ≠ C› ‹A' ≠ B› ex_suma by presburger
      have "G ≠ H"
        by (metis suma_distincts ‹B A' A C A A' SumA G H I›) 
      have "I ≠ H"
        by (metis suma_distincts ‹B A' A C A A' SumA G H I›) 
      have "G H I LtA D E F"
      proof -
        obtain V W X where "A' A B A B C SumA V W X"
          using ‹A ≠ A'› ‹A ≠ B› ‹C ≠ B› ex_suma by presburger
        have "V ≠ W"
          by (metis suma_distincts ‹A' A B A B C SumA V W X›) 
        have "X ≠ W"
          by (metis suma_distincts ‹A' A B A B C SumA V W X›) 
        have "SAMS C A A' A' A B"
          by (meson os_ts__sams ‹A A' TS B C› ‹A' ≠ C› ‹Bet B A' C› 
              assms(2) bet_out_1 l9_2 not_col_permutation_2 out_one_side)
        have "SAMS A' A B A B C"
          using ‹A ≠ A'› ‹A' ≠ B› ‹Per B A' A› acute2__sams 
            assms(4) l11_43 by force
        have "C A A' A' A B SumA C A B"
          by (meson ‹A' ≠ B› ‹B C A CongA A' C A› ‹Bet B A' C› 
              assms(2) bet__ts between_symmetry col_permutation_2 
              ncol_conga_ncol not_col_permutation_5 ts__suma)
        have "C A A' LeA C A A'"
          using ‹A ≠ A'› ‹A ≠ C› lea_refl by auto 
        moreover
        have "A' A B A B A' SumA V W X"
          by (meson ‹A B C CongA A B A'› ‹A' A B A B C SumA V W X› 
              ‹SAMS A' A B A B C› conga3_suma__suma 
              sams2_suma2__conga123 suma2__conga) 
        hence "Obtuse V W X" 
          using ‹Per B A' A› assms(1) t22_12__oah by blast 
        hence "B A' A LtA V W X" 
          using ‹Per B A' A› ‹A ≠ A'› ‹A' ≠ B› 
            obtuse_per__lta by auto 
        moreover
        have "SAMS C A A' V W X"
          by (metis ‹A ≠ B› ‹A ≠ C› ‹A' A B A B C SumA V W X› 
              ‹C A A' A' A B SumA C A B› ‹C ≠ B› ‹SAMS A' A B A B C› 
              ‹SAMS C A A' A' A B› sams123231 sams_assoc_1) 
        moreover
        have "C A A' B A' A SumA G H I"
          by (simp add: ‹B A' A C A A' SumA G H I› suma_sym) 
        moreover
        have "C A A' V W X SumA D E F"
          by (meson ‹A' A B A B C SumA V W X› 
              ‹C A A' A' A B SumA C A B› ‹SAMS A' A B A B C› 
              ‹SAMS C A A' A' A B› assms(3) suma_assoc_1) 
        ultimately
        show ?thesis
          using sams_lea_lta456_suma2__lta by blast 
      qed
      obtain J K L where "C A A' B C A SumA J K L"
        using ‹A ≠ A'› ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
      have "J ≠ K"
        using ‹C A A' B C A SumA J K L› conga_distinct 
          suma2__conga by blast 
      have "L ≠ K"
        using ‹C A A' B C A SumA J K L› conga_distinct 
          suma2__conga by blast 
      have "A A' C LtA J K L" 
      proof -
        have "A' A C A C A' SumA J K L" 
        proof -
          have "C A A' CongA A' A C"
            using ‹A ≠ A'› ‹A ≠ C› conga_pseudo_refl by auto 
          moreover
          have "B C A CongA A C A'"
            using ‹B C A CongA A' C A› conga_right_comm by blast 
          moreover
          have "J K L CongA J K L"
            using ‹J ≠ K› ‹L ≠ K› conga_refl by presburger 
          ultimately
          show ?thesis
            using ‹C A A' B C A SumA J K L› conga3_suma__suma by blast 
        qed
        hence "Obtuse J K L" 
          using ‹Per C A' A› assms(1) t22_12__oah by blast 
        moreover
        have "Per A A' C"
          using Per_perm ‹Per C A' A› by blast 
        ultimately
        show ?thesis
          by (simp add: ‹A ≠ A'› ‹A' ≠ C› obtuse_per__lta) 
      qed
      obtain S T U where "B A' A J K L SumA S T U"
        using ‹A ≠ A'› ‹A' ≠ B› ‹J ≠ K› ‹L ≠ K› ex_suma by fastforce
      have "S ≠ T"
        by (metis suma_distincts ‹B A' A J K L SumA S T U›) 
      have "U ≠ T"
        by (metis suma_distincts ‹B A' A J K L SumA S T U›) 
      have "B A' C LtA S T U" 
      proof -
        have "B A' A LeA B A' A"
          using ‹A ≠ A'› ‹A' ≠ B› lea_refl by force 
        moreover
        have "A A' C LtA J K L"
          by (simp add: ‹A A' C LtA J K L›) 
        moreover
        have "SAMS B A' A J K L" 
        proof -
          have "SAMS B A' A C A A'"
            by (metis acute_sym ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› 
                ‹Per B A' A› ‹Per C A' A› acute_per__sams l11_43) 
          moreover
          have "SAMS C A A' B C A"
            by (metis ‹A ≠ A'› ‹A' ≠ C› ‹Per C A' A› 
                acute2__sams acute_sym assms(5) l11_43) 
          moreover
          have "SAMS G H I B C A" 
          proof -
            have "SAMS D E F B C A"
              by (simp add: ‹SAMS D E F B C A›) 
            moreover
            have "G H I LeA D E F"
              by (simp add: ‹G H I LtA D E F› lta__lea) 
            moreover
            have "B C A LeA B C A"
              using ‹A ≠ C› ‹C ≠ B› lea_refl by auto 
            ultimately
            show ?thesis
              by (meson sams_lea2__sams) 
          qed
          ultimately
          show ?thesis
            by (meson ‹B A' A C A A' SumA G H I› 
                ‹C A A' B C A SumA J K L› sams_assoc_1) 
        qed
        moreover
        have "B A' A A A' C SumA B A' C"
          using ‹A ≠ A'› ‹A' ≠ B› ‹A' ≠ C› ‹Bet B A' C› 
            bet__suma by auto 
        moreover
        have "B A' A J K L SumA S T U"
          by (simp add: ‹B A' A J K L SumA S T U›) 
        ultimately
        show ?thesis
          using sams_lea_lta456_suma2__lta by blast 
      qed
      moreover
      have "S T U LtA P Q R" 
      proof -
        have "G H I LtA D E F"
          using ‹G H I LtA D E F› by blast 
        moreover
        have "B C A LeA B C A"
          using ‹A ≠ C› ‹C ≠ B› lea_refl by auto 
        moreover
        have "SAMS D E F B C A"
          by (simp add: ‹SAMS D E F B C A›) 
        moreover
        have "G H I B C A SumA S T U"
          by (meson ‹B A' C LtA S T U› ‹Bet B A' C› 
              bet_col col_lta__out not_bet_and_out) 
        moreover
        have "D E F B C A SumA P Q R"
          by (simp add: ‹D E F B C A SumA P Q R›) 
        ultimately
        show ?thesis
          by (meson sams_lea_lta123_suma2__lta) 
      qed
      ultimately
      show ?thesis
        using lta_trans by blast 
    qed
    hence "False"
      by (meson ‹Bet B A' C› bet_col col_lta__out not_bet_and_out) 
  }
  thus ?thesis by auto
qed

(** Under the Obtuse angle hypothesis,
  the sum of the three angles of a triangle is greater than 180
  *)

lemma t22_14__nsams:
  assumes "hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "¬ Col A B C" and
    "C A B A B C SumA D E F"
  shows "¬ SAMS D E F B C A" 
proof -
  have "A ≠ B"
    using assms(2) col_trivial_1 by auto 
  have "C ≠ B"
    using assms(2) not_col_distincts by blast 
  have "A ≠ C"
    using assms(2) col_trivial_3 by blast 
  {
    assume "Acute A B C" 
    {
      assume "Acute A C B" 
      have "¬ SAMS D E F B C A"
        by (simp add: t22_14__nsams_aux ‹Acute A B C› ‹Acute A C B› 
            assms(1) assms(2) assms(3)) 
    }
    moreover
    {
      assume "Per A C B ∨ Obtuse A C B" 
      have "Acute C A B" 
        using l11_43 ‹A ≠ C› ‹C ≠ B› ‹Per A C B ∨ Obtuse A C B› by auto 
      have "Acute C B A" 
        using l11_43 ‹A ≠ C› ‹C ≠ B› ‹Per A C B ∨ Obtuse A C B› by auto 
      obtain G H I where "B C A C A B SumA G H I"
        using ‹A ≠ B› ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
      have "G ≠ H"
        using ‹B C A C A B SumA G H I› suma_distincts by blast 
      have "I ≠ H"
        using ‹B C A C A B SumA G H I› suma_distincts by blast 
      {
        assume "SAMS D E F B C A" 
        have "¬ SAMS G H I A B C"
          by (simp add: ‹Acute C A B› ‹Acute C B A› ‹B C A C A B SumA G H I›
              assms(1) assms(2) not_col_permutation_2 t22_14__nsams_aux) 
        hence "False"
          by (metis ‹A ≠ B› ‹A ≠ C› ‹B C A C A B SumA G H I› ‹C ≠ B› 
              ‹SAMS D E F B C A› assms(3) sams123231 sams_assoc sams_sym) 
      }
      hence "¬ SAMS D E F B C A"
        by blast 
    }
    ultimately
    have "¬ SAMS D E F B C A"
      using ‹A ≠ C› ‹C ≠ B› angle_partition by blast 
  }
  moreover
  {
    assume "Per A B C ∨ Obtuse A B C" 
    have "Acute B A C" 
      using l11_43 ‹A ≠ B› ‹C ≠ B› ‹Per A B C ∨ Obtuse A B C› by force 
    have "Acute B C A" 
      using l11_43 ‹A ≠ B› ‹C ≠ B› ‹Per A B C ∨ Obtuse A B C› by auto 
    {
      assume "SAMS D E F B C A" 
      hence "SAMS D E F A C B"
        by (simp add: sams_right_comm) 
      have "False"
        by (meson t22_14__nsams_aux ‹Acute B A C› ‹Acute B C A› 
            ‹SAMS D E F A C B› assms(1) assms(2) assms(3) 
            not_col_permutation_4 sams_left_comm suma_comm suma_sym) 
    }
    hence "¬ SAMS D E F B C A"
      by auto 
  }
  ultimately
  show ?thesis
    by (metis ‹A ≠ B› ‹C ≠ B› angle_partition) 
qed

(** If the sum of the angles of a non-degenerate triangle is equal to 180,
  then the Right angle hypothesis holds
  *)

lemma t22_14__rah:
  assumes "¬ Col A B C" and
    "A B C TriSumA P Q R" and
    "Bet P Q R"
  shows "hypothesis_of_right_saccheri_quadrilaterals" 
proof -
  have "C A B TriSumA P Q R"
    using assms(2) trisuma_perm_312 by blast
  {
    assume "hypothesis_of_acute_saccheri_quadrilaterals"
    obtain D E F where "C A B A B C SumA D E F" 
      using ‹C A B TriSumA P Q R› TriSumA_def by blast 
    have "¬ Bet P Q R" 
    proof -
      have "¬ Col A B C"
        by (simp add: assms(1)) 
      moreover
      have "C A B A B C SumA D E F"
        using ‹C A B A B C SumA D E F› by blast 
      moreover
      have "D E F B C A SumA P Q R"
        by (meson TriSumA_def ‹C A B TriSumA P Q R› assms(3) 
            bet_suma__sams calculation(2) conga3_suma__suma 
            sams2_suma2__conga456 suma2__conga) 
      ultimately
      show ?thesis
        using t22_14__sams_nbet ‹HypothesisAcuteSaccheriQuadrilaterals› by blast 
    qed
    hence "False"
      using assms(3) by auto 
  }
  moreover
  {
    assume "hypothesis_of_obtuse_saccheri_quadrilaterals" 
    obtain D E F where "C A B A B C SumA D E F ∧ D E F B C A SumA P Q R"
      using ‹C A B TriSumA P Q R› TriSumA_def by blast 
    have "C A B A B C SumA D E F "
      by (simp add: ‹C A B A B C SumA D E F ∧ D E F B C A SumA P Q R›) 
    have "SAMS D E F B C A"
      using ‹C A B A B C SumA D E F ∧ D E F B C A SumA P Q R› 
        assms(3) bet_suma__sams by blast 
    hence "False"
      using ‹C A B A B C SumA D E F› 
        ‹HypothesisObtuseSaccheriQuadrilaterals› assms(1) 
        t22_14__nsams by blast 
  }
  ultimately
  show ?thesis
    using saccheri_s_three_hypotheses by blast 
qed

(** If the sum of the angles of a triangle is less than 180,
  then the Acute angle hypothesis holds
  *)

lemma t22_14__aah:
  assumes "C A B A B C SumA D E F" and
    "D E F B C A SumA P Q R" and
    "SAMS D E F B C A" and
    "¬ Bet P Q R"
  shows "hypothesis_of_acute_saccheri_quadrilaterals" 
proof -
  {
    assume "hypothesis_of_right_saccheri_quadrilaterals"
    have "A B C TriSumA P Q R"
      using TriSumA_def assms(1) assms(2) trisuma_perm_231 by blast 
    hence "Bet P Q R"
      using ‹HypothesisRightSaccheriQuadrilaterals› t22_14__bet by blast 
    hence "False"
      using assms(4) by auto 
  }
  moreover
  {
    assume "hypothesis_of_obtuse_saccheri_quadrilaterals"
    {
      assume "Col A B C"
      have "C A B TriSumA P Q R"
        using TriSumA_def assms(1) assms(2) by blast 
      hence "Bet P Q R"
        using ‹Col A B C› col_trisuma__bet not_col_permutation_1 by blast 
      hence "False"
        using assms(4) by blast 
    }
    moreover
    {
      assume "¬ Col A B C"
      hence "¬ SAMS D E F B C A"
        by (simp add: t22_14__nsams ‹HypothesisObtuseSaccheriQuadrilaterals› assms(1)) 
      hence "False"
        using assms(3) by auto 
    }
    ultimately
    have "False" 
      by auto
  }
  ultimately
  show ?thesis
    using saccheri_s_three_hypotheses by blast 
qed

(** If the sum of the angles of a triangle is greater than 180,
  then the Obtuse angle hypothesis holds
  *)

lemma t22_14__oah:
  assumes "C A B A B C SumA D E F" and
    "¬ SAMS D E F B C A"
  shows "hypothesis_of_obtuse_saccheri_quadrilaterals" 
proof -
  have "A ≠ B"
    using assms(1) suma_distincts by auto 
  have "A ≠ C"
    using assms(1) suma_distincts by blast 
  have "C ≠ B"
    using assms(1) suma_distincts by blast 
  have "D ≠ E"
    using assms(1) suma_distincts by blast 
  have "F ≠ E"
    using assms(1) suma_distincts by blast 
  {
    assume "Col A B C"
    have "SAMS D E F B C A" 
    proof -
      {
        assume "Bet A B C"
        hence "SAMS D E F B C A"
          by (metis ‹C ≠ B› ‹D ≠ E› ‹F ≠ E› bet_out between_symmetry 
              out213__sams sams_sym) 
      }
      moreover
      {
        assume "¬ Bet A B C"
        hence "B Out A C"
          using ‹Col A B C› l6_4_2 by blast 
        hence "C A B CongA D E F"
          using assms(1) out546_suma__conga by auto 
        moreover
        have "B C A CongA B C A"
          using ‹A ≠ C› ‹C ≠ B› conga_pseudo_refl conga_right_comm by presburger 
        moreover
        have "SAMS C A B B C A"
          using ‹A ≠ B› ‹A ≠ C› ‹C ≠ B› sams123231 sams_comm by presburger 
        ultimately
        have "SAMS D E F B C A"
          using conga2_sams__sams by blast 
      }
      ultimately
      show ?thesis 
        by auto
    qed
    hence "False"
      using assms(2) by auto 
    hence "hypothesis_of_obtuse_saccheri_quadrilaterals" 
      by auto
  }
  moreover
  {
    assume "¬ Col A B C"
    obtain P Q R where "D E F B C A SumA P Q R"
      using ‹A ≠ C› ‹C ≠ B› ‹D ≠ E› ‹F ≠ E› ex_suma by presburger
    {
      assume "hypothesis_of_acute_saccheri_quadrilaterals" 
      hence "SAMS D E F B C A" 
        using t22_14__sams_nbet ‹D E F B C A SumA P Q R› 
          ‹¬ Col A B C› assms(1) by blast
      hence "False"
        using assms(2) by auto 
    }
    moreover
    {
      assume "hypothesis_of_right_saccheri_quadrilaterals" 
      have "C A B TriSumA P Q R" 
        using ‹C A B A B C SumA D E F› TriSumA_def 
          ‹D E F B C A SumA P Q R› by blast 
      hence "Bet P Q R"
        using ‹HypothesisRightSaccheriQuadrilaterals› 
          t22_14__bet by blast 
      hence "SAMS D E F B C A" 
        using bet_suma__sams ‹D E F B C A SumA P Q R› by auto 
      hence "False"
        using assms(2) by auto 
    }
    ultimately
    have "hypothesis_of_obtuse_saccheri_quadrilaterals"
      using saccheri_s_three_hypotheses by blast 
  }
  ultimately
  show ?thesis
    by blast
qed

(** If C is on the circle of diameter AB, then we have the angles equation A + B = C *)

lemma cong_mid__suma:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" 
  shows "C A B A B C SumA A C B" 
proof -
  have "A ≠ B"
    using assms(1) col_trivial_1 by blast 
  have "C ≠ B"
    using assms(1) not_col_distincts by blast 
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto 
  have "A ≠ M"
    using ‹A ≠ B› assms(2) is_midpoint_id by blast
  have "M ≠ B"
    using ‹A ≠ B› assms(2) midpoint_not_midpoint by blast 
  have "M ≠ C"
    using NCol_cases assms(1) assms(2) midpoint_col by blast
  have "A B C CongA M C B" 
  proof -
    have "M B C CongA M C B"
      by (metis ‹C ≠ B› assms(2) assms(3) cong_transitivity 
          l11_44_1_a midpoint_cong not_cong_4312 not_conga_sym) 
    moreover
    have "B Out A M"
      by (simp add: ‹A ≠ B› assms(2) midpoint_out_1) 
    moreover
    have "B Out C C"
      using ‹C ≠ B› out_trivial by blast 
    moreover
    have "C Out M M"
      using ‹M ≠ C› out_trivial by force 
    moreover
    have "C Out B B"
      using ‹C ≠ B› out_trivial by force 
    ultimately
    show ?thesis
      using l11_10 by blast 
  qed
  have "B A C CongA M C A" 
  proof -
    have "M A C CongA M C A"
      by (simp add: ‹A ≠ C› ‹A ≠ M› assms(3) l11_44_1_a) 
    moreover
    have "A Out B M"
      using Out_def ‹A ≠ B› ‹A ≠ M› assms(2) midpoint_bet by auto 
    moreover
    have "A Out C C"
      using ‹A ≠ C› out_trivial by auto 
    moreover
    have "C Out M M"
      by (simp add: ‹M ≠ C› out_trivial) 
    moreover
    have "C Out A A"
      by (simp add: ‹A ≠ C› out_trivial) 
    ultimately
    show ?thesis
      using l11_10 by blast 
  qed
  have "A C M M C B SumA A C B"
    by (meson ‹B A C CongA M C A› ‹M ≠ B› assms(1) assms(2) 
        bet__ts midpoint_bet ncol_conga_ncol not_col_permutation_4 ts__suma) 
  moreover
  have "A C M CongA C A B"
    by (meson ‹B A C CongA M C A› conga_comm conga_sym) 
  moreover
  have "M C B CongA A B C"
    using ‹A B C CongA M C B› not_conga_sym by blast 
  moreover
  have "A C B CongA A C B"
    using ‹A ≠ C› ‹C ≠ B› conga_refl by force 
  ultimately
  show ?thesis
    using conga3_suma__suma by blast 
qed

(** The three following lemmas link Saccheri's three hypotheses
  with triangles ABC having C on the circle of diameter AB;
  the first one states the equivalence between the Right angle hypothesis and Thales' theorem
  *)

lemma t22_17__rah_1:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "Per A C B"
  shows "hypothesis_of_right_saccheri_quadrilaterals" 
proof -
  have "C ≠ B"
    using assms(1) not_col_distincts by blast 
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto 
  have "C A B A B C SumA A C B"
    using assms(1) assms(2) assms(3) cong_mid__suma by blast 
  obtain P Q R where "A C B B C A SumA P Q R"
    using ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
  have "C A B TriSumA P Q R"
    using TriSumA_def ‹A C B B C A SumA P Q R› ‹C A B A B C SumA A C B› by blast 
  moreover
  have "Bet P Q R" 
  proof -
    have "Per A C B"
      by (simp add: assms(4)) 
    moreover
    have "Per B C A"
      using calculation l8_2 by presburger 
    moreover
    have "A C B B C A SumA P Q R"
      using ‹A C B B C A SumA P Q R› by blast 
    ultimately
    show ?thesis
      using per2_suma__bet by blast 
  qed
  ultimately
  show ?thesis
    using assms(1) col_permutation_1 t22_14__rah by blast 
qed

lemma t22_17__rah_2:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "hypothesis_of_right_saccheri_quadrilaterals"
  shows "Per A C B"
proof -
  have "A ≠ B"
    using assms(1) col_trivial_1 by blast 
  have "C ≠ B"
    using assms(1) not_col_distincts by blast 
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto 
  have "A ≠ M"
    using ‹A ≠ B› assms(2) is_midpoint_id by blast
  have "M ≠ B"
    using ‹A ≠ B› assms(2) midpoint_not_midpoint by blast 
  have "M ≠ C"
    using NCol_cases assms(1) assms(2) midpoint_col by blast
  have "C A B A B C SumA A C B"
    using assms(1) assms(2) assms(3) cong_mid__suma by blast 
  obtain P Q R where "A C B B C A SumA P Q R"
    using ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
  have "C A B TriSumA P Q R"
    using TriSumA_def ‹A C B B C A SumA P Q R› ‹C A B A B C SumA A C B› by blast 
  hence "Bet P Q R"
    using assms(4) t22_14__bet by blast 
  moreover
  have "A C B A C B SumA P Q R"
    using ‹A C B B C A SumA P Q R› suma_middle_comm by blast 
  ultimately
  show ?thesis
    by (meson bet_suma__per) 
qed

lemma t22_17__rah:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C"
  shows "Per A C B ⟷ hypothesis_of_right_saccheri_quadrilaterals"
  by (meson t22_17__rah_1 t22_17__rah_2 assms(1) assms(2) assms(3)) 

lemma t22_17__oah_1:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "Obtuse A C B"
  shows "hypothesis_of_obtuse_saccheri_quadrilaterals" 
proof -
  have "C ≠ B"
    using assms(1) not_col_distincts by blast 
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto 
  have "C A B A B C SumA A C B"
    using assms(1) assms(2) assms(3) cong_mid__suma by blast 
  obtain P Q R where "A C B B C A SumA P Q R"
    using ‹A ≠ C› ‹C ≠ B› ex_suma by presburger
  have "C A B A B C SumA B C A"
    by (simp add: ‹C A B A B C SumA A C B› suma_right_comm) 
  moreover
  have "¬ SAMS B C A B C A"
    using assms(4) obtuse__nsams sams_comm by blast 
  ultimately
  show ?thesis
    using t22_14__oah by blast 
qed

lemma t22_17__oah_2:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "hypothesis_of_obtuse_saccheri_quadrilaterals"
  shows "Obtuse A C B" 
proof -
  have "C ≠ B"
    using assms(1) not_col_distincts by blast 
  have "A ≠ C"
    using assms(1) col_trivial_3 by auto 
  have "C A B A B C SumA A C B"
    using assms(1) assms(2) assms(3) cong_mid__suma by blast 
  hence "¬ SAMS B C A B C A"
    by (meson assms(1) assms(4) sams_left_comm t22_14__nsams) 
  hence "Obtuse B C A"
    using ‹A ≠ C› ‹C ≠ B› nsams__obtuse by auto 
  thus ?thesis
    using obtuse_sym by blast 
qed


lemma t22_17__oah:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" 
  shows "Obtuse A C B ⟷ hypothesis_of_obtuse_saccheri_quadrilaterals"
  by (meson t22_17__oah_1 t22_17__oah_2 assms(1) assms(2) assms(3)) 

lemma t22_17__aah_1:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "Acute A C B"
  shows "hypothesis_of_acute_saccheri_quadrilaterals" 
proof -
  {
    assume "Per A C B"
    hence "A C B LtA A C B"
      using acute_not_per assms(4) by auto 
    hence "False"
      by (simp add: nlta)
  }
  moreover
  {
    assume "Obtuse A C B"
    hence "A C B LtA A C B"
      using acute__not_obtuse assms(4) by blast 
    hence "False" 
      by (simp add: nlta)
  }
  ultimately
  show ?thesis
    using assms(1) assms(2) assms(3) saccheri_s_three_hypotheses
      t22_17__oah_2 t22_17__rah by blast 
qed

lemma t22_17__aah_2:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C" and
    "hypothesis_of_acute_saccheri_quadrilaterals"
  shows "Acute A C B " 
proof -
  {
    assume "Per A C B"
    hence "hypothesis_of_right_saccheri_quadrilaterals" 
      using assms(1) assms(2) assms(3) t22_17__rah_1 by blast 
    hence "False"
      using assms(4) not_aah by auto 
  }
  moreover
  {
    assume "Obtuse A C B"
    hence "hypothesis_of_obtuse_saccheri_quadrilaterals"
      using assms(1) assms(2) assms(3) t22_17__oah_1 by blast 
    hence "False"
      using assms(4) not_oah by blast 
  }
  ultimately
  show ?thesis
    by (metis angle_partition assms(1) not_col_distincts) 
qed

lemma t22_17__aah:
  assumes "¬ Col A B C" and
    "M Midpoint A B" and
    "Cong M A M C"
  shows "Acute A C B ⟷ hypothesis_of_acute_saccheri_quadrilaterals"
  by (meson t22_17__aah_1 t22_17__aah_2 assms(1) assms(2) assms(3)) 

lemma t22_20:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "A B C B C A SumA D E F"
  shows "SAMS D E F C A B" 
  using assms(1) assms(2) t22_14__oah by blast 

lemma absolute_exterior_angle_theorem:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Bet B A B'" and
    "A ≠ B'" and
    "A B C B C A SumA D E F"
  shows "D E F LeA C A B'"
proof -
  have "SAMS D E F C A B" 
    using t22_20 by (simp add: assms(1) assms(4)) 
  thus ?thesis
    by (metis assms(2) assms(3) lea_left_comm sams_chara sams_comm 
        sams_distincts sams_sym) 
qed

lemma defect_distincts:
  assumes "Defect A B C D E F"
  shows "A ≠ B ∧ B ≠ C ∧ A ≠ C ∧ D ≠ E ∧ E ≠ F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms by presburger
  thus ?thesis
    by (meson suppa_distincts trisuma_distincts) 
qed

lemma ex_defect:
  assumes "A ≠ B" and
    "B ≠ C" and
    "A ≠ C"
  shows "∃ D E F. Defect A B C D E F" 
proof -
  obtain G H I where "A B C TriSumA G H I"
    using assms(1) assms(2) assms(3) ex_trisuma by presburger
  have "G ≠ H"
    using ‹A B C TriSumA G H I› trisuma_distincts by blast
  have "H ≠ I"
    using ‹A B C TriSumA G H I› trisuma_distincts by presburger 
  obtain D E F where "G H I SuppA D E F"
    using ex_suppa ‹A B C TriSumA G H I› trisuma_distincts by presburger 
  thus ?thesis
    using Defect_def ‹A B C TriSumA G H I› by blast 
qed

lemma conga_defect__defect:
  assumes "Defect A B C D E F" and
    "D E F CongA D' E' F'" 
  shows "Defect A B C D' E' F'" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(1) by blast
  have "G H I CongA G H I" 
  proof -
    have "G ≠ H"
      using ‹A B C TriSumA G H I ∧ G H I SuppA D E F› trisuma_distincts by blast
    moreover
    have "H ≠ I"
      using ‹A B C TriSumA G H I ∧ G H I SuppA D E F› trisuma_distincts by blast 
    ultimately
    show ?thesis
      using conga_pseudo_refl conga_right_comm by presburger 
  qed
  thus ?thesis
    by (meson Defect_def conga2_suppa__suppa assms(2) 
        ‹A B C TriSumA G H I ∧ G H I SuppA D E F›) 
qed

lemma defect2__conga:
  assumes "Defect A B C D E F" and
    "Defect A B C D' E' F'"
  shows "D E F CongA D' E' F'" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(1) by blast
  obtain G' H' I' where "A B C TriSumA G' H' I' ∧ G' H' I' SuppA D' E' F'"
    using Defect_def assms(2) by blast
  have "G H I SuppA D' E' F'"
    by (meson conga2_suppa__suppa ‹A B C TriSumA G H I ∧ G H I SuppA D E F› 
        ‹⋀thesis. (⋀G' H' I'. 
      A B C TriSumA G' H' I' ∧ G' H' I' SuppA D' E' F' ⟹ thesis) ⟹ thesis› 
        suppa2__conga456 trisuma2__conga) 
  thus ?thesis
    using ‹A B C TriSumA G H I ∧ G H I SuppA D E F› suppa2__conga456 by blast 
qed

lemma defect_perm_231:
  assumes "Defect A B C D E F"
  shows "Defect B C A D E F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(1) by blast
  thus ?thesis
    by (meson Defect_def trisuma_perm_231) 
qed

lemma defect_perm_312:
  assumes "Defect A B C D E F"
  shows "Defect C A B D E F"
  by (simp add: assms defect_perm_231) 

lemma defect_perm_321:
  assumes "Defect A B C D E F"
  shows "Defect C B A D E F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(1) by blast
  thus ?thesis
    using Defect_def trisuma_perm_321 by blast 
qed

lemma defect_perm_213:
  assumes "Defect A B C D E F"
  shows "Defect B A C D E F"
  by (meson assms defect_perm_231 defect_perm_321) 

lemma defect_perm_132:
  assumes "Defect A B C D E F"
  shows "Defect A C B D E F"
  by (meson assms defect_perm_312 defect_perm_321) 

lemma conga3_defect__defect:
  assumes "Defect A B C D E F" and
    "A B C CongA A' B' C'" and
    "B C A CongA B' C' A'" and
    "C A B CongA C' A' B'"
  shows "Defect A' B' C' D E F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(1) by blast
  thus ?thesis
    using Defect_def assms(2) assms(3) assms(4) conga3_trisuma__trisuma by blast 
qed

lemma col_defect__out:
  assumes "Col A B C" and
    "Defect A B C D E F"
  shows "E Out D F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(2) by blast
  thus ?thesis
    using assms(1) bet_suppa__out col_trisuma__bet by blast
qed

lemma rah_defect__out:
  assumes "hypothesis_of_right_saccheri_quadrilaterals" and
    "Defect A B C D E F"
  shows "E Out D F" 
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(2) by blast
  thus ?thesis
    using assms(1) bet_suppa__out t22_14__bet by blast
qed

lemma defect_ncol_out__rah:
  assumes "¬ Col A B C" and
    "Defect A B C D E F" and
    "E Out D F"
  shows "hypothesis_of_right_saccheri_quadrilaterals"
proof -
  obtain G H I where "A B C TriSumA G H I ∧ G H I SuppA D E F"
    using Defect_def assms(2) by blast
  thus ?thesis
    by (meson assms(1) assms(3) out_suppa__bet suppa_sym t22_14__rah)
qed


(** The following development is inspired by The Foundations of
  Geometry and the Non-Euclidean Plane, by George E Martin, chapter 22 *)

(** Additivity of the defect : if C1 is between A and C, the defect of ABC is
  the sum of the defects of ABC1 and BC1C.
  In this proof, we have to exclude the semi-elliptical case 
  so that the sums of angles behave. *)

lemma t22_16_1:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Bet A C1 C" and
    "Defect A B C1 D E F" and
    "Defect B C1 C G H I" and
    "D E F G H I SumA K L M"
  shows "SAMS D E F G H I ∧ Defect A B C K L M" 
proof -
  have "A ≠ B"
    using assms(3) defect_distincts by blast 
  have "C1 ≠ B"
    using assms(3) defect_distincts by blast 
  have "A ≠ C1"
    using assms(3) defect_distincts by blast 
  have "D ≠ E"
    using assms(3) defect_distincts by presburger 
  have "F ≠ E"
    using assms(3) defect_distincts by blast 
  have "C1 ≠ C"
    using assms(4) defect_distincts by blast
  have "C ≠ B"
    using assms(4) defect_distincts by blast 
  have "G ≠ H"
    using assms(5) suma_distincts by blast 
  have "I ≠ H"
    using assms(5) suma_distincts by blast 
  have "Defect C1 B A D E F"
    by (simp add: assms(3) defect_perm_321)
  obtain P Q R where "C1 B A TriSumA P Q R ∧ P Q R SuppA D E F"
    using Defect_def ‹Defect C1 B A D E F› by presburger
  have "P Q R D E F SumA A C1 C"
    by (simp add: ‹A ≠ C1› ‹C1 B A TriSumA P Q R ∧ P Q R SuppA D E F›
        ‹C1 ≠ C› assms(2) bet_suppa__suma) 
  obtain S T U where 1: "C1 B A B A C1 SumA S T U ∧ S T U A C1 B SumA P Q R"
    using TriSumA_def ‹C1 B A TriSumA P Q R ∧ P Q R SuppA D E F› 
    by blast
  have "S T U D E F SumA B C1 C ∧ SAMS S T U D E F"
  proof -
    have "B C1 C A C1 B SumA A C1 C"
      by (metis ‹A ≠ C1› ‹C1 ≠ B› ‹C1 ≠ C› assms(2) bet__suma 
          between_symmetry suma_comm) 
    obtain V W X where "A C1 B D E F SumA V W X" 
      using ex_suma ‹D ≠ E› ‹F ≠ E› ‹A ≠ C1› ‹C1 ≠ B› by presburger 
    have "P Q R SuppA D E F" 
      using ‹C1 B A TriSumA P Q R ∧ P Q R SuppA D E F› by blast
    hence "SAMS P Q R D E F"
      by (simp add: suppa__sams)
    have "C1 B A B A C1 SumA S T U" 
      using ‹C1 B A B A C1 SumA S T U ∧ S T U A C1 B SumA P Q R› by blast
    hence "SAMS S T U A C1 B"
      by (simp add: assms(1) t22_20)
    have "SAMS A C1 B D E F" 
    proof -
      have "A C1 B LeA P Q R"
        using ‹C1 B A B A C1 SumA S T U ∧ S T U A C1 B SumA P Q R› 
          ‹SAMS S T U A C1 B› sams_suma__lea456789 by blast 
      moreover
      have "D E F LeA D E F"
        by (simp add: ‹D ≠ E› ‹F ≠ E› lea_refl) 
      ultimately
      show ?thesis
        using sams_lea2__sams ‹SAMS P Q R D E F› by blast 
    qed
    have "S T U V W X SumA A C1 C"
      by (meson ‹A C1 B D E F SumA V W X› 
          ‹C1 B A B A C1 SumA S T U ∧ S T U A C1 B SumA P Q R› 
          ‹P Q R D E F SumA A C1 C› ‹SAMS A C1 B D E F› 
          ‹SAMS S T U A C1 B› suma_assoc_1)
    have "SAMS S T U D E F"
    proof -
      have "S T U LeA P Q R" 
        using sams_suma__lea123789 ‹SAMS S T U A C1 B› 
          ‹C1 B A B A C1 SumA S T U ∧ S T U A C1 B SumA P Q R› 
        by blast 
      moreover
      have "D E F LeA D E F"
        by (simp add: ‹D ≠ E› ‹F ≠ E› lea_refl) 
      ultimately
      show ?thesis
        using sams_lea2__sams ‹SAMS P Q R D E F› by blast 
    qed
    moreover
    have "S T U D E F SumA B C1 C" 
    proof -
      obtain B' C1' C' where "S T U D E F SumA B' C1' C'" 
        using ex_suma calculation sams_distincts by presburger 
      have "B' C1' C' A C1 B SumA A C1 C" 
      proof -
        have "SAMS S T U D E F"
          using calculation by auto 
        moreover
        have "SAMS D E F A C1 B"
          by (simp add: ‹SAMS A C1 B D E F› sams_sym) 
        moreover
        have "D E F A C1 B SumA V W X"
          by (simp add: ‹A C1 B D E F SumA V W X› suma_sym) 
        ultimately
        show ?thesis
          by (meson suma_assoc_2 ‹S T U V W X SumA A C1 C› 
              ‹S T U D E F SumA B' C1' C'›) 
      qed
      have "B' C1' C' CongA B C1 C"
        by (meson ‹B C1 C A C1 B SumA A C1 C› 
            ‹B' C1' C' A C1 B SumA A C1 C› assms(2) 
            bet_suma__sams sams2_suma2__conga123) 
      thus ?thesis 
        by (meson ‹S T U D E F SumA B' C1' C'› calculation 
            conga3_suma__suma sams2_suma2__conga123 sams2_suma2__conga456) 
    qed
    ultimately
    show ?thesis 
      by auto
  qed
  hence "S T U D E F SumA B C1 C" 
    by blast
  have "SAMS S T U D E F"  
    using ‹S T U D E F SumA B C1 C ∧ SAMS S T U D E F› by blast
  have "Defect C1 C B G H I"
    by (simp add: assms(4) defect_perm_231)
  obtain P Q R where "C1 C B TriSumA P Q R ∧ P Q R SuppA G H I"
    using Defect_def ‹Defect C1 C B G H I› by blast
  obtain V W X where "C1 C B C B C1 SumA V W X ∧ V W X B C1 C SumA P Q R" 
    using ‹C1 C B TriSumA P Q R ∧ P Q R SuppA G H I› TriSumA_def by blast
  have "P Q R G H I SumA A C1 C"   
    by (simp add: ‹A ≠ C1› ‹C1 C B TriSumA P Q R ∧ P Q R SuppA G H I› 
        ‹C1 ≠ C› assms(2) bet_suppa__suma)
  hence "SAMS P Q R G H I" 
    by (meson bet_suma__sams assms(2)) 
  have "C1 C B C B C1 SumA V W X"
    by (simp add: ‹C1 C B C B C1 SumA V W X ∧ V W X B C1 C SumA P Q R›) 
  hence "SAMS V W X B C1 C"
    using assms(1) t22_14__oah by blast 
  have "SAMS D E F G H I" 
  proof -
    have "D E F LeA P Q R" 
    proof -
      have "D E F LeA B C1 C" 
        using sams_suma__lea456789 ‹S T U D E F SumA B C1 C› 
          ‹SAMS S T U D E F› by blast 
      moreover
      have "B C1 C LeA P Q R" 
        using sams_suma__lea456789 
          ‹C1 C B C B C1 SumA V W X ∧ V W X B C1 C SumA P Q R› 
          ‹SAMS V W X B C1 C› by blast 
      ultimately
      show ?thesis
        by (meson lea_trans) 
    qed
    moreover
    have "G H I LeA G H I"
      by (simp add: ‹G ≠ H› ‹I ≠ H› lea_refl) 
    ultimately
    show ?thesis
      using sams_lea2__sams ‹SAMS P Q R G H I› by blast 
  qed
  have "V ≠ W"
    using ‹SAMS V W X B C1 C› sams_distincts by blast 
  have "W ≠ X"     
    using ‹SAMS V W X B C1 C› sams_distincts by blast
  have "S ≠ T"
    using ‹SAMS S T U D E F› sams_distincts by blast 
  have "T ≠ U" 
    using ‹SAMS S T U D E F› sams_distincts by blast 
  obtain A' B' C' where "V W X S T U SumA A' B' C'" 
    using ex_suma ‹V ≠ W› ‹W ≠ X› ‹S ≠ T› ‹T ≠ U› by blast
  have "SAMS V W X S T U" 
  proof -
    have "V W X LeA V W X"
      using ‹V ≠ W› ‹W ≠ X› lea_refl by auto 
    moreover
    have "S T U LeA B C1 C" 
      using sams_suma__lea123789 ‹S T U D E F SumA B C1 C› 
        ‹SAMS S T U D E F› by blast 
    ultimately
    show ?thesis
      by (meson sams_lea2__sams ‹SAMS V W X B C1 C›) 
  qed
  have "A' B' C' D E F SumA P Q R" 
  proof -
    have "SAMS V W X S T U"
      by (simp add: ‹SAMS V W X S T U›) 
    moreover
    have "SAMS S T U D E F"
      using ‹SAMS S T U D E F› by auto 
    moreover
    have "V W X S T U SumA A' B' C'"
      by (simp add: ‹V W X S T U SumA A' B' C'›) 
    moreover
    have "S T U D E F SumA B C1 C"
      by (simp add: ‹S T U D E F SumA B C1 C›) 
    moreover
    have "V W X B C1 C SumA P Q R"
      by (simp add: ‹C1 C B C B C1 SumA V W X ∧ V W X B C1 C SumA P Q R›) 
    ultimately
    show ?thesis
      using suma_assoc by blast 
  qed
  have "SAMS A' B' C' D E F" 
    using sams_assoc ‹SAMS V W X S T U› ‹SAMS S T U D E F› 
      ‹V W X S T U SumA A' B' C'› ‹S T U D E F SumA B C1 C› 
      ‹SAMS V W X B C1 C› by blast 
  hence "A' B' C' K L M SumA A C1 C" 
    using suma_assoc assms(5) ‹SAMS D E F G H I› 
      ‹A' B' C' D E F SumA P Q R› ‹P Q R G H I SumA A C1 C› by blast 
  hence "A' B' C' SuppA K L M" 
    using bet_suma__suppa assms(2) by blast 
  moreover
  have "A B C TriSumA A' B' C'" 
  proof -
    have "X ≠ W"
      using ‹W ≠ X› by blast 
    then obtain D E F where "V W X C1 B A SumA D E F" 
      using ex_suma ‹V ≠ W› ‹C1 ≠ B› ‹A ≠ B› by presburger
    have "SAMS V W X C1 B A" 
    proof -
      have "V W X LeA V W X"
        by (simp add: ‹V ≠ W› ‹X ≠ W› lea_refl) 
      moreover
      have "C1 B A LeA S T U" 
      proof -
        have "C1 B A B A C1 SumA S T U"
          using 1 by blast
        moreover
        have "SAMS C1 B A B A C1"
          using ‹A ≠ B› ‹A ≠ C1› ‹C1 ≠ B› sams123231 by auto 
        ultimately
        show ?thesis
          using sams_suma__lea123789 by blast 
      qed
      ultimately
      show ?thesis
        using sams_lea2__sams ‹SAMS V W X S T U› by blast 
    qed
    have "A C B TriSumA A' B' C'" 
    proof -
      have "A C B C B A SumA D E F" 
      proof -
        have "C1 C B CongA A C B" 
        proof -
          have "C Out A C1"
            by (simp add: ‹C1 ≠ C› assms(2) bet_out_1 l6_6) 
          moreover
          have "C Out B B "
            using ‹C ≠ B› out_trivial by auto
          ultimately
          show ?thesis
            using out2__conga by blast 
        qed
        have "C1 C B C B A SumA D E F" 
        proof -
          have "SAMS C1 C B C B C1"
            by (simp add: ‹C ≠ B› ‹C1 ≠ B› ‹C1 ≠ C› sams123231) 
          moreover
          have "C1 InAngle C B A"
            by (meson Bet_cases InAngle_def ‹A ≠ B› ‹C ≠ B› 
                ‹C1 ≠ B› assms(2) out_trivial)
          hence "SAMS C B C1 C1 B A"
            by (simp add: inangle__sams)
          moreover
          have "C B C1 C1 B A SumA C B A"
            by (simp add: ‹C1 InAngle C B A› inangle__suma) 
          ultimately
          show ?thesis
            by (meson suma_assoc_1 ‹V W X C1 B A SumA D E F› 
                ‹C1 C B C B C1 SumA V W X›) 
        qed
        moreover
        have "C B A CongA C B A"
          by (simp add: ‹A ≠ B› ‹C ≠ B› conga_refl) 
        moreover
        have "D ≠ E"
          using ‹V W X C1 B A SumA D E F› suma_distincts by presburger
        have "E ≠ F"
          using ‹V W X C1 B A SumA D E F› suma_distincts by presburger
        have "D E F CongA D E F" 
          using ‹D ≠ E› ‹E ≠ F› lea_asym lea_refl by auto 
        ultimately
        show ?thesis
          by (meson conga3_suma__suma ‹C1 C B CongA A C B›) 
      qed
      moreover
      have "D E F B A C SumA A' B' C'" 
      proof -
        have "B A C CongA B A C1" 
        proof -
          have "A Out B B"
            using ‹A ≠ B› bet_out_1 between_trivial2 by auto 
          moreover
          have "A Out C1 C"
            using ‹A ≠ C1› assms(2) bet_out by auto 
          ultimately
          show ?thesis
            by (simp add: out2__conga Tarski_neutral_dimensionless_axioms) 
        qed
        have "D E F B A C1 SumA A' B' C'" 
        proof -
          have "SAMS C1 B A B A C1"
            using ‹A ≠ B› ‹A ≠ C1› ‹C1 ≠ B› sams123231 by auto 
          moreover
          have "C1 B A B A C1 SumA S T U" 
            using 1 by auto
          ultimately
          show ?thesis
            by (meson suma_assoc_2 ‹V W X C1 B A SumA D E F› 
                ‹SAMS V W X C1 B A› ‹V W X S T U SumA A' B' C'›) 
        qed
        moreover
        have "D ≠ E"
          using ‹A C B C B A SumA D E F› suma_distincts by presburger 
        have "E ≠ F"
          using ‹A C B C B A SumA D E F› suma_distincts by presburger 
        have "D E F CongA D E F" 
          using ‹D ≠ E› ‹E ≠ F› lea_asym lea_refl by auto 
        moreover
        have "B A C1 CongA B A C"
          by (simp add: ‹B A C CongA B A C1› conga_sym_equiv) 
        moreover
        have "A' ≠ B'"
          using ‹A' B' C' SuppA K L M› suppa_distincts by blast
        have "B' ≠ C'"
          using ‹A' B' C' SuppA K L M› suppa_distincts by blast
        have "A' B' C' CongA A' B' C'"
          using ‹A' ≠ B'› ‹B' ≠ C'› conga_refl by auto 
        ultimately
        show ?thesis
          by (meson conga3_suma__suma) 
      qed
      ultimately
      show ?thesis
        using TriSumA_def by blast 
    qed
    thus ?thesis
      by (simp add: trisuma_perm_132) 
  qed
  ultimately
  show ?thesis
    using Defect_def ‹SAMS D E F G H I› by blast 
qed

lemma t22_16_1bis:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Bet A C1 C" and
    "Defect A B C1 D E F" and
    "Defect B C1 C G H I" and
    "Defect A B C K L M" 
  shows "SAMS D E F G H I ∧ D E F G H I SumA K L M" 
proof -
  have "D ≠ E"
    using assms(3) defect_distincts by presburger 
  have "E ≠ F"
    using assms(3) defect_distincts by blast 
  have "C1 ≠ C"
    using assms(4) defect_distincts by blast
  have "C ≠ B"
    using assms(4) defect_distincts by blast 
  have "G ≠ H"
    using assms(4) defect_distincts by blast
  have "H ≠ I"
    using assms(4) defect_distincts by blast
  obtain K' L' M' where "D E F G H I SumA K' L' M'" 
    using ex_suma ‹D ≠ E› ‹E ≠ F› ‹G ≠ H› ‹H ≠ I› by presburger 
  hence "SAMS D E F G H I ∧ Defect A B C K' L' M'"
    using assms(1) assms(2) assms(3) assms(4) t22_16_1 by blast
  hence "SAMS D E F G H I" 
    by auto
  moreover
  have "D E F G H I SumA K L M" 
  proof -
    have "D E F CongA D E F"
      using ‹D ≠ E› ‹E ≠ F› conga_refl by auto 
    moreover
    have "G H I CongA G H I"
      using ‹G ≠ H› ‹H ≠ I› conga_refl by auto 
    moreover
    have "K' L' M' CongA K L M" 
      by (meson defect2__conga assms(5) ‹SAMS D E F G H I ∧ Defect A B C K' L' M'›) 
    ultimately
    show ?thesis
      by (meson conga3_suma__suma ‹D E F G H I SumA K' L' M'›) 
  qed
  ultimately
  show ?thesis 
    by auto
qed

lemma t22_16_2aux:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Defect A B C D1 D2 D3" and
    "Defect A B D C1 C2 C3" and
    "Defect A D C B1 B2 B3" and
    "Defect C B D A1 A2 A3" and
    "Bet A PO C" and
    "Bet B PO D" and
    "Col A B C" and
    "D1 D2 D3 B1 B2 B3 SumA P Q R"
  shows "SAMS C1 C2 C3 A1 A2 A3 ∧ C1 C2 C3 A1 A2 A3 SumA P Q R" 
proof -
  have "B ≠ D"
    using assms(3) defect_distincts by auto 
  have "C1 ≠ C2"
    using assms(3) defect_distincts by blast
  have "C2 ≠ C3"
    using assms(3) defect_distincts by auto 
  have "A1 ≠ A2"
    using assms(5) defect_distincts by blast 
  have "A2 ≠ A3"
    using assms(5) defect_distincts by blast 
  have "A ≠ C"
    using assms(2) defect_distincts by blast 
  have "P ≠ Q"
    using assms(9) suma_distincts by blast 
  have "Q ≠ R"
    using assms(9) suma_distincts by blast 
  have "D2 Out D1 D3" 
    using assms(2) assms(8) col_defect__out by blast 
  thus ?thesis 
  proof (cases "Col A D C")
    case True
    have "Col C B D"
      by (metis True ‹A ≠ C› assms(8) col_permutation_4 
          col_permutation_5 col_transitivity_1) 
    hence "A2 Out A1 A3" 
      using assms(5) col_defect__out by blast 
    have "Col A B D"
      by (meson True ‹A ≠ C› assms(8) col_permutation_5 col_transitivity_1)
    hence "B2 Out B1 B3"
      using True assms(4) col_defect__out by blast 
    have "C2 Out C1 C3"
      using assms(3) by (meson True ‹A ≠ C› assms(8) 
          col_defect__out col_permutation_5 col_transitivity_1) 
    have "SAMS C1 C2 C3 A1 A2 A3"
      by (simp add: ‹A2 Out A1 A3› ‹C1 ≠ C2› ‹C2 ≠ C3› out546__sams)
    moreover
    have "C1 C2 C3 A1 A2 A3 SumA P Q R" 
    proof -
      have "D1 D2 D3 CongA C1 C2 C3"
        by (simp add: ‹C2 Out C1 C3› ‹D2 Out D1 D3› l11_21_b) 
      moreover
      have "B1 B2 B3 CongA A1 A2 A3"
        by (simp add: ‹A2 Out A1 A3› ‹B2 Out B1 B3› l11_21_b) 
      moreover
      have "P Q R CongA P Q R"
        using ‹P ≠ Q› ‹Q ≠ R› conga_refl by auto 
      ultimately
      show ?thesis
        by (meson conga3_suma__suma assms(9)) 
    qed
    ultimately
    show ?thesis
      by auto
  next
    case False
    have "B = PO" 
    proof -
      have "¬ Col A C D"
        using False col_permutation_5 by blast 
      moreover
      have "D ≠ B"
        using ‹B ≠ D› by auto 
      moreover
      have "Col A C B"
        by (simp add: assms(8) col_permutation_5) 
      moreover
      have "Col A C PO"
        using Col_perm assms(6) bet_col by blast 
      moreover
      have "Col D B B"
        by (simp add: col_trivial_2) 
      moreover
      have "Col D B PO"
        using Col_def assms(7) by auto 
      ultimately
      show ?thesis
        using l6_21 by blast 
    qed
    have "B1 B2 B3 CongA P Q R"
      using assms(9) out213_suma__conga ‹D2 Out D1 D3› by blast
    have "SAMS C1 C2 C3 A1 A2 A3 ∧ C1 C2 C3 A1 A2 A3 SumA B1 B2 B3" 
    proof -
      have "Defect A D B C1 C2 C3"
        using assms(3) defect_perm_132 by blast 
      moreover
      have "Defect D B C A1 A2 A3"
        using assms(5) defect_perm_321 by blast 
      ultimately
      show ?thesis
        using ‹B = PO› assms(1) assms(4) assms(6) t22_16_1bis by blast 
    qed
    hence "SAMS C1 C2 C3 A1 A2 A3" 
      by blast
    moreover
    have "C1 C2 C3 A1 A2 A3 SumA P Q R" 
    proof -
      have "C1 C2 C3 A1 A2 A3 SumA B1 B2 B3" 
        using ‹SAMS C1 C2 C3 A1 A2 A3 ∧ C1 C2 C3 A1 A2 A3 SumA B1 B2 B3› 
        by blast
      moreover
      have "C1 C2 C3 CongA C1 C2 C3"
        using ‹C1 ≠ C2› ‹C2 ≠ C3› conga_refl by auto 
      moreover
      have "A1 A2 A3 CongA A1 A2 A3"
        using ‹A1 ≠ A2› ‹A2 ≠ A3› conga_refl by auto 
      moreover
      have "B1 B2 B3 CongA P Q R"
        using ‹D2 Out D1 D3› assms(9) out213_suma__conga by auto 
      ultimately
      show ?thesis
        by (meson conga3_suma__suma) 
    qed
    ultimately
    show ?thesis 
      by auto
  qed
qed

lemma t22_16_2aux1:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Defect A B C D1 D2 D3" and
    "Defect A B D C1 C2 C3" and
    "Defect A D C B1 B2 B3" and
    "Defect C B D A1 A2 A3" and
    "Bet A PO C" and
    "Bet B PO D" and
    "Col A B D" and
    "D1 D2 D3 B1 B2 B3 SumA P Q R"
  shows "SAMS C1 C2 C3 A1 A2 A3 ∧ C1 C2 C3 A1 A2 A3 SumA P Q R" 
proof -
  have "B ≠ D"
    using assms(3) defect_distincts by auto 
  have "C1 ≠ C2"
    using assms(3) defect_distincts by blast
  have "C2 ≠ C3"
    using assms(3) defect_distincts by auto 
  have "A1 ≠ A2"
    using assms(5) defect_distincts by blast 
  have "A2 ≠ A3"
    using assms(5) defect_distincts by blast 
  have "A ≠ C"
    using assms(2) defect_distincts by blast 
  have "P ≠ Q"
    using assms(9) suma_distincts by blast 
  have "Q ≠ R"
    using assms(9) suma_distincts by blast
  have "C2 Out C1 C3" 
    using col_defect__out assms(3) assms(8) by blast 
  have "SAMS C1 C2 C3 A1 A2 A3"
    by (simp add: ‹A1 ≠ A2› ‹A2 ≠ A3› ‹C2 Out C1 C3› out213__sams) 
  moreover
  have "C1 C2 C3 A1 A2 A3 SumA P Q R" 
  proof -
    have "C1 C2 C3 A1 A2 A3 SumA A1 A2 A3" 
      using ‹A1 ≠ A2› ‹A2 ≠ A3› ‹C2 Out C1 C3› by (simp add: out213__suma)
    have "D1 D2 D3 B1 B2 B3 SumA A1 A2 A3" 
    proof -
      have "Defect B A D C1 C2 C3"
        by (simp add: assms(3) defect_perm_213) 
      moreover
      have "Defect B A C D1 D2 D3"
        using assms(2) defect_perm_213 by blast 
      moreover
      have "Defect B C D A1 A2 A3"
        by (simp add: assms(5) defect_perm_213) 
      moreover
      have "Defect D A C B1 B2 B3"
        using assms(4) defect_perm_213 by blast 
      moreover
      have "Col B A D"
        using Col_perm assms(8) by blast 
      ultimately
      show ?thesis
        using assms(1) t22_16_2aux assms(6) assms(7) 
          ‹C1 C2 C3 A1 A2 A3 SumA A1 A2 A3› by blast 
    qed
    hence "A1 A2 A3 CongA P Q R"
      by (meson assms(9) suma2__conga) 
    thus ?thesis
      by (meson ‹C1 C2 C3 A1 A2 A3 SumA A1 A2 A3› calculation 
          conga3_suma__suma sams2_suma2__conga123 suma2__conga) 
  qed
  ultimately
  show ?thesis
    by blast 
qed

(** In a convex quadrilateral ABCD, the sum of the defects of ABC and ADC is equal to
  the sum of the defects of ABD and CBD. We add some hypotheses to make the proof easier *)
lemma t22_16_2:
  assumes "¬ hypothesis_of_obtuse_saccheri_quadrilaterals" and
    "Defect A B C D1 D2 D3" and
    "Defect A B D C1 C2 C3" and
    "Defect A D C B1 B2 B3" and
    "Defect C B D A1 A2 A3" and
    "Bet A PO C" and
    "Bet B PO D" and
    "SAMS D1 D2 D3 B1 B2 B3" and
    "D1 D2 D3 B1 B2 B3 SumA P Q R"
  shows "SAMS C1 C2 C3 A1 A2 A3 ∧ C1 C2 C3 A1 A2 A3 SumA P Q R" 
proof -
  have "A ≠ B"
    using assms(3) defect_distincts by blast 
  have "B ≠ D"
    using assms(3) defect_distincts by auto 
  have "A ≠ D"
    using assms(3) defect_distincts by blast 
  have "C1 ≠ C2"
    using assms(3) defect_distincts by blast
  have "C2 ≠ C3"
    using assms(3) defect_distincts by auto 
  have "C ≠ B"
    using assms(2) defect_distincts by blast 
  have "C ≠ D"
    using assms(4) defect_distincts by blast 
  have "A1 ≠ A2"
    using assms(5) defect_distincts by blast 
  have "A2 ≠ A3"
    using assms(5) defect_distincts by blast 
  have "A ≠ C"
    using assms(2) defect_distincts by blast 
  have "D1 ≠ D2"
    using assms(8) sams_distincts by presburger 
  have "D2 ≠ D3"
    using assms(8) sams_distincts by auto 
  have "P ≠ Q"
    using assms(9) suma_distincts by blast 
  have "Q ≠ R"
    using assms(9) suma_distincts by blast
  thus ?thesis
  proof (cases "Col A B C")
    case True
    thus ?thesis
      using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
        assms(7) assms(9) t22_16_2aux by blast 
  next
    case False
    show ?thesis 
    proof (cases "Col A D C")
      case True
      have "Bet D PO B"
        by (simp add: assms(7) between_symmetry) 
      moreover
      have "Col A D C"
        by (simp add: True) 
      moreover
      have "B1 B2 B3 D1 D2 D3 SumA P Q R"
        by (simp add: assms(9) suma_sym) 
      ultimately
      show ?thesis     
        using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
          assms(7) assms(9) t22_16_2aux
        by (meson defect_perm_132) 
    next
      case False
      thus ?thesis 
      proof (cases "Col A B D")
        case True
        thus ?thesis
          using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
            assms(7) assms(9) t22_16_2aux1 by blast  
      next
        case False
        thus ?thesis 
        proof (cases "Col C B D")
          case True
          thus ?thesis 
            using assms(1) assms(2) assms(3) assms(4) assms(5) assms(6) 
              assms(7) assms(9) t22_16_2aux1 
            by (meson between_symmetry defect_perm_321 sams_sym suma_sym) 
        next
          case False
          have "Col B PO D"
            by (simp add: assms(7) bet_col) 
          have "Col A PO C"
            by (simp add: Col_def assms(6)) 
          {
            assume "PO = A"
            hence "Bet B A D"
              using assms(7) by blast 
            hence "False" 
              using ‹¬ Col A B D› Bet_cases Col_def by blast 
          }
          hence "PO ≠ A" 
            by auto
          {
            assume "PO = B"
            hence "Bet A B C"
              using assms(6) by blast 
            hence "False"
              using ‹¬ Col A B C› bet_col by blast 
          }
          hence "PO ≠ B" 
            by auto
          {
            assume "PO = C"
            hence "False"
              using False ‹Col B PO D› col_permutation_4 by blast
          }
          hence "PO ≠ C" 
            by auto
          {
            assume "PO = D"
            hence "Bet A D C"
              using assms(6) by auto 
            hence "False" 
              using ‹¬ Col A D C› bet_col by blast 
          }
          hence "PO ≠ D" 
            by auto
          obtain S1 T1 U1 where "Defect A B PO S1 T1 U1"
            using ‹A ≠ B› ‹PO ≠ A› ‹PO ≠ B› ex_defect by presburger 
          obtain S2 T2 U2 where "Defect B C PO S2 T2 U2"
            using ‹C ≠ B› ‹PO ≠ B› ‹PO ≠ C› ex_defect by presburger 
          obtain S3 T3 U3 where "Defect C D PO S3 T3 U3"
            using ‹C ≠ D› ‹PO ≠ C› ‹PO ≠ D› ex_defect by presburger 
          obtain S4 T4 U4 where "Defect A D PO S4 T4 U4"
            using ‹A ≠ D› ‹PO = A ⟹ False› 
              ‹PO = D ⟹ False› ex_defect by presburger 
          have "Defect B PO C S2 T2 U2"
            by (simp add: ‹Defect B C PO S2 T2 U2› defect_perm_132) 
          hence "SAMS S1 T1 U1 S2 T2 U2 ∧ S1 T1 U1 S2 T2 U2 SumA D1 D2 D3" 
            using assms(1) assms(2) assms(6) 
              ‹Defect A B PO S1 T1 U1› t22_16_1bis by blast 
          have "SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3"
            using assms(1) assms(6) t22_16_1bis 
            by (meson ‹Defect A D PO S4 T4 U4› ‹Defect C D PO S3 T3 U3› 
                assms(4) defect_perm_231) 
          have "SAMS S1 T1 U1 S4 T4 U4 ∧ S1 T1 U1 S4 T4 U4 SumA C1 C2 C3"           
            using assms(1) t22_16_1bis 
            by (meson ‹Defect A B PO S1 T1 U1› ‹Defect A D PO S4 T4 U4› 
                assms(3) assms(7) defect_perm_132 defect_perm_213) 
          have "SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3"
            using assms(1) t22_16_1bis 
            by (meson ‹Defect B C PO S2 T2 U2› ‹Defect C D PO S3 T3 U3› 
                assms(5) assms(7) defect_perm_132 defect_perm_213)
          have "S3 ≠ T3"
            using ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3› 
              sams_distincts by blast 
          have "T3 ≠ U3" 
            using ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3›
              sams_distincts by blast 
          obtain V W X where "D1 D2 D3 S3 T3 U3 SumA V W X" 
            using ex_suma ‹D1 ≠ D2›‹D2 ≠ D3›‹S3 ≠ T3› ‹T3 ≠ U3› by blast
          have "SAMS D1 D2 D3 S3 T3 U3" 
          proof -
            have "SAMS D1 D2 D3 B1 B2 B3"
              by (simp add: assms(8)) 
            moreover
            have"D1 D2 D3 LeA D1 D2 D3"
              using ‹D1 ≠ D2› ‹D2 ≠ D3› lta__lea nlea__lta by blast 
            moreover
            have "S3 T3 U3 LeA B1 B2 B3" 
            proof -
              have"S4 T4 U4 S3 T3 U3 SumA B1 B2 B3"
                using ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                by linarith 
              moreover
              have "SAMS S4 T4 U4 S3 T3 U3"
                using ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                by auto 
              ultimately
              show ?thesis
                using sams_suma__lea456789 by blast 
            qed
            ultimately
            show ?thesis
              using sams_lea2__sams by blast 
          qed
          have  "V W X S4 T4 U4 SumA P Q R" 
          proof -
            have "SAMS S3 T3 U3 S4 T4 U4"
              by (simp add: ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                  sams_sym) 
            moreover
            have "S3 T3 U3 S4 T4 U4 SumA B1 B2 B3"
              by (simp add: ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                  suma_sym) 
            ultimately
            show ?thesis
              using assms(9) ‹SAMS D1 D2 D3 S3 T3 U3› 
                ‹D1 D2 D3 S3 T3 U3 SumA V W X› suma_assoc_2 by blast
          qed
          have "SAMS V W X S4 T4 U4" 
          proof -
            have "SAMS S3 T3 U3 S4 T4 U4" 
              by (simp add: ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                  sams_sym) 
            moreover
            have "S3 T3 U3 S4 T4 U4 SumA B1 B2 B3"
              by (simp add: ‹SAMS S4 T4 U4 S3 T3 U3 ∧ S4 T4 U4 S3 T3 U3 SumA B1 B2 B3› 
                  suma_sym) 
            ultimately
            show ?thesis
              using  assms(8) ‹SAMS D1 D2 D3 S3 T3 U3› ‹D1 D2 D3 S3 T3 U3 SumA V W X› 
                sams_assoc by blast 
          qed
          have "A1 A2 A3 S1 T1 U1 SumA V W X" 
          proof -
            have "SAMS S3 T3 U3 S2 T2 U2"
              by (simp add: ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3› 
                  sams_sym) 
            moreover
            have "SAMS S2 T2 U2 S1 T1 U1" 
              using ‹SAMS S1 T1 U1 S2 T2 U2 ∧ S1 T1 U1 S2 T2 U2 SumA D1 D2 D3› 
                sams_sym by blast 
            moreover
            have "S3 T3 U3 S2 T2 U2 SumA A1 A2 A3"
              by (simp add: ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3› 
                  suma_sym) 
            moreover
            have "S2 T2 U2 S1 T1 U1 SumA D1 D2 D3"
              by (simp add: ‹SAMS S1 T1 U1 S2 T2 U2 ∧ S1 T1 U1 S2 T2 U2 SumA D1 D2 D3› 
                  suma_sym) 
            moreover
            have "S3 T3 U3 D1 D2 D3 SumA V W X"
              by (simp add: ‹D1 D2 D3 S3 T3 U3 SumA V W X› suma_sym) 
            ultimately
            show ?thesis
              by (meson suma_assoc_2) 
          qed
          have "SAMS A1 A2 A3 S1 T1 U1" 
          proof -
            have "SAMS S3 T3 U3 S2 T2 U2" 
              by (simp add: ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3› 
                  sams_sym) 
            moreover
            have "SAMS S2 T2 U2 S1 T1 U1"       
              using ‹SAMS S1 T1 U1 S2 T2 U2 ∧ S1 T1 U1 S2 T2 U2 SumA D1 D2 D3› 
                sams_sym by blast 
            moreover
            have "S3 T3 U3 S2 T2 U2 SumA A1 A2 A3"   
              by (simp add: ‹SAMS S2 T2 U2 S3 T3 U3 ∧ S2 T2 U2 S3 T3 U3 SumA A1 A2 A3› 
                  suma_sym) 
            moreover
            have "S2 T2 U2 S1 T1 U1 SumA D1 D2 D3"
              by (simp add: ‹SAMS S1 T1 U1 S2 T2 U2 ∧ S1 T1 U1 S2 T2 U2 SumA D1 D2 D3› 
                  suma_sym) 
            moreover
            have "SAMS S3 T3 U3 D1 D2 D3"
              by (simp add: ‹SAMS D1 D2 D3 S3 T3 U3› sams_sym) 
            ultimately
            show ?thesis
              using sams_assoc_2 by blast 
          qed
          have "SAMS C1 C2 C3 A1 A2 A3"
          proof -
            have "SAMS S4 T4 U4 S1 T1 U1" 
              using ‹SAMS S1 T1 U1 S4 T4 U4 ∧ S1 T1 U1 S4 T4 U4 SumA C1 C2 C3› 
              by (simp add: sams_sym) 
            moreover
            have "SAMS S1 T1 U1 A1 A2 A3"
              by (simp add: ‹SAMS A1 A2 A3 S1 T1 U1› sams_sym) 
            moreover
            have "S4 T4 U4 S1 T1 U1 SumA C1 C2 C3"
              by (simp add: ‹SAMS S1 T1 U1 S4 T4 U4 ∧ S1 T1 U1 S4 T4 U4 SumA C1 C2 C3› 
                  suma_sym) 
            moreover
            have "S1 T1 U1 A1 A2 A3 SumA V W X"
              by (simp add: ‹A1 A2 A3 S1 T1 U1 SumA V W X› suma_sym) 
            moreover
            have "SAMS S4 T4 U4 V W X"
              by (simp add: ‹SAMS V W X S4 T4 U4› sams_sym) 
            ultimately
            show ?thesis
              by (meson sams_assoc_2) 
          qed
          moreover
          have "C1 C2 C3 A1 A2 A3 SumA P Q R"
          proof -
            have "SAMS S4 T4 U4 S1 T1 U1" 
              using ‹SAMS S1 T1 U1 S4 T4 U4 ∧ S1 T1 U1 S4 T4 U4 SumA C1 C2 C3› 
              by (simp add: sams_sym) 
            moreover
            have "SAMS S1 T1 U1 A1 A2 A3"
              by (simp add: ‹SAMS A1 A2 A3 S1 T1 U1› sams_sym) 
            moreover
            have "S4 T4 U4 S1 T1 U1 SumA C1 C2 C3"       
              by (simp add: ‹SAMS S1 T1 U1 S4 T4 U4 ∧ S1 T1 U1 S4 T4 U4 SumA C1 C2 C3›
                  suma_sym) 
            moreover
            have "S1 T1 U1 A1 A2 A3 SumA V W X"     
              by (simp add: ‹A1 A2 A3 S1 T1 U1 SumA V W X› suma_sym) 
            moreover
            have "S4 T4 U4 V W X SumA P Q R"
              by (simp add: ‹V W X S4 T4 U4 SumA P Q R› suma_sym) 
            ultimately
            show ?thesis
              using suma_assoc by blast 
          qed
          ultimately
          show ?thesis 
            by auto
        qed
      qed
    qed
  qed
qed

lemma isosceles_sym :
  assumes "A B C isosceles"
  shows "C B A isosceles" 
  using assms isosceles_def not_cong_4321 by blast

lemma isosceles_conga:
  assumes "A ≠ C" and
    "A ≠ B" and
    "A B C isosceles"
  shows "C A B CongA A C B" 
  by (meson assms(1) assms(2) assms(3) conga_comm isosceles_def 
      l11_44_1_a not_cong_2134)

lemma conga_isosceles:
  assumes "¬ Col A B C" and
    "C A B CongA A C B" 
  shows "A B C isosceles" 
  by (meson assms(1) assms(2) cong_left_commutativity conga_comm 
      isosceles_def l11_44_1_b)

(** In a triangle isosceles in A the altitude wrt. A, is also the bisector and median. *)

lemma isosceles_foot__midpoint_conga:
  assumes "A B C isosceles" and
    "Col H A C" and
    "H B Perp A C"
  shows "¬ Col A B C ∧ A ≠ H ∧ C ≠ H ∧ H Midpoint A C ∧ H B A CongA H B C" 
proof -
  {
    assume "Col A B C"
    hence "¬ H B Perp A C" 
      by (metis NCol_perm Perp_cases assms(2) l8_16_1)
    hence False 
      by (simp add: assms(3))
  }
  moreover
  {
    assume "A = H" 
    have "A B Lt B C ∧ A C Lt B C" 
      by (metis Col_def Out_cases Perp_perm l11_46  ‹A = H› 
          acute_col_perp__out angle_partition assms(3) bet_neq12__neq 
          calculation col_trivial_3 not_bet_and_out)
    hence False 
      using assms(1) cong__nlt isosceles_def by blast
  }
  moreover
  have " C ≠ H" 
    by (metis l11_46 assms(1) assms(3) calculation(1) cong__nlt 
        isosceles_def not_col_distincts not_cong_4321 perp_per_1)
  moreover
  have "H PerpAt A C B H" 
    using Perp_perm assms(2) assms(3) col_permutation_1 l8_15_1 by blast
  hence "Per A H B" 
    using perp_in_per_1 by force
  hence "Per C H B" 
    using assms(2) calculation(2) l8_3 by blast
  have "H Midpoint A C" 
    by (metis ‹Per A H B› ‹Per C H B› assms(1) assms(2) assms(3) 
        cong2_per2__cong cong_left_commutativity cong_reflexivity 
        isosceles_def l7_20_bis not_col_permutation_4 not_cong_2143 perp_distinct)
  moreover
  have "H B A CongA H B C" 
    by (meson Perp_cases assms(1) assms(3) cong_perp_conga 
        conga_comm isosceles_def not_cong_3421 not_conga_sym)
  ultimately
  show ?thesis 
    by blast
qed

lemma equilateral_strict_equilateral:
  assumes "A B C equilateralStrict"
  shows "A B C equilateral" 
  using assms equilateralStrict_def by blast

lemma equilateral_cong:
  assumes "A B C equilateral"
  shows "Cong A B B C ∧ Cong B C C A ∧ Cong C A A B" 
  by (meson assms cong_transitivity equilateral_def not_cong_3412)

lemma equilateral_rot:
  assumes "A B C equilateral"
  shows "B C A equilateral" 
  using assms equilateral_cong equilateral_def by blast

lemma equilateral_swap:
  assumes "A B C equilateral"
  shows "B A C equilateral" 
  by (meson assms cong_4321 equilateral_def equilateral_rot)

lemma equilateral_rot_2:
  assumes "A B C equilateral"
  shows "C B A equilateral" 
  using assms equilateral_rot equilateral_swap by blast

lemma equilateral_swap_2:
  assumes "A B C equilateral"
  shows "A C B equilateral" 
  using assms equilateral_rot equilateral_rot_2 by blast

lemma equilateral_swap_rot:
  assumes "A B C equilateral"
  shows "C A B equilateral" 
  by (simp add: assms equilateral_rot)

lemma equilateral_isosceles_1:
  assumes "A B C equilateral"
  shows "A B C isosceles" 
  using assms equilateral_cong isosceles_def by blast

lemma equilateral_isosceles_2:
  assumes "A B C equilateral"
  shows "B C A isosceles" 
  using assms equilateral_cong isosceles_def by blast

lemma equilateral_isosceles_3:
  assumes "A B C equilateral"
  shows "C A B isosceles" 
  using assms equilateral_cong isosceles_def by blast

lemma equilateral_strict_neq:
  assumes "A B C equilateralStrict" 
  shows "A ≠ B ∧ B ≠ C ∧ A ≠ C" 
  by (metis assms bet_cong_eq between_trivial2 equilateralStrict_def equilateral_cong)

lemma equilateral_strict_swap_1:
  assumes "A B C equilateralStrict"
  shows "A C B equilateralStrict" 
  by (metis assms equilateralStrict_def equilateral_strict_neq equilateral_swap_2)

lemma equilateral_strict_swap_2:
  assumes "A B C equilateralStrict"
  shows "B A C equilateralStrict" 
  by (metis assms equilateralStrict_def equilateral_swap)

lemma equilateral_strict_swap_3:
  assumes "A B C equilateralStrict"
  shows "B C A equilateralStrict" 
  using assms equilateral_strict_swap_1 equilateral_strict_swap_2 by blast

lemma equilateral_strict_swap_4:
  assumes "A B C equilateralStrict"
  shows "C A B equilateralStrict" 
  by (simp add: assms equilateral_strict_swap_3)

lemma equilateral_strict_swap_5:
  assumes "A B C equilateralStrict"
  shows "C B A equilateralStrict" 
  using assms equilateral_strict_swap_1 equilateral_strict_swap_4 by blast

lemma equilateral_strict__not_col: 
  assumes "A B C equilateralStrict"
  shows "¬ Col A B C" 
proof -
  have "A ≠ B" 
    using assms equilateral_strict_neq by blast
  have "A ≠ C" 
    using assms equilateral_strict_neq by blast
  have "C ≠ B" 
    using assms equilateral_strict_neq by blast
  have "Cong B A B C" 
    using assms cong_left_commutativity equilateral_cong 
      equilateral_strict_equilateral by blast
  have "Cong C A C B" 
    using assms cong_3421 equilateral_cong equilateral_strict_equilateral 
    by blast
  {
    assume "Col A B C"
    have "B Midpoint A C" 
      using l7_20_bis by (simp add: ‹A ≠ C› ‹Col A B C› ‹Cong B A B C›)
    moreover
    have "C Midpoint A B" 
      by (simp add: ‹A ≠ B› ‹Col A B C› ‹Cong C A C B› col_permutation_5 l7_20_bis)
    ultimately
    have False 
      using ‹A ≠ B› midpoint_not_midpoint by blast
  }
  thus ?thesis 
    by auto
qed

lemma equilateral_strict_conga_1:
  assumes "A B C equilateralStrict"
  shows "C A B CongA A C B" 
proof -
  have "A ≠ B" 
    using assms equilateral_strict_neq by blast
  moreover
  have "A ≠ C" 
    using assms equilateral_strict_neq by blast
  moreover
  have "A B C isosceles" 
    by (meson assms equilateral_isosceles_1 equilateral_strict_equilateral)
  ultimately
  show ?thesis 
    by (simp add: isosceles_conga)
qed

lemma equilateral_strict_conga_2:
  assumes "A B C equilateralStrict"
  shows "B A C CongA A B C" 
  by (simp add: equilateral_strict_conga_1 assms equilateral_strict_swap_1)

lemma equilateral_strict_conga_3:
  assumes "A B C equilateralStrict"
  shows "C B A CongA B C A" 
  by (simp add: equilateral_strict_conga_2 assms equilateral_strict_swap_3)

lemma conga3_equilateral:
  assumes "¬ Col A B C" and
    "B A C CongA A B C" and
    "A B C CongA B C A"
  shows "A B C equilateral" 
  by (meson assms(1) assms(2) assms(3) col_conga_col conga_right_comm 
      conga_trans equilateral_def equilateral_rot_2 l11_44_1_b 
      not_cong_2134 not_cong_3421)

lemma lg_exists:
  "∃ l. (QCong l ∧ l A B)"
  using QCong_def cong_pseudo_reflexivity by blast

lemma lg_cong:
  assumes "QCong l" and
    "l A B" and
    "l C D"
  shows "Cong A B C D"
  by (metis QCong_def assms(1) assms(2) assms(3) cong_inner_transitivity)

lemma lg_cong_lg:
  assumes "QCong l" and
    "l A B" and
    "Cong A B C D"
  shows "l C D"
  by (metis QCong_def assms(1) assms(2) assms(3) cong_transitivity)

lemma lg_sym:
  assumes "QCong l"
    and "l A B"
  shows "l B A"
  using assms(1) assms(2) cong_pseudo_reflexivity lg_cong_lg by blast

lemma ex_points_lg:
  assumes "QCong l"
  shows "∃ A B. l A B"
  using QCong_def assms cong_pseudo_reflexivity by fastforce

lemma is_len_cong:
  assumes "TarskiLen A B l" and
    "TarskiLen C D l"
  shows "Cong A B C D"
  using TarskiLen_def assms(1) assms(2) lg_cong by auto

lemma is_len_cong_is_len:
  assumes "TarskiLen A B l" and
    "Cong A B C D"
  shows "TarskiLen C D l"
  using TarskiLen_def assms(1) assms(2) lg_cong_lg by fastforce

lemma not_cong_is_len:
  assumes "¬ Cong A B C D" and
    "TarskiLen A B l"
  shows "¬ l C D"
  using TarskiLen_def assms(1) assms(2) lg_cong by auto

lemma not_cong_is_len1:
  assumes "¬ Cong A B C D"
    and "TarskiLen A B l"
  shows "¬ TarskiLen C D l"
  using assms(1) assms(2) is_len_cong by blast

lemma lg_null_instance:
  assumes "QCongNull l"
  shows "l A A"
  by (metis QCongNull_def QCong_def assms cong_diff cong_trivial_identity)

lemma lg_null_trivial:
  assumes "QCong l"
    and "l A A"
  shows "QCongNull l"
  using QCongNull_def assms(1) assms(2) by auto

lemma lg_null_dec:
  (*assumes "QCong l" *)
  shows "QCongNull l ∨ ¬ QCongNull l"
  by simp

lemma ex_point_lg:
  assumes "QCong l"
  shows "∃ B. l A B"
  by (metis QCong_def assms not_cong_3412 segment_construction)

lemma ex_point_lg_out:
  assumes "A ≠ P" and
    "QCong l" and
    "¬ QCongNull l"
  shows "∃ B. (l A B ∧ A Out B P)"
proof -
  obtain X Y where P1: "∀ X0 Y0. (Cong X Y X0 Y0 ⟷ l X0 Y0)"
    using QCong_def assms(2) by auto
  hence "l X Y"
    using cong_reflexivity by auto
  hence "X ≠ Y"
    using assms(2) assms(3) lg_null_trivial by auto
  then obtain B where "A Out P B ∧ Cong A B X Y"
    using assms(1) segment_construction_3 by blast
  thus ?thesis
    using Cong_perm Out_cases P1 by blast
qed

lemma ex_point_lg_bet:
  assumes "QCong l"
  shows "∃ B. (l M B ∧ Bet A M B)"
proof -
  obtain X Y where P1: "∀ X0 Y0. (Cong X Y X0 Y0 ⟷ l X0 Y0)"
    using QCong_def assms by auto
  hence "l X Y"
    using cong_reflexivity by blast
  obtain B where "Bet A M B ∧ Cong M B X Y"
    using segment_construction by blast
  thus ?thesis
    using Cong_perm P1 by blast
qed

lemma ex_points_lg_not_col:
  assumes "QCong l"
    and "¬ QCongNull l"
  shows "∃ A B. (l A B ∧ ¬ Col A B P)"
proof -
  have  "∃ B::'p. A ≠ B"
    using another_point by blast
  then obtain A::'p where "P ≠ A"
    by metis
  then obtain Q where "¬ Col P A Q"
    using not_col_exists by auto
  hence "A ≠ Q"
    using col_trivial_2 by auto
  then obtain B where "l A B ∧ A Out B Q"
    using assms(1) assms(2) ex_point_lg_out by blast
  thus ?thesis
    by (metis ‹¬ Col P A Q› col_transitivity_1 not_col_permutation_1 
        out_col out_diff1)
qed

lemma ex_eql:
  assumes  "∃ A B. (TarskiLen A B l1 ∧ TarskiLen A B l2)"
  shows "l1 = l2"
proof -
  obtain A B where P1: "TarskiLen A B l1 ∧ TarskiLen A B l2"
    using assms by auto
  have "∀ A0 B0. (l1 A0 B0 ⟶ l2 A0 B0)"
    by (metis TarskiLen_def ‹TarskiLen A B l1 ∧ TarskiLen A B l2› lg_cong lg_cong_lg)
  have "∀ A0 B0. (l1 A0 B0 ⟷ l2 A0 B0)"
  proof -
    have "∀ A0 B0. (l1 A0 B0 ⟶ l2 A0 B0)"
      by (metis TarskiLen_def ‹TarskiLen A B l1 ∧ TarskiLen A B l2› 
          lg_cong lg_cong_lg)
    moreover have "∀ A0 B0. (l2 A0 B0 ⟶ l1 A0 B0)"
      by (metis TarskiLen_def ‹TarskiLen A B l1 ∧ TarskiLen A B l2› 
          lg_cong lg_cong_lg)
    ultimately show ?thesis by blast
  qed
  thus ?thesis by blast
qed

lemma all_eql:
  assumes "TarskiLen A B l1" and
    "TarskiLen A B l2"
  shows "l1 EqLTarski l2" 
  by (metis EqLTarski_def assms(1) assms(2) ex_eql)

lemma null_len:
  assumes "TarskiLen A A la" and
    "TarskiLen B B lb"
  shows "la EqLTarski lb" 
  using all_eql assms(1) assms(2) cong_trivial_identity is_len_cong_is_len by blast

lemma eqL_equivalence:
  assumes "QCong la" and
    "QCong lb" and
    "QCong lc"
  shows "la = la ∧ (la = lb ⟶ lb = la) ∧ (la = lb ∧ lb = lc ⟶ la = lc)"
  by simp

lemma ex_lg:
  "∃ l. (QCong l ∧ l A B)"
  by (simp add: lg_exists)

lemma lg_eql_lg:
  assumes "QCong l1" and
    "l1 EqLTarski l2"
  shows "QCong l2" 
  using EqLTarski_def QCong_def assms(1) assms(2) by force

lemma ex_eqL:
  assumes "QCong l1" and
    "QCong l2" and
    "∃ A B. (l1 A B ∧ l2 A B)"
  shows "l1 EqLTarski l2" 
  using TarskiLen_def all_eql assms(1) assms(2) assms(3) by force

lemma ang_exists:
  assumes "A ≠ B" and
    "C ≠ B"
  shows "∃ a. (QCongA a ∧ a A B C)"
proof -
  have "A B C CongA A B C"
    by (simp add: assms(1) assms(2) conga_refl)
  thus ?thesis
    using QCongA_def assms(1) assms(2) by auto
qed

lemma ex_points_eng:
  assumes "QCongA a"
  shows "∃ A B C. (a A B C)"
proof -
  obtain A B C where "A ≠ B ∧ C ≠ B ∧ (∀ X Y Z. (A B C CongA X Y Z ⟷ a X Y Z))"
    using QCongA_def assms by auto
  thus ?thesis
    using conga_pseudo_refl by blast
qed

lemma ang_conga:
  assumes "QCongA a" and
    "a A B C" and
    "a A' B' C'"
  shows "A B C CongA A' B' C'"
proof -
  obtain A0 B0 C0 where "A0 ≠ B0 ∧ C0 ≠ B0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟷ a X Y Z))"
    using QCongA_def assms(1) by auto
  thus ?thesis
    by (meson assms(2) assms(3) not_conga not_conga_sym)
qed

lemma is_ang_conga:
  assumes "A B C Ang a" and
    "A' B' C' Ang a"
  shows "A B C CongA A' B' C'"
  using Ang_def ang_conga assms(1) assms(2) by auto

lemma is_ang_conga_is_ang:
  assumes "A B C Ang a" and
    "A B C CongA A' B' C'"
  shows "A' B' C' Ang a"
proof -
  have "QCongA a"
    using Ang_def assms(1) by auto
  then obtain A0 B0 C0 where "A0 ≠ B0 ∧ C0 ≠ B0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟷ a X Y Z))"
    using QCongA_def by auto
  thus ?thesis
    by (metis Ang_def assms(1) assms(2) not_conga)
qed

lemma not_conga_not_ang:
  assumes "QCongA a" and
    "¬ A B C CongA A' B' C'" and
    "a A B C"
  shows "¬ a A' B' C'"
  using ang_conga assms(1) assms(2) assms(3) by auto

lemma not_conga_is_ang:
  assumes "¬ A B C CongA A' B' C'" and
    "A B C Ang a"
  shows "¬ a A' B' C'"
  using Ang_def ang_conga assms(1) assms(2) by auto

lemma not_cong_is_ang1:
  assumes "¬ A B C CongA A' B' C'" and
    "A B C Ang a"
  shows "¬ A' B' C' Ang a"
  using assms(1) assms(2) is_ang_conga by blast

lemma ex_eqa:
  assumes "∃ A B C.(A B C Ang a1 ∧ A B C Ang a2)"
  shows "a1 = a2"
proof -
  obtain A B C where P1: "A B C Ang a1 ∧ A B C Ang a2"
    using assms by auto
  {
    fix x y z
    assume "a1 x y z"
    hence "x y z Ang a1"
      using Ang_def assms by auto
    hence "x y z CongA A B C"
      using P1 not_cong_is_ang1 by blast
    hence "x y z Ang a2"
      using P1 is_ang_conga_is_ang not_conga_sym by blast
    hence "a2 x y z"
      using Ang_def assms by auto
  }
  {
    fix x y z
    assume "a2 x y z"
    hence "x y z Ang a2"
      using Ang_def assms by auto
    hence "x y z CongA A B C"
      using P1 not_cong_is_ang1 by blast
    hence "x y z Ang a1"
      using P1 is_ang_conga_is_ang not_conga_sym by blast
    hence "a1 x y z"
      using Ang_def assms by auto
  }
  hence "∀ x y z. (a1 x y z) ⟷ (a2 x y z)"
    using ‹⋀z y x. a1 x y z ⟹ a2 x y z› by blast
  hence "⋀x y. (∀ z. (a1 x y) z = (a2 x y) z)"
    by simp
  hence "⋀ x y. (a1 x y) = (a2 x y)" using fun_eq_iff by auto
  thus ?thesis using fun_eq_iff by auto
qed

lemma all_eqa:
  assumes "A B C Ang a1" and
    "A B C Ang a2"
  shows "a1 = a2"
  using assms(1) assms(2) ex_eqa by blast

lemma is_ang_distinct:
  assumes "A B C Ang a"
  shows "A ≠ B ∧ C ≠ B"
  using assms conga_diff1 conga_diff2 is_ang_conga by blast

lemma null_ang:
  assumes "A B A Ang a1" and
    "C D C Ang a2"
  shows "a1 = a2"
  using all_eqa assms(1) assms(2) conga_trivial_1 
    is_ang_conga_is_ang is_ang_distinct by auto

lemma flat_ang:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "A B C Ang a1" and
    "A' B' C' Ang a2"
  shows "a1  = a2"
proof -
  have "A B C Ang a2"
  proof -
    have "A' B' C' Ang a2"
      by (simp add: assms(4))
    moreover have "A' B' C' CongA A B C"
      by (metis assms(1) assms(2) assms(3) calculation 
          conga_line is_ang_distinct)
    ultimately show ?thesis
      using is_ang_conga_is_ang by blast
  qed
  thus ?thesis
    using assms(3) all_eqa by auto
qed

lemma ang_distinct:
  assumes "QCongA a" and
    "a A B C"
  shows "A ≠ B ∧ C ≠ B"
proof -
  have "A B C Ang a"
    by (simp add: Ang_def assms(1) assms(2))
  thus ?thesis
    using is_ang_distinct by auto
qed

lemma ex_ang:
  assumes "B ≠ A" and
    "B ≠ C"
  shows "∃ a. (QCongA a ∧ a A B C)"
  using ang_exists assms(1) assms(2) by auto

lemma anga_exists:
  assumes "A ≠ B" and
    "C ≠ B" and
    "Acute A B C"
  shows "∃ a. (QCongAAcute a ∧ a A B C)"
proof -
  have "A B C CongA A B C"
    by (simp add: assms(1) assms(2) conga_refl)
  thus ?thesis
    using assms(1) QCongAAcute_def assms(3) by blast
qed

lemma anga_is_ang:
  assumes "QCongAAcute a"
  shows "QCongA a"
proof -
  obtain A0 B0 C0 where "Acute A0 B0 C0 ∧ 
  (∀ X Y Z.(A0 B0 C0 CongA X Y Z ⟷ a X Y Z))"
    using QCongAAcute_def assms by auto
  thus ?thesis
    using QCongA_def by (metis acute_distincts)
qed

lemma ex_points_anga:
  assumes "QCongAAcute a"
  shows "∃ A B C. a A B C"
  by (simp add: anga_is_ang assms ex_points_eng)

lemma anga_conga:
  assumes "QCongAAcute a" and
    "a A B C" and
    "a A' B' C'"
  shows "A B C CongA A' B' C'"
  by (meson ang_conga anga_is_ang assms(1) assms(2) assms(3))

lemma is_anga_to_is_ang:
  assumes "A B C AngAcute a"
  shows "A B C Ang a"
  using AngAcute_def Ang_def anga_is_ang assms by auto

lemma is_anga_conga:
  assumes "A B C AngAcute a" and
    "A' B' C' AngAcute a"
  shows "A B C CongA A' B' C'"
  using AngAcute_def anga_conga assms(1) assms(2) by auto

lemma is_anga_conga_is_anga:
  assumes "A B C AngAcute a" and
    "A B C CongA A' B' C'"
  shows "A' B' C' AngAcute a"
  using AngAcute_def Ang_def is_ang_conga_is_ang assms(1) assms(2) 
    is_anga_to_is_ang by fastforce

lemma not_conga_is_anga:
  assumes "¬ A B C CongA A' B' C'" and
    "A B C AngAcute a"
  shows "¬ a A' B' C'"
  using AngAcute_def anga_conga assms(1) assms(2) by auto

lemma not_cong_is_anga1:
  assumes "¬ A B C CongA A' B' C'" and
    "A B C AngAcute a"
  shows "¬ A' B' C' AngAcute a"
  using assms(1) assms(2) is_anga_conga by auto

lemma ex_eqaa:
  assumes "∃ A B C. (A B C AngAcute a1 ∧ A B C AngAcute a2)"
  shows "a1 EqA a2" 
proof -
  obtain A B C where "A B C AngAcute a1" and "A B C AngAcute a2"
    using assms by blast
  {
    fix A0 B0 C0
    assume "a1 A0 B0 C0"
    hence "A B C CongA A0 B0 C0"
      using is_ang_conga ‹A B C AngAcute a1› not_conga_is_anga by blast
    hence "A0 B0 C0 Ang a2" 
      using ‹A B C AngAcute a2› is_anga_conga_is_anga is_anga_to_is_ang by blast
    hence "a2 A0 B0 C0" 
      by (simp add: Ang_def)
  }
  moreover
  {
    fix A0 B0 C0
    assume "a2 A0 B0 C0"
    hence "A B C CongA A0 B0 C0"
      using is_ang_conga ‹A B C AngAcute a2› not_conga_is_anga by blast
    hence "A0 B0 C0 Ang a1" 
      using ‹A B C AngAcute a1› is_anga_conga_is_anga is_anga_to_is_ang by blast
    hence "a1 A0 B0 C0" 
      by (simp add: Ang_def)
  }
  ultimately show ?thesis 
    using EqA_def by blast
qed

lemma all_eqaa:
  assumes "A B C AngAcute a1" and
    "A B C AngAcute a2"
  shows "a1 EqA a2"
  using assms(1) assms(2) ex_eqaa by blast

lemma is_anga_distinct:
  assumes "A B C AngAcute a"
  shows "A ≠ B ∧ C ≠ B"
  using assms is_ang_distinct is_anga_to_is_ang by blast

lemma null_anga:
  assumes "A B A AngAcute a1" and
    "C D C AngAcute a2"
  shows "a1 EqA a2" 
proof (rule all_eqaa [where ?A="A" and ?B="B" and ?C="A"])
  show "A B A AngAcute a1" 
    using assms(1) by blast
  show "A B A AngAcute a2"
  proof (rule is_anga_conga_is_anga[where ?A="C" and ?B="D" and ?C="C"])
    show "C D C AngAcute a2" 
      using assms(2) by auto
    show "C D C CongA A B A" 
      using assms(1) assms(2) conga_trivial_1 is_anga_distinct by force
  qed
qed

lemma anga_distinct:
  assumes "QCongAAcute a" and
    "a A B C"
  shows "A ≠ B ∧ C ≠ B"
  using ang_distinct anga_is_ang assms(1) assms(2) by blast

lemma out_is_len_eq:
  assumes "A Out B C" and
    "TarskiLen A B l" and
    "TarskiLen A C l"
  shows "B = C"
  using Out_def assms(1) assms(2) assms(3) between_cong 
    not_cong_is_len1 by fastforce

lemma out_len_eq:
  assumes "QCong l" and
    "A Out B C" and
    "l A B" and
    "l A C"
  shows "B = C" using out_is_len_eq
  using TarskiLen_def assms(1) assms(2) assms(3) assms(4) by auto

lemma ex_anga:
  assumes "Acute A B C"
  shows "∃ a. (QCongAAcute a ∧ a A B C)"
  using acute_distincts anga_exists assms by blast

lemma not_null_ang_ang:
  assumes "QCongAnNull a"
  shows "QCongA a"
  using QCongAnNull_def assms by blast

lemma not_null_ang_def_equiv:
  "QCongAnNull a ⟷ (QCongA a ∧ (∃ A B C. (a A B C ∧  ¬ B Out A C)))"
proof -
  {
    assume "QCongAnNull a"
    have "QCongA a ∧ (∃ A B C. (a A B C ∧  ¬ B Out A C))"
      using QCongAnNull_def ‹QCongAnNull a› ex_points_eng 
      by fastforce
  }
  {
    assume "QCongA a ∧ (∃ A B C. (a A B C ∧  ¬ B Out A C))"
    have "QCongAnNull a"
      by (metis Ang_def QCongAnNull_def l11_21_a 
          ‹QCongA a ∧ (∃A B C. a A B C ∧ ¬ B Out A C)› not_conga_is_ang)
  }
  thus ?thesis
    using ‹QCongAnNull a ⟹ QCongA a ∧ (∃A B C. a A B C ∧ ¬ B Out A C)› by blast
qed

lemma not_flat_ang_def_equiv:
  "QCongAnFlat a ⟷ (QCongA a ∧ (∃ A B C. (a A B C ∧ ¬ Bet A B C)))"
proof -
  {
    assume "QCongAnFlat a"
    hence "QCongA a ∧ (∃ A B C. (a A B C ∧ ¬ Bet A B C))"
      using QCongAnFlat_def ex_points_eng by fastforce
  }
  {
    assume "QCongA a ∧ (∃ A B C. (a A B C ∧ ¬ Bet A B C))"
    have "QCongAnFlat a"
      by (metis QCongAnFlat_def ‹QCongA a ∧ (∃A B C. a A B C ∧ ¬ (A ─ B ─ C ))› ang_conga
          bet_conga__bet)
  }
  thus ?thesis
    using ‹QCongAnFlat a ⟹ QCongA a ∧ (∃A B C. a A B C ∧ ¬ Bet A B C)› 
    by blast
qed

lemma ang_const:
  assumes "QCongA a" and
    "A ≠ B"
  shows "∃ C. a A B C"
proof -
  obtain A0 B0 C0 where "A0 ≠ B0 ∧ C0 ≠ B0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟶ a X Y Z))"
    by (metis QCongA_def assms(1))
  hence "(A0 B0 C0 CongA A0 B0 C0) ⟷ a A0 B0 C0"
    by (simp add: conga_refl)
  hence "a A0 B0 C0"
    using ‹A0 ≠ B0 ∧ C0 ≠ B0 ∧ (∀X Y Z. A0 B0 C0 CongA X Y Z ⟶ a X Y Z)› 
      conga_refl by blast
  thus ?thesis
    using ‹A0 ≠ B0 ∧ C0 ≠ B0 ∧ (∀X Y Z. A0 B0 C0 CongA X Y Z ⟶ a X Y Z)›
      angle_construction_3 assms(2) by blast
qed

lemma ang_sym:
  assumes "QCongA a" and
    "a A B C"
  shows "a C B A"
proof -
  obtain A0 B0 C0 where "A0 ≠ B0 ∧ C0 ≠ B0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟶ a X Y Z))"
    by (metis QCongA_def assms(1))
  thus ?thesis
    by (metis ang_conga assms(1) assms(2) conga_left_comm conga_refl not_conga_sym)
qed

lemma ang_not_null_lg:
  assumes "QCongA a" and
    "QCong l" and
    "a A B C" and
    "l A B"
  shows "¬ QCongNull l"
  by (metis QCongNull_def TarskiLen_def ang_distinct assms(1) 
      assms(3) assms(4) cong_reverse_identity not_cong_is_len)

lemma ang_distincts:
  assumes "QCongA a" and
    "a A B C"
  shows "A ≠ B ∧ C ≠ B"
  using ang_distinct assms(1) assms(2) by auto

lemma anga_sym:
  assumes "QCongAAcute a" and
    "a A B C"
  shows "a C B A"
  by (simp add: ang_sym anga_is_ang assms(1) assms(2))

lemma anga_not_null_lg:
  assumes "QCongAAcute a" and
    "QCong l" and
    "a A B C" and
    "l A B"
  shows "¬ QCongNull l"
  using ang_not_null_lg anga_is_ang assms(1) assms(2) assms(3) assms(4) by blast

lemma anga_distincts:
  assumes "QCongAAcute a" and
    "a A B C"
  shows "A ≠ B ∧ C ≠ B"
  using anga_distinct assms(1) assms(2) by blast

lemma ang_const_o:
  assumes "¬ Col A B P" and
    "QCongA a" and
    "QCongAnNull a" and
    "QCongAnFlat a"
  shows "∃ C. a A B C ∧ A B OS C P"
proof -
  obtain A0 B0 C0 where P1: "A0 ≠ B0 ∧ C0 ≠ B0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟶ a X Y Z))"
    by (metis QCongA_def assms(2))
  hence "a A0 B0 C0"
    by (simp add: conga_refl)
  hence T1: "A0 ≠ C0"
    using P1 QCongAnNull_def assms(3) out_trivial by fastforce
  have "A ≠ B"
    using assms(1) col_trivial_1 by blast
  have "A0 ≠ B0 ∧ B0 ≠ C0"
    using P1 by auto
  then obtain C where P2: "A0 B0 C0 CongA A B C ∧ (A B OS C P ∨ Col A B C)"
    using angle_construction_2 assms(1) by blast
  hence "a A B C"
    by (simp add: P1)
  have P3: "A B OS C P ∨ Col A B C"
    using P2 by simp
  have P4: "∀ A B C. (a A B C ⟶ ¬ B Out A C)"
    using assms(3) by (simp add: QCongAnNull_def)
  have P5: "∀ A B C. (a A B C ⟶ ¬ Bet A B C)"
    using assms(4) QCongAnFlat_def by auto
  {
    assume "Col A B C"
    have "¬ B Out A C"
      using P4 by (simp add: ‹a A B C›)
    have "¬ Bet A B C"
      using P5 by (simp add: ‹a A B C›)
    hence "A B OS C P"
      using ‹Col A B C› ‹¬ B Out A C› l6_4_2 by blast
    hence "∃ C1. (a A B C1 ∧ A B OS C1 P)"
      using ‹a A B C› by blast
  }
  hence "∃ C1. (a A B C1 ∧ A B OS C1 P)"
    using P3 ‹a A B C› by blast
  thus ?thesis
    by simp
qed

lemma anga_const:
  assumes "QCongAAcute a" and
    "A ≠ B"
  shows "∃ C. a A B C"
  using ang_const anga_is_ang assms(1) assms(2) by fastforce

lemma null_anga_null_angaP:
  "QCongANullAcute a ⟷ IsNullAngaP a"
proof -
  have "QCongANullAcute a ⟶ IsNullAngaP a"
    using IsNullAngaP_def QCongANullAcute_def ex_points_anga by fastforce
  moreover have "IsNullAngaP a ⟶ QCongANullAcute a"
    by (metis IsNullAngaP_def QCongAnNull_def QCongANullAcute_def 
        anga_is_ang not_null_ang_def_equiv)
  ultimately show ?thesis
    by blast
qed

lemma is_null_anga_out:
  assumes (*"QCongAAcute a" and *)
    "a A B C" and
    "QCongANullAcute a"
  shows "B Out A C"
  using QCongANullAcute_def assms(1) assms(2) by auto

lemma anga_acute:
  assumes "QCongAAcute a" and
    "a A B C"
  shows "Acute A B C" 
  using QCongAAcute_def acute_conga__acute assms(1) assms(2) by metis

lemma not_null_not_col:
  assumes "QCongAAcute a" and
    "¬ QCongANullAcute a" and
    "a A B C"
  shows "¬ Col A B C"
proof -
  have "Acute A B C"
    using anga_acute assms(1) assms(3) by blast
  thus ?thesis
    using IsNullAngaP_def acute_col__out assms(1) assms(2) assms(3) 
      null_anga_null_angaP by blast
qed

lemma ang_cong_ang:
  assumes "QCongA a" and
    "a A B C" and
    "A B C CongA A' B' C'"
  shows "a A' B' C'"
  by (metis QCongA_def assms(1) assms(2) assms(3) not_conga)

lemma is_null_ang_out:
  assumes (*"QCongA a" and *)
    "a A B C" and
    "QCongANull a"
  shows "B Out A C"
proof -
  have "a A B C ⟶ B Out A C"
    using QCongANull_def assms(2) by auto
  thus ?thesis
    by (simp add: assms(1))
qed

lemma out_null_ang:
  assumes "QCongA a" and
    "a A B C" and
    "B Out A C"
  shows "QCongANull a"
  by (metis QCongANull_def QCongAnNull_def assms(1) assms(2) assms(3) 
      not_null_ang_def_equiv)

lemma bet_flat_ang:
  assumes "QCongA a" and
    "a A B C" and
    "Bet A B C"
  shows "AngFlat a"
  by (metis AngFlat_def QCongAnFlat_def assms(1) assms(2) assms(3) 
      not_flat_ang_def_equiv)

lemma out_null_anga:
  assumes "QCongAAcute a" and
    "a A B C" and
    "B Out A C"
  shows "QCongANullAcute a"
  using IsNullAngaP_def assms(1) assms(2) assms(3) null_anga_null_angaP by auto

lemma anga_not_flat:
  assumes "QCongAAcute a"
  shows "QCongAnFlat a"
  by (metis (no_types, lifting) QCongAnFlat_def anga_is_ang assms 
      bet_col is_null_anga_out not_bet_and_out not_null_not_col)

lemma anga_const_o:
  assumes "¬ Col A B P" and
    "¬ QCongANullAcute a" and
    "QCongAAcute a"
  shows "∃ C. (a A B C ∧ A B OS C P)"
proof -
  have "QCongA a"
    by (simp add: anga_is_ang assms(3))
  moreover  have "QCongAnNull a"
    using QCongANullAcute_def assms(2) assms(3) calculation 
      not_null_ang_def_equiv by auto
  moreover have "QCongAnFlat a"
    by (simp add: anga_not_flat assms(3))
  ultimately show ?thesis
    by (simp add: ang_const_o assms(1))
qed

lemma anga_conga_anga:
  assumes "QCongAAcute a" and
    "a A B C" and
    "A B C CongA A' B' C'"
  shows "a A' B' C'"
  using ang_cong_ang anga_is_ang assms(1) assms(2) assms(3) by blast

lemma anga_out_anga:
  assumes "QCongAAcute a" and
    "a A B C" and
    "B Out A A'" and
    "B Out C C'"
  shows "a A' B C'"
proof -
  have "A B C CongA A' B C'"
    by (simp add: assms(3) assms(4) l6_6 out2__conga)
  thus ?thesis
    using anga_conga_anga assms(1) assms(2) by blast
qed

lemma out_out_anga:
  assumes "QCongAAcute a" and
    "B Out A C" and
    "B' Out A' C'" and
    "a A B C"
  shows "a A' B' C'"
proof -
  have "A B C CongA A' B' C'"
    by (simp add: assms(2) assms(3) l11_21_b)
  thus ?thesis
    using anga_conga_anga assms(1) assms(4) by blast
qed

lemma is_null_all:
  assumes "A ≠ B" and
    "QCongANullAcute a"
  shows "a A B A"
proof -
  obtain A0 B0 C0 where "Acute A0 B0 C0 ∧ 
  (∀ X Y Z. (A0 B0 C0 CongA X Y Z ⟷ a X Y Z))"
    using QCongAAcute_def QCongANullAcute_def assms(2) by auto
  hence "a A0 B0 C0"
    using acute_distincts conga_refl by blast
  thus ?thesis 
    using QCongANullAcute_def assms(1) assms(2) out_out_anga 
      out_trivial by fast
qed

lemma anga_col_out:
  assumes "QCongAAcute a" and
    "a A B C" and
    "Col A B C"
  shows "B Out A C"
proof -
  have "Acute A B C"
    using anga_acute assms(1) assms(2) by auto
  hence P1: "Bet A B C ⟶ B Out A C"
    using acute_not_bet by auto
  hence "Bet C A B ⟶ B Out A C"
    using assms(3) l6_4_2 by auto
  thus ?thesis
    using P1 assms(3) l6_4_2 by blast
qed

lemma ang_not_lg_null:
  assumes "QCong la" and
    "QCong lc" and
    "QCongA a" and
    "la A B" and
    "lc C B" and
    "a A B C"
  shows "¬ QCongNull la ∧ ¬ QCongNull lc"
  by (metis ang_not_null_lg ang_sym assms(1) assms(2) assms(3) 
      assms(4) assms(5) assms(6))

lemma anga_not_lg_null:
  assumes (*"QCong la" and
  "QCong lc" and*)
    "QCongAAcute a" and
    "la A B" and
    "lc C B" and
    "a A B C"
  shows  "¬ QCongNull la ∧ ¬ QCongNull lc"
  by (metis QCongNull_def anga_not_null_lg anga_sym assms(1) 
      assms(2) assms(3) assms(4))

lemma anga_col_null:
  assumes "QCongAAcute a" and
    "a A B C" and
    "Col A B C"
  shows "B Out A C ∧ QCongANullAcute a"
  using anga_col_out assms(1) assms(2) assms(3) out_null_anga by blast

lemma eqA_preserves_ang:
  assumes "QCongA a" and
    "a EqA b"
  shows "QCongA b" 
proof -
  obtain x x0 x1 where "x ≠ x0" and "x1 ≠ x0" and "∀ X Y Z. x x0 x1 CongA X Y Z ⟷ a X Y Z" 
    using QCongA_def assms(1) by auto
  thus ?thesis 
    using EqA_def QCongA_def assms(2) by auto
qed

lemma eqA_preserves_anga:
  assumes "QCongAAcute a" and
    "a EqA b"
  shows "QCongAAcute b"
proof -
  have "QCongA a" 
    by (simp add: anga_is_ang assms(1))
  obtain A B C where "a A B C" 
    using assms(1) ex_points_anga by blast
  hence "b A B C" 
    using EqA_def assms(2) by fastforce
  have "Acute A B C" 
    using ‹a A B C› anga_acute assms(1) by blast
  moreover
  {
    fix X Y Z
    assume "A B C CongA X Y Z"
    hence "b X Y Z" 
      using EqA_def ‹a A B C› anga_conga_anga assms(1) assms(2) by fastforce
  }
  moreover
  {
    fix X Y Z
    assume "b X Y Z" 
    hence "A B C CongA X Y Z"
      using EqA_def ‹a A B C› anga_conga assms(1) assms(2) by auto
  }
  ultimately show ?thesis 
    by (metis QCongAAcute_def)
qed

(* Gabriel Braun April 2013 *)

lemma l13_6: 
  assumes "Lcos lc l a" and
    "Lcos ld l a"
  shows "lc EqLTarski ld"
proof -
  have H1: "QCong lc ∧ QCong l ∧ QCongAAcute a ∧
  (∃ A B C. (Per C B A ∧ lc A B ∧ l A C ∧ a B A C))" 
    using Lcos_def assms(1) by force
  then obtain X1 Y1 Z1 where "Per Z1 Y1 X1" and "lc X1 Y1" and "l X1 Z1" and "a Y1 X1 Z1"
    by blast
  have H2: "QCong ld ∧ QCong l ∧ QCongAAcute a ∧
  (∃ A B C. (Per C B A ∧ ld A B ∧ l A C ∧ a B A C))" 
    using Lcos_def assms(2) by force
  then obtain X2 Y2 Z2 where "Per Z2 Y2 X2" and "ld X2 Y2" and "l X2 Z2" and "a Y2 X2 Z2"
    by blast
  have "TarskiLen X1 Z1 l" 
    by (simp add: TarskiLen_def H1 ‹l X1 Z1›)
  have "TarskiLen X2 Z2 l" 
    by (simp add: TarskiLen_def H2 ‹l X2 Z2›)
  have "Cong X1 Z1 X2 Z2" 
    using ‹TarskiLen X1 Z1 l› ‹TarskiLen X2 Z2 l› is_len_cong by auto
  have "Y1 X1 Z1 AngAcute a" 
    using ‹a Y1 X1 Z1› H1 by (simp add: AngAcute_def)
  have "Y2 X2 Z2 AngAcute a" 
    using H2 by (simp add: AngAcute_def ‹a Y2 X2 Z2›)
  have "Y1 X1 Z1 CongA Y2 X2 Z2" 
    using ‹Y1 X1 Z1 AngAcute a› ‹a Y2 X2 Z2› not_conga_is_anga by blast
  have "TarskiLen X1 Y1 lc" 
    by (simp add: H1 TarskiLen_def ‹lc X1 Y1›)
  have "TarskiLen X2 Y2 ld" 
    by (simp add: H2 TarskiLen_def ‹ld X2 Y2›)
  {
    assume "Z1 = Y1"
    hence "X2 Out Y2 Z2" 
      using ‹Y1 X1 Z1 CongA Y2 X2 Z2› eq_conga_out by blast
    hence "Col Z2 Y2 X2" 
      by (simp add: col_permutation_3 out_col)
    hence "Y2 = Z2 ∨ X2 = Y2" 
      using l8_9 ‹Per Z2 Y2 X2› by blast
    hence "Y2 = Z2" 
      using ‹X2 Out Y2 Z2› out_diff1 by blast
    have "TarskiLen X1 Y1 l" 
      using ‹TarskiLen X1 Z1 l› ‹Z1 = Y1› by blast
    hence "l EqLTarski lc" 
      by (metis ‹TarskiLen X1 Y1 lc› all_eql)
    have "TarskiLen X2 Y2 l" 
      by (simp add: ‹TarskiLen X2 Z2 l› ‹Y2 = Z2›)
    hence "l EqLTarski ld" 
      by (metis ‹TarskiLen X2 Y2 ld› all_eql)
    hence ?thesis 
      using EqLTarski_def‹l EqLTarski lc› by auto
  }
  moreover
  {
    assume "Z1 ≠ Y1"
    {
      assume "Y2 = Z2"
      have "Y2 X2 Y2 CongA Y1 X1 Z1" 
        using ‹Y1 X1 Z1 CongA Y2 X2 Z2› ‹Y2 = Z2› conga_sym_equiv by auto
      hence "X1 Out Y1 Z1" 
        by (simp add: eq_conga_out)
      have "Z1 = Y1 ∨ X1 = Y1" 
        using ‹Per Z1 Y1 X1› ‹X1 Out Y1 Z1› l8_2 l8_9 out_col by blast
      hence "Y1 = Z1" 
        using ‹X1 Out Y1 Z1› out_diff1 by blast
      hence False 
        using ‹Z1 ≠ Y1› by blast
    }
    hence "Z2 ≠ Y2" 
      by blast
    hence "X1 Y1 Z1 CongA X2 Y2 Z2" 
      by (metis ‹Per Z1 Y1 X1› ‹Per Z2 Y2 X2› ‹Y1 X1 Z1 CongA Y2 X2 Z2› ‹Z1 ≠ Y1› 
          conga_comm conga_diff1 conga_diff45 l11_16)
    {
      assume "Col Z1 X1 Y1"
      hence "X1 = Y1 ∨ Z1 = Y1" 
        using NCol_perm ‹Per Z1 Y1 X1› l8_3 per_distinct_1 by blast
      hence False 
        using CongA_def ‹X1 Y1 Z1 CongA X2 Y2 Z2› by blast
    }
    hence "¬ Col Z1 X1 Y1" 
      by blast
    have "Z1 X1 Y1 CongA Z2 X2 Y2" 
      by (simp add: ‹Y1 X1 Z1 CongA Y2 X2 Z2› conga_comm)
    have "Cong Z1 Y1 Z2 Y2 ∧ Cong X1 Y1 X2 Y2 ∧ Y1 Z1 X1 CongA Y2 Z2 X2" 
      using l11_50_2 ‹Cong X1 Z1 X2 Z2› ‹X1 Y1 Z1 CongA X2 Y2 Z2› 
        ‹Z1 X1 Y1 CongA Z2 X2 Y2› ‹¬ Col Z1 X1 Y1› not_cong_2143 by blast
    hence ?thesis 
      by (metis EqLTarski_def‹TarskiLen X1 Y1 lc› ‹TarskiLen X2 Y2 ld› ex_eql is_len_cong_is_len)
  }
  ultimately show ?thesis
    by blast
qed

lemma null_lcos_eql:
  assumes "Lcos lp l a" and
    "QCongANullAcute a"
  shows "l EqLTarski lp" 
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a ∧
  (∃ A B C. (Per C B A ∧ lp A B ∧ l A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  then obtain A B C where "Per C B A" and "lp A B" and "l A C" and "a B A C"
    by blast
  have "A Out B C" 
    using ‹a B A C› assms(2) is_null_anga_out by force
  hence "Col A B C" 
    by (simp add: out_col)
  hence "C = B ∨ A = B"
    using Per_cases ‹Per C B A› l8_9 by blast
  moreover have "C = B ⟶ ?thesis" 
  proof -
    {
      assume "C = B"
      have "QCong l" 
        using H1 by blast
      have "l A B" 
        using ‹C = B› ‹l A C› by auto
      hence "TarskiLen A B l" 
        by (simp add: TarskiLen_def ‹QCong l›)
      moreover have "TarskiLen A B lp" 
        by (simp add: H1 TarskiLen_def ‹lp A B›)
      ultimately have "l EqLTarski lp" 
        using all_eql assms(1) l13_6 by blast
    }
    thus ?thesis by blast
  qed
  moreover have "A = B ⟶ ?thesis" 
    using ‹A Out B C› out_diff1 by blast
  ultimately show ?thesis 
    by fastforce
qed

lemma eql_lcos_null:
  assumes "Lcos l lp a" and 
    "l EqLTarski lp" 
  shows "QCongANullAcute a" 
proof -
  have H1:"QCong l ∧ QCong lp ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ l A B ∧ lp A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  then obtain B A C where "Per C A B" and "l B A" and "lp B C" and "a A B C"
    by blast
  have "∀ A0 B0. l A0 B0 ⟷ lp A0 B0" 
    using EqLTarski_def assms(2) by force
  have "l B A ⟷ lp B A" 
    using ‹∀A0 B0. l A0 B0 = lp A0 B0› by auto
  hence "lp B A" 
    by (simp add: ‹l B A›)
  have "l B C ⟷ lp B C" 
    using ‹∀A0 B0. l A0 B0 = lp A0 B0› by auto
  hence "l B C" 
    by (simp add: ‹lp B C›)
  have "Cong B A B C" 
    using Lcos_def TarskiLen_def ‹l B A› ‹l B C› assms(1) is_len_cong by force
  obtain B' where "A Midpoint B B'" and "Cong C B C B'" 
    using Per_def ‹Per C A B› by blast
  have "A ≠ B ∧ C ≠ B" 
    using anga_distinct H1 ‹a A B C› by blast
  hence "A ≠ B" 
    by simp
  have "C ≠ B" 
    using ‹A ≠ B ∧ C ≠ B› by fastforce
  have "A = C" 
    by (meson ‹Cong B A B C› ‹Per C A B› cong2_per2__cong cong_diff_4 
        cong_pseudo_reflexivity cong_transitivity l8_20_1_R1)
  have "QCongAAcute a" 
    using H1 by blast
  moreover {
    fix A0 B0 C0
    assume "a A0 B0 C0"
    hence "A B A CongA A0 B0 C0" 
      using anga_conga ‹A = C› ‹a A B C› calculation by blast
    hence "B0 Out A0 C0" 
      using eq_conga_out by blast
  }
  ultimately show ?thesis 
    using QCongANullAcute_def by auto
qed

lemma lcos_lg_not_null:
  assumes "Lcos l lp a" 
  shows "¬ QCongNull l ∧ ¬ QCongNull lp"
proof -
  have H1:"QCong l ∧ QCong lp ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ l A B ∧ lp A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  then obtain A B C where "Per C B A" and "l A B" and "lp A C" and "a B A C"
    by blast
  hence "B ≠ A ∧ C ≠ A" 
    using H1 anga_distinct ‹a B A C› by blast
  {
    assume "QCong l ∧ (∃ X. l X X)"
    then obtain X where "l X X" 
      by blast
    hence "Cong A B X X" 
      using ‹QCong l ∧ (∃X. l X X)› ‹l A B› lg_cong by blast
    hence False 
      using ‹B ≠ A ∧ C ≠ A› cong_identity by blast
  }
  moreover
  {
    assume "QCong lp ∧ (∃ X. lp X X)"
    then obtain X where "lp X X" 
      by blast
    hence "Cong A C X X" 
      using ‹QCong lp ∧ (∃X. lp X X)› ‹lp A C› lg_cong by blast
    hence False 
      using ‹B ≠ A ∧ C ≠ A› cong_diff_2 by blast
  }
  ultimately show ?thesis 
    using QCongNull_def by auto
qed

lemma perp_acute_out: 
  assumes "Acute A B C" and
    "A B Perp C C'" and
    "Col A B C'"
  shows "B Out A C'" 
proof -
  have "B Out C' A" 
    using acute_col_perp__out 
    by (meson acute_sym assms(1) assms(2) assms(3) col_permutation_4 perp_comm perp_right_comm)
  thus ?thesis 
    using l6_6 by blast
qed

lemma perp_col_out__acute_aux: 
  assumes "A B Perp C C'" and
    "B Out A C'"
  shows "Acute A B C" 
  using assms(1) assms(2) perp_out_acute by blast

lemma perp_out__acute: 
  assumes "A B Perp C C'" and
    "Col A B C'" 
  shows "Acute A B C ⟷ B Out A C'" 
  using assms(1) assms(2) perp_acute_out perp_col_out__acute_aux by blast

lemma obtuse_not_acute:
  assumes "Obtuse A B C"
  shows "¬ Acute A B C" 
  using acute__not_obtuse assms by blast

lemma acute_not_obtuse: 
  assumes "Acute A B C" 
  shows "¬ Obtuse A B C" 
  using assms obtuse_not_acute by blast

lemma perp_obtuse_bet:
  assumes "A B Perp C C'" and
    "Col A B C'" and
    "Obtuse A B C"
  shows "Bet A B C'" 
proof -
  obtain A0 B0 C0 where "Per A0 B0 C0" and "A0 B0 C0 LtA A B C" 
    using Obtuse_def assms(3) by blast
  have "A0 ≠ B0" 
    using ‹A0 B0 C0 LtA A B C› lta_distincts by auto
  have "C0 ≠ B0" 
    using ‹A0 B0 C0 LtA A B C› lta_distincts by blast
  have "A ≠ B" 
    using assms(1) perp_not_eq_1 by blast
  have "C ≠ B" 
    using assms(1) assms(2) col_trivial_2 l8_16_1 by blast
  {
    assume "B = C'" 
    hence "Per A B C" 
      using assms(1) perp_left_comm perp_per_1 by blast
    have "A0 B0 C0 CongA A B C" 
      by (simp add: ‹A ≠ B› ‹A0 ≠ B0› ‹C ≠ B› ‹C0 ≠ B0› ‹Per A B C› ‹Per A0 B0 C0› l11_16)
    hence False 
      by (simp add: ‹A0 B0 C0 LtA A B C› lta_not_conga)
  }
  hence "B ≠ C'" 
    by blast
  {
    assume "Bet B C' A ∨ Bet C' A B" 
    hence "Bet B A C' ∨ Bet B C' A" 
      using Bet_cases by blast
    hence "B Out A C'" 
      using Out_def ‹A ≠ B› ‹B ≠ C'› by blast
  }
  thus ?thesis using perp_out_acute
    using Col_def assms(1) assms(2) assms(3) obtuse_not_acute by blast
qed

lemma lcos_const0: 
  assumes "Lcos lp l a" and
    "QCongANullAcute a"
  shows "∃ A B C. l A B ∧ lp B C ∧ a A B C" 
proof -
  have "QCong lp ∧ QCong l ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ lp A B ∧ l A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  thus ?thesis 
    using anga_sym lg_sym by blast
qed

lemma lcos_const1:
  fixes P::'p 
  assumes "Lcos lp l a" and 
    "¬ QCongANullAcute a" 
  shows "∃ A B C. ¬ Col A B P ∧ A B OS C P ∧ l A B ∧ lp B C ∧ a A B C" 
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ lp A B ∧ l A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  have "¬ QCongNull lp ∧ ¬ QCongNull l" 
    using assms(1) lcos_lg_not_null by auto
  then obtain A B where "l A B" and "¬ Col A B P" 
    using H1 ex_points_lg_not_col by blast
  then obtain C' where "a A B C'" and "A B OS C' P" 
    using anga_const_o H1 ‹¬ Col A B P› assms(2) by blast
  have "A ≠ B ∧ B ≠ C'" 
    using ‹A B OS C' P› os_distincts by blast
  obtain C where "lp B C" and "B Out C C'" 
    using H1 ex_points_lg_not_col ‹A ≠ B ∧ B ≠ C'› ‹¬ QCongNull lp ∧ ¬ QCongNull l› 
      ex_point_lg_out by blast
  have "A B OS C P" 
    using ‹A B OS C' P› ‹B Out C C'› l6_6 not_col_distincts os_out_os by blast
  moreover have "a A B C" 
  proof -
    have "B Out A A"      
      using ‹A ≠ B ∧ B ≠ C'› out_trivial by auto
    moreover have "B Out C' C" 
      using Out_cases ‹B Out C C'› by blast
    ultimately show ?thesis
      using H1 ‹a A B C'› anga_out_anga by blast
  qed
  ultimately have "∃ C. ¬ Col A B P ∧ A B OS C P ∧ l A B ∧ lp B C ∧ a A B C" 
    using ‹¬ Col A B P› ‹l A B› ‹lp B C› by blast
  thus ?thesis 
    by blast
qed

lemma lcos_const:
  assumes "Lcos lp l a"
  shows "∃ A B C. lp A B ∧ l B C ∧ a A B C" 
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ lp A B ∧ l A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  then obtain A B C where "Per C B A" and "lp A B" and "l A C" and "a B A C"
    by blast
  hence "lp B A" 
    using lg_sym H1 by blast
  thus ?thesis 
    using ‹a B A C› ‹l A C› by auto
qed

lemma lcos_lg_distincts:
  assumes "Lcos lp l a" and
    "l A B" and 
    (*"lp B C" and*)
    "a A B C"
  shows "A ≠ B ∧ C ≠ B"
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ lp A B ∧ l A C ∧ a B A C))" 
    using assms(1) Lcos_def by blast
  have "¬ QCongNull lp ∧ ¬ QCongNull l" 
    using assms(1) lcos_lg_not_null by auto
  {
    assume "A = B"
    hence False 
      using H1 ‹¬ QCongNull lp ∧ ¬ QCongNull l› assms(2) lg_null_trivial by blast
  }
  moreover
  {
    assume "C = B"
    hence False 
      using H1 anga_distincts assms(3) by blast
  }
  ultimately show ?thesis
    by blast
qed

lemma lcos_const_a:
  assumes "Lcos lp l a"
  shows "∀ B. ∃ A C. l A B ∧ lp B C ∧ a A B C"
proof -
  {
    fix B
    have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a"
      using assms(1) Lcos_def by blast
    then obtain A where "l B A" 
      using ex_point_lg by blast
    hence "l A B" 
      using H1 lg_sym by auto
    have "¬ QCongNull lp ∧ ¬ QCongNull l" 
      using assms(1) lcos_lg_not_null by auto
    {
      assume "A = B"
      hence "QCongNull l" 
        using H1 ‹l B A› lg_null_trivial by auto
      hence False 
        using ‹¬ QCongNull lp ∧ ¬ QCongNull l› by linarith
    }
    then obtain C' where "a A B C'" 
      using H1 anga_const by blast
    hence "C' ≠ B" 
      using ‹l A B› assms lcos_lg_distincts by auto
    then obtain C where "lp B C" and "B Out C C'" 
      using ex_point_lg_out H1 ‹¬ QCongNull lp ∧ ¬ QCongNull l› by metis
    have "a A B C" 
    proof (rule anga_out_anga [where ?A = "A" and ?C = "C'"], simp_all add: H1 ‹a A B C'›)
      show "B Out A A" 
        using ‹A = B ⟹ False› out_trivial by blast
      show "B Out C' C" 
        using Out_cases ‹B Out C C'› by auto
    qed
    hence "∃ C. l A B ∧ lp B C ∧ a A B C" 
      using ‹l A B› ‹lp B C› by blast
    hence "∃ A C. l A B ∧ lp B C ∧ a A B C" 
      by blast
  }
  thus ?thesis
    by blast
qed

lemma lcos_const_ab:
  assumes "Lcos lp l a" and
    "l A B"
  shows "∃ C. lp B C ∧ a A B C" 
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a"
    using assms(1) Lcos_def by blast
  have "¬ QCongNull lp ∧ ¬ QCongNull l" 
    using assms(1) lcos_lg_not_null by auto
  {
    assume "A = B"
    hence "QCongNull l" 
      using H1 assms(2) lg_null_trivial by auto
    hence False 
      using ‹¬ QCongNull lp ∧ ¬ QCongNull l› by linarith
  }
  then obtain C' where "a A B C'" 
    using H1 anga_const by blast
  hence "C' ≠ B" 
    using ‹l A B› assms lcos_lg_distincts by auto
  then obtain C where "lp B C" and "B Out C C'" 
    using ex_point_lg_out H1 ‹¬ QCongNull lp ∧ ¬ QCongNull l› by metis
  have "a A B C" 
  proof (rule anga_out_anga [where ?A = "A" and ?C = "C'"], simp_all add: H1 ‹a A B C'›)
    show "B Out A A" 
      using ‹A = B ⟹ False› out_trivial by blast
    show "B Out C' C" 
      using Out_cases ‹B Out C C'› by auto
  qed
  thus ?thesis 
    using ‹lp B C› by auto
qed

lemma lcos_const_cb:
  assumes "Lcos lp l a" and
    "lp B C"
  shows "∃ A. l A B ∧ a A B C" 
proof -
  have H1:"QCong lp ∧ QCong l ∧ QCongAAcute a"
    using assms(1) Lcos_def by blast
  have "¬ QCongNull lp ∧ ¬ QCongNull l" 
    using assms(1) lcos_lg_not_null by auto
  {
    assume "C = B"
    hence "QCongNull lp" 
      using H1 assms(2) lg_null_trivial by auto
    hence False 
      using ‹¬ QCongNull lp ∧ ¬ QCongNull l› by linarith
  }
  then obtain A' where "a C B A'" 
    using H1 anga_const by blast
  hence "A' ≠ B" 
    using anga_distinct H1 by blast
  then obtain A where "l B A" and "B Out A A'" 
    using ex_point_lg_out H1 ‹¬ QCongNull lp ∧ ¬ QCongNull l› by metis
  have "a A B C" 
  proof (rule anga_out_anga [where ?A = "A'" and ?C = "C"], simp add: H1)
    show "B Out A' A" 
      using ‹B Out A A'› l6_6 by blast
    show "B Out C C" 
      using ‹C = B ⟹ False› out_trivial by blast
    show "a A' B C" 
      using anga_sym H1 ‹a C B A'› by blast
  qed
  thus ?thesis 
    using H1 ‹l B A› lg_sym by blast 
qed

lemma lcos_lg_anga:
  assumes "Lcos lp l a"
  shows "Lcos lp l a ∧ QCong l ∧ QCong lp ∧ QCongAAcute a" 
  using Lcos_def assms by blast

lemma lcos_eql_lcos:
  assumes "lp1 EqLTarski lp2" and
    "l1 EqLTarski l2" and
    "Lcos lp1 l1 a"
  shows "Lcos lp2 l2 a" 
proof -
  have H1:"QCong lp1 ∧ QCong l1 ∧ QCongAAcute a ∧ 
              (∃ A B C. (Per C B A ∧ lp1 A B ∧ l1 A C ∧ a B A C))" 
    using assms(3) Lcos_def by blast
  have "QCong l2" 
    using EqLTarski_def H1 QCong_def assms(2) by auto
  moreover have "QCong lp2" 
    using EqLTarski_def H1 QCong_def assms(1) by auto
  ultimately show ?thesis
    using EqLTarski_def H1 Lcos_def assms(1) assms(2) by auto
qed

lemma lcos_not_lg_null:
  assumes "Lcos lp l a"
  shows "¬ QCongNull lp" 
  using assms lcos_lg_not_null by blast

lemma lcos_const_o: 
  assumes "¬ Col A B P" and 
    "¬ QCongANullAcute a" and 
    "QCong l" and
    "QCong lp" and
    "QCongAAcute a" and
    "l A B" and
    "Lcos lp l a"
  shows "∃ C. A B OS C P ∧ a A B C ∧ lp B C" 
proof -
  obtain C' where "a A B C'" and "A B OS C' P" 
    using anga_const_o assms(1) assms(2) assms(5) by blast
  hence "C' ≠ B" 
    using os_distincts by blast
  have "A ≠ B" 
    using assms(1) not_col_distincts by auto
  have "¬ QCongNull lp" 
    using assms(7) lcos_lg_not_null by blast
  have "B ≠ C'" 
    using ‹C' ≠ B› by auto
  obtain lc' where "QCong lc'" and "lc' C' B" 
    using lg_exists by blast
  hence "¬ QCongNull l ∧ ¬ QCongNull lc'" 
    using ‹A ≠ B› ‹C' ≠ B› assms(3) assms(6) cong_identity lg_cong lg_null_instance by blast
  obtain C where "lp B C" and "B Out C C'"
    using ex_point_lg_out ‹C' ≠ B› ‹¬ QCongNull lp› assms(4) by metis
  have "A B OS C P" 
    using Out_cases ‹A B OS C' P› ‹B Out C C'› col_trivial_2 os_out_os by blast
  moreover have "a A B C" 
  proof (rule anga_out_anga [where ?A ="A" and ?C="C'"], simp_all add: assms(5) ‹a A B C'›)
    show "B Out A A" 
      by (simp add: ‹A ≠ B› out_trivial)
    show "B Out C' C" 
      by (simp add: ‹B Out C C'› l6_6)
  qed
  ultimately show ?thesis
    using ‹lp B C› by blast
qed

lemma flat_not_acute: 
  assumes "Bet A B C"
  shows "¬ Acute A B C" 
  using acute_not_bet assms by force

lemma acute_comp_not_acute: 
  assumes "Bet A B C" and
    "Acute A B D"
  shows "¬ Acute C B D" 
proof -
  {
    assume "Col A C D"
    moreover have "Bet A C D ⟶ ?thesis" 
      using assms(1) assms(2) between_exchange4 flat_not_acute by blast
    moreover 
    {
      assume "Bet C D A"
      have "Bet A B D ∨ Bet A D B" 
        using ‹Bet C D A› assms(1) between_symmetry l5_3 by blast
      moreover have "Bet A B D ⟶ ?thesis"
        using acute_not_bet assms(2) by force
      moreover have "Bet A D B ⟶ ?thesis" 
        using acute_not_bet acute_sym assms(1) between_exchange3 by blast        
      ultimately have ?thesis 
        by blast
    }
    moreover have "Bet D A C ⟶ ?thesis" 
      using acute_not_bet acute_sym assms(1) between_exchange2 by blast
    ultimately have ?thesis 
      using Col_def by blast
  }
  moreover
  {
    assume "¬ Col A C D"
    assume "Acute C B D" 
    obtain A0 B0 C0 where "Per A0 B0 C0" and "A B D LtA A0 B0 C0" 
      using Acute_def assms(2) by blast
    obtain A1 B1 C1 where "Per A1 B1 C1" and "C B D LtA A1 B1 C1" 
      using Acute_def ‹Acute C B D› by blast
    have "A ≠ B" 
      using ‹A B D LtA A0 B0 C0› lta_distincts by auto
    have "D ≠ B" 
      using ‹A B D LtA A0 B0 C0› lta_distincts by auto
    have "A0 ≠ B0" 
      using ‹A B D LtA A0 B0 C0› lta_distincts by blast
    have "C0 ≠ B0" 
      using ‹A B D LtA A0 B0 C0› lta_distincts by blast
    have "A1 ≠ B1"
      using ‹C B D LtA A1 B1 C1› lta_distincts by auto
    have "C1 ≠ B1" 
      using ‹C B D LtA A1 B1 C1› lta_distincts by blast
    have "A0 B0 C0 CongA A1 B1 C1" 
      by (simp add: ‹A0 ≠ B0› ‹A1 ≠ B1› ‹C0 ≠ B0› ‹C1 ≠ B1› ‹Per A0 B0 C0› 
          ‹Per A1 B1 C1› l11_16)
    have "C B D LtA A0 B0 C0" 
      using ‹A0 ≠ B0› ‹Acute C B D› ‹C0 ≠ B0› ‹Per A0 B0 C0› acute_per__lta by auto
    have "A ≠ C" 
      using ‹A ≠ B› assms(1) between_identity by blast
    have "Col A C B" 
      by (simp add: assms(1) bet_col col_permutation_5)
    obtain P where "A C Perp P B" and "A C OS D P" 
      using ‹¬ Col A C D› assms(1) bet_col l10_15 not_col_permutation_5 by blast
    have "A B Perp P B" 
      using ‹A C Perp P B› ‹A ≠ B› ‹Col A C B› perp_col by blast
    hence "B PerpAt B A P B" 
      using perp_left_comm perp_perp_in by blast
    hence "Per A B P" 
      by (simp add: perp_in_per_3)
    have "P ≠ B" 
      using ‹B PerpAt B A P B› perp_in_distinct by blast
    have "A B P CongA A0 B0 C0" 
      by (simp add: ‹A ≠ B› ‹A0 ≠ B0› ‹C0 ≠ B0› ‹P ≠ B› ‹Per A B P› ‹Per A0 B0 C0› l11_16)
    have "A B D CongA A B D" 
      by (simp add: ‹A ≠ B› ‹D ≠ B› conga_refl)
    moreover have "A0 B0 C0 CongA A B P" 
      using ‹A B P CongA A0 B0 C0› conga_sym by blast
    ultimately have "A B D LtA A B P" 
      by (simp add: ‹A B D LtA A0 B0 C0› conga_preserves_lta)
    have "C B D CongA C B D" 
      using ‹Acute C B D› acute_distincts conga_refl by blast
    hence "C B D LtA A B P" 
      using ‹A0 B0 C0 CongA A B P› ‹C B D LtA A0 B0 C0› conga_preserves_lta by auto
    have "A B D LeA A B P ⟷ C B P LeA C B D" 
      by (metis ‹A ≠ B› ‹Acute C B D› acute_not_bet assms(1) l11_36 not_bet_distincts)
    hence "C B P LeA C B D" 
      by (metis ‹A B D LtA A B P› ‹A ≠ B› ‹D ≠ B› ‹P ≠ B› lea123456_lta__lta lea_total nlta)
    have "Per C B P" 
      by (meson Col_cases PerpAt_def ‹B PerpAt B A P B› ‹Col A C B› col_trivial_1)
    hence "A B P CongA C B P" 
      using ‹A ≠ B› ‹C B D CongA C B D› ‹P ≠ B› ‹Per A B P› conga_diff45 l11_16 by blast
    have "C B P CongA A B P" 
      using ‹A B P CongA C B P› conga_sym_equiv by auto
    hence "A B P LeA C B D" 
      using ‹C B D CongA C B D› ‹C B P LeA C B D› l11_30 by blast
    hence False 
      using ‹C B D LtA A B P› lea__nlta by auto
  }
  ultimately show ?thesis
    by blast
qed

lemma lcos_per: 
  assumes "QCongAAcute a" and
    "QCong l" and 
    "QCong lp" and
    "Lcos lp l a" and
    "l A C" and
    "lp A B" and
    "a B A C"
  shows "Per A B C" 
proof (cases "B = C")
  case True
  thus ?thesis 
    by (simp add: l8_5)
next
  case False
  obtain A0 B0 C0 where "Per C0 B0 A0" and "lp A0 B0" and "l A0 C0" and "a B0 A0 C0" 
    using Lcos_def assms(4) by auto
  hence "B0 A0 C0 CongA B A C" 
    using anga_conga assms(1) assms(7) by blast
  have "Cong A0 C0 A C" 
    using ‹l A0 C0› assms(2) assms(5) lg_cong by auto
  have "Cong A0 B0 A B" 
    using ‹lp A0 B0› assms(3) assms(6) lg_cong by auto
  hence "Cong B0 C0 B C ∧ (B0 ≠ C0 ⟶ A0 B0 C0 CongA A B C ∧ A0 C0 B0 CongA A C B)" 
    using ‹B0 A0 C0 CongA B A C› ‹Cong A0 C0 A C› l11_49 by blast
  hence "B0 ≠ C0" 
    using False cong_reverse_identity by blast
  hence "A0 B0 C0 CongA A B C ∧ A0 C0 B0 CongA A C B" 
    by (simp add: ‹Cong B0 C0 B C ∧ (B0 ≠ C0 ⟶ A0 B0 C0 CongA A B C ∧ A0 C0 B0 CongA A C B)›)
  thus ?thesis 
    using Per_cases ‹Per C0 B0 A0› l11_17 by blast
qed

lemma is_null_anga_dec: 
  (*assumes "QCongAAcute a" *)
  shows "QCongANullAcute a ∨ ¬ QCongANullAcute a" 
  by blast

lemma lcos_lg:
  assumes "Lcos lp l a" and
    "A B Perp B C" and
    "a B A C" and
    "l A C"
  shows "lp A B"
proof -
  obtain A' B' C' where "Per C' B' A'" and "lp A' B'" and "l A' C'" and "a B' A' C'" 
    using assms(1) Lcos_def by force
  hence "Cong A C A' C'" 
    by (metis TarskiLen_def assms(1) assms(4) is_len_cong lcos_lg_anga)
  have "B A C CongA B' A' C'" 
    using anga_conga Lcos_def ‹a B' A' C'› assms(1) assms(3) by blast
  {
    assume "QCongANullAcute a"
    hence "QCongAAcute a ∧ (∀ A B C. (a A B C ⟶ B Out A C))" 
      using QCongANullAcute_def by simp
    hence "∀ A B C. a A B C ⟶ B Out A C" 
      by blast
    have "l EqLTarski lp" 
      using ‹QCongANullAcute a› assms(1) null_lcos_eql by blast
    have "A Out B C" 
      by (simp add: ‹∀A B C. a A B C ⟶ B Out A C› assms(3))
    have "B A Perp C B" 
      by (simp add: assms(2) perp_comm)
    hence "¬ Col B A C" 
      by (simp add: perp_not_col)
    hence False 
      using ‹A Out B C› not_col_permutation_4 out_col by blast
    hence ?thesis 
      by blast
  }
  moreover 
  {
    assume "¬ QCongANullAcute a" 
    have "A ≠ B" 
      using assms(2) perp_distinct by presburger
    have "A' ≠ B'" 
      using ‹B A C CongA B' A' C'› conga_diff1 conga_sym_equiv by blast
    have "C ≠ B" 
      using assms(2) perp_distinct by blast
    moreover 
    {
      assume "C' = B'" 
      have "QCongAAcute a" 
        using assms(1) Lcos_def by blast
      hence False
        by (metis ‹A' ≠ B'› ‹C' = B'› ‹¬ QCongANullAcute a› ‹a B' A' C'› 
            bet_out not_bet_distincts out_null_anga)
    }
    hence "C' ≠ B'" 
      by blast
    moreover have "B PerpAt A B B C" 
      by (simp add: assms(2) col_trivial_1 col_trivial_3 l8_14_2_1b_bis)
    hence "Per A B C" 
      using perp_in_per by blast
    moreover have "Per A' B' C'" 
      using Per_perm ‹Per C' B' A'› by blast
    ultimately have "A B C CongA A' B' C'" 
      by (simp add: ‹A ≠ B› ‹A' ≠ B'› l11_16)
    have "Cong C B C' B' ∧ Cong A B A' B' ∧ B C A CongA B' C' A'" 
    proof (rule l11_50_2, simp_all add: ‹A B C CongA A' B' C'›)
      {
        assume "Col C A B"
        have "B A Perp C B" 
          by (simp add: assms(2) perp_comm)
        hence False 
          using NCol_cases ‹Col C A B› perp_not_col by blast
      }
      thus "¬ Col C A B"
        by blast
      show "C A B CongA C' A' B'" 
        by (simp add: ‹B A C CongA B' A' C'› conga_comm)
      show "Cong C A C' A'" 
        using ‹Cong A C A' C'› not_cong_2143 by blast
    qed
    have "QCong lp" 
      using Lcos_def assms(1) by blast
    moreover have "lp A' B'" 
      using ‹lp A' B'› by auto
    moreover have "Cong A' B' A B" 
      using ‹Cong C B C' B' ∧ Cong A B A' B' ∧ B C A CongA B' C' A'› not_cong_3412 by blast
    ultimately have ?thesis 
      using lg_cong_lg by blast
  }
  ultimately show ?thesis 
    by blast
qed

lemma l13_7: 
  assumes "Lcos la l a" and
    "Lcos lb l b" and
    "Lcos lab la b" and
    "Lcos lba lb a"
  shows "lab EqLTarski lba" 
proof -
  have "QCong l" 
    using assms(1) lcos_lg_anga by blast
  have "QCong la" 
    using assms(1) lcos_lg_anga by blast
  have "QCongAAcute a" 
    using assms(4) lcos_lg_anga by blast
  have "QCong lb" 
    using assms(2) lcos_lg_anga by blast
  have "QCongAAcute b" 
    using assms(2) lcos_lg_anga by blast
  have "QCong lab" 
    using assms(3) lcos_lg_anga by blast
  have "QCong lba" 
    using assms(4) lcos_lg_anga by blast
  {
    assume "QCongANullAcute a"
    hence "lb EqLTarski lba" 
      using assms(4) null_lcos_eql by blast
    have "l EqLTarski la" 
      using ‹QCongANullAcute a› assms(1) null_lcos_eql by auto
    have "Lcos lab l b" 
      using EqLTarski_def‹l EqLTarski la› assms(3) by presburger
    have "lb EqLTarski lab" 
      using ‹Lcos lab l b› assms(2) l13_6 by auto
    hence ?thesis 
      by (meson ‹l EqLTarski la› ‹lb EqLTarski lba› assms(2) l13_6 lcos_eql_lcos)
  }
  moreover 
  {
    assume "¬ QCongANullAcute a"
    have "QCongANullAcute b ⟶ ?thesis" 
      by (meson assms(1) assms(2) assms(3) assms(4) l13_6 lcos_eql_lcos null_lcos_eql)
    moreover {
      assume "¬ QCongANullAcute b"
      obtain C A B where "la C A" and "l A B" and "a C A B" 
        using assms(1) lcos_const by blast
      have "C ≠ A ∧ B ≠ A" 
        by (metis ‹l A B› ‹la C A› assms(1) assms(3) lcos_const_ab lcos_lg_distincts)
      {
        assume "Col A B C"
        hence "Col C A B" 
          using Col_cases by blast
        hence "A Out C B ∧ QCongANullAcute a" 
          using anga_col_null ‹QCongAACute a› ‹a C A B› by blast
        hence False 
          using ‹¬ QCongANullAcute a› by blast
      }
      obtain P where "P C Reflect B A" 
        using l10_2_existence by blast
      hence "C P Reflect B A" 
        using l10_4 by blast
      moreover have "¬ Col B A C" 
        using ‹Col A B C ⟹ False› col_permutation_4 by blast
      ultimately have "¬ Col B A P" 
        using osym_not_col by blast
      have "l B A" 
        by (simp add: ‹QCong l› ‹l A B› lg_sym)
      have "∃ D. B A OS D P ∧ b B A D ∧ lb A D" 
        using lcos_const_o [where ?l = "l"] ‹¬ Col B A P› ‹¬ QCongANullAcute b›
          ‹QCong l› ‹QCong lb› ‹QCongAACute b› ‹l B A› assms(2) by simp
      then obtain D where "B A OS D P" and "b B A D" and "lb A D" 
        by blast
      have "P ≠ C" 
        using Col_cases ‹C P Reflect B A› ‹Col A B C ⟹ False› l10_8 by blast
      hence "B A TS P C" 
        using l10_14 ‹C ≠ A ∧ B ≠ A› ‹P C Reflect B A› by simp
      have "B A OS P D" 
        by (simp add: ‹B A OS D P› one_side_symmetry)
      hence "B A TS D C" 
        using l9_8_2 [where ?A = "P"] ‹B A TS P C› by blast
      have "la A C" 
        by (simp add: ‹QCong la› ‹la C A› lg_sym)
      hence "Per A C B" 
        using lcos_per ‹QCong l› ‹QCong la› ‹QCongAACute a› ‹a C A B› ‹l A B› 
          assms(1) by blast
      have "b D A B" 
        using anga_sym ‹QCongAACute b› ‹b B A D› by auto
      hence "Per A D B"  using lcos_per 
        using ‹QCong l› ‹QCong lb› ‹QCongAACute b› ‹l A B› ‹lb A D› assms(2) by blast
      {
        assume "Col C D A"
        hence "Per B C D" 
          using ‹B A TS D C› ‹Per A C B› ‹Per A D B› col_permutation_3 
            per2_preserves_diff ts_distincts by blast
        have "Per B D C" 
          using ‹B A TS D C› ‹Col C D A› ‹Per A C B› ‹Per A D B› not_col_permutation_1 
            per2_preserves_diff ts_distincts by blast
        have "C = D" 
          using ‹Per B C D› ‹Per B D C› l8_7 by blast
        then obtain T where "Col T B A" and "Bet C T C" 
          using ‹B A TS D C› ts_distincts by blast
        hence "C = T" 
          using between_identity by blast
        hence False 
          using ‹B A TS D C› ‹C = D› ts_distincts by blast
      }
      obtain E where "Col C D E" and "C D Perp A E" 
        using ‹Col C D A ⟹ False› l8_18_existence by blast
      have "B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D" 
      proof (rule l13_2, simp_all add: ‹Col C D E›)
        show "A B TS C D" 
          using ‹B A TS D C› invert_two_sides l9_2 by blast
        show "Per B C A" 
          using Per_perm ‹Per A C B› by blast
        show "Per B D A" 
          using Per_cases ‹Per A D B› by blast
        show "A E Perp C D" 
          using Perp_perm ‹C D Perp A E› by blast
      qed
      hence "a D A E" 
        using anga_conga_anga ‹QCongAACute a› ‹a C A B› conga_left_comm by blast
      have "b C A E" 
        using anga_conga_anga ‹B A C CongA D A E ∧ B A D CongA C A E ∧ Bet C E D› 
          ‹QCongAACute b› ‹b B A D› by blast
      have "C E Perp A E"
      proof (rule perp_col [where ?B = "D"])
        {
          assume "C = E"
          {
            fix A0 B0 C0
            assume "b A0 B0 C0"
            hence "A0 B0 C0 CongA C A C" 
              using anga_conga ‹C = E› ‹QCongAACute b› ‹b C A E› by blast
            have "A Out C C" 
              by (simp add: ‹C ≠ A ∧ B ≠ A› out_trivial)
            hence "B0 Out A0 C0" 
              using l11_21_a ‹A0 B0 C0 CongA C A C› conga_sym_equiv by blast
          }
          hence "QCongANullAcute b" 
            using  ‹QCongAACute b› QCongANullAcute_def by blast
        }
        thus "C ≠ E" 
          using ‹¬ QCongANullAcute b› by blast
        show "C D Perp A E" 
          by (simp add: ‹C D Perp A E›)
        show "Col C D E"
          by (simp add: ‹Col C D E›)
      qed
      have "lab A E" 
      proof (rule lcos_lg [where ?l = "la" and ?a = "b" and ?C = "C"])
        show " Lcos lab la b" 
          by (simp add: assms(3))
        show "A E Perp E C" 
          using Perp_perm ‹C E Perp A E› by blast
        show "b E A C" using anga_sym 
          using ‹QCongAACute b› ‹b C A E› by auto
        show "la A C" 
          using lg_sym by (simp add: ‹la A C›)
      qed
      have "D E Perp A E" 
      proof (rule perp_col [where ?B = "C"]) 
        {
          assume "D = E"
          {
            fix A0 B0 C0
            assume "a A0 B0 C0"
            have "A0 B0 C0 CongA D A D" 
              using anga_conga ‹D = E› ‹a A0 B0 C0› ‹a D A E› ‹QCongAACute a› by blast
            have "B0 Out A0 C0" 
            proof (rule l11_21_a [where ?A="D" and ?B="A" and ?C="D"])
              show "A Out D D" 
                using ‹Col C D A ⟹ False› ‹Col C D E› ‹D = E› out_trivial by force
              show "D A D CongA A0 B0 C0" 
                by (simp add: ‹A0 B0 C0 CongA D A D› conga_sym)
            qed
          }
          hence "QCongANullAcute a" 
            using ‹QCongAACute a› QCongANullAcute_def by blast
          hence False 
            using ‹¬ QCongANullAcute a› by blast
        }
        thus "D ≠ E" 
          by blast
        show "D C Perp A E" 
          using Perp_cases ‹C D Perp A E› by blast
        show "Col D C E"
          using ‹Col C D E› not_col_permutation_4 by blast
      qed
      have "lba A E" 
      proof (rule lcos_lg [where ?a="a" and ?l = "lb" and ?C="D"], 
          simp_all add: assms(4) ‹lb A D›)
        show "A E Perp E D" 
          using Perp_cases ‹D E Perp A E› by blast
        show "a E A D" 
          using ‹a D A E› anga_sym ‹QCongAACute a› by blast
      qed
      hence "lab EqLTarski lba"  
        using ‹QCong lab› ‹QCong lba› ‹lab A E› assms(3) ex_eqL l13_6 by blast
    }
    ultimately have ?thesis 
      by blast
  }
  ultimately show ?thesis
    by blast
qed

lemma out_acute: 
  assumes "B Out A C" 
  shows "Acute A B C" 
proof -
  have "A ≠ B ∧ C ≠ B" 
    using assms out_distinct by auto
  then obtain Q where "¬ Col A B Q" 
    using not_col_exists by blast
  then obtain P where "A B Perp P B" and "A B OS Q P"
    using l10_15 not_col_distincts by blast
  hence "Per P B A" 
    using Perp_perm perp_per_1 by blast
  hence "Per A B P" 
    using l8_2 by blast
  moreover have "A B C LtA A B P" 
  proof -
    have "A B C LeA A B P" 
      using ‹A B Perp P B› ‹A ≠ B ∧ C ≠ B› assms l11_31_1 perp_not_eq_2 by auto
    moreover have "¬ A B C CongA A B P" 
      by (metis Col_def Out_def ‹A B OS Q P› ‹Per P B A› assms col124__nos l11_21_a 
          l8_20_1_R1 l8_6)
    ultimately show ?thesis 
      using LtA_def by blast
  qed
  ultimately show ?thesis 
    using Acute_def by blast
qed

lemma perp_acute: 
  assumes "Col A C P" and
    "P PerpAt B P A C" 
  shows "Acute A B P" 
proof (cases "Col P A B")
  case True
  thus ?thesis 
    by (metis acute_trivial assms(2) l8_14_2_1b not_col_distincts 
        not_col_permutation_2 perp_in_distinct)
next
  case False
  have "Per A P B" 
    using PerpAt_def assms(2) col_trivial_1 l8_2 by presburger
  thus ?thesis using l11_43 
    by (metis False acute_sym col_trivial_1 col_trivial_3)
qed

lemma null_lcos: 
  assumes "QCong l" and 
    "¬ QCongNull l" and
    "QCongANullAcute a"
  shows "Lcos l l a" 
proof -
  obtain A B C where "a A B C" 
    using ex_points_anga QCongANullAcute_def assms(3) by presburger
  hence "B Out A C" 
    using assms(3) is_null_anga_out by auto
  hence "A ≠ B" 
    by (simp add: out_distinct)
  obtain A' B' where "l A' B'" 
    using assms(1) ex_points_lg by blast
  obtain P where "l B P" and "B Out P A" 
    using ex_point_lg_out ‹A ≠ B› assms(1) assms(2) by metis
  moreover have "Per P P B" 
    by (simp add: l8_20_1_R1)
  moreover have "a P B P" 
    by (metis assms(1) assms(2) assms(3) calculation(1) is_null_all lg_null_trivial)
  ultimately show ?thesis 
    using Lcos_def QCongANullAcute_def assms(1) assms(3) by auto
qed

lemma lcos_exists:
  assumes "QCongAAcute a" and
    "QCong l" and
    "¬ QCongNull l"
  shows "∃ lp. Lcos lp l a" 
proof (cases "QCongANullAcute a")
  case True
  thus ?thesis 
    using assms(2) assms(3) null_lcos by blast
next
  case False
  obtain A B where "l A B" 
    using assms(2) ex_points_lg by presburger
  obtain C where "a A B C" 
    by (metis QCongNull_def ‹l A B› anga_const assms(1) assms(2) assms(3))
  {
    assume "Col B C A"
    hence "B Out A C ∧ QCongANullAcute a" 
      using ‹a A B C› anga_col_out assms(1) col_permutation_2 out_null_anga by blast
    hence False 
      using False by blast
  }
  hence "¬ Col B C A" 
    by blast
  then obtain P where "Col B C P" and "B C Perp A P" 
    using l8_18_existence by blast
  obtain lp where "QCong lp" and "lp B P" 
    using lg_exists by fastforce
  obtain A' B' C' where "Acute A' B' C'" and "∀ X Y Z. A' B' C' CongA X Y Z ⟷ a X Y Z"
    using QCongAAcute_def assms(1) by metis
  hence "A' B' C' CongA A B C" 
    using ‹a A B C› by auto
  hence "A B C CongA A' B' C'" 
    using not_conga_sym by blast
  moreover have "C' InAngle A' B' C'" 
    using ‹Acute A' B' C'› acute_distincts inangle3123 by blast
  ultimately have "A B C LeA A' B' C'" 
    by (simp add: conga__lea)
  hence "Acute A B C" 
    using ‹Acute A' B' C'› acute_lea_acute by blast
  have "B P Perp P A" 
  proof (rule perp_col [where ?B = "C"], simp_all add:‹Col B C P›)
    {
      assume "B = P"
      hence "Per A B C" 
        using ‹B C Perp A P› l8_2 perp_per_1 by blast
      moreover have "¬ Per A B C" 
        using ‹Acute A B C› by (simp add: acute_not_per)
      ultimately have False 
        by simp
    }
    thus "B ≠ P" 
      by blast
    show "B C Perp P A" 
      using Perp_perm ‹B C Perp A P› by blast
  qed
  hence "Per A P B" 
    using Perp_cases perp_per_1 by blast
  moreover have "lp B P" 
    using ‹lp B P› by blast
  moreover have "l B A" 
    by (simp add: ‹l A B› assms(2) lg_sym)
  moreover have "a A B P" 
  proof (rule anga_out_anga [where ?A="A" and ?C="C"], simp_all add:‹a A B C›)
    show "QCongAACute a" 
      by (simp add: assms(1))
    show "B Out A A" 
      by (metis ‹¬ Col B C A› col_trivial_3 out_trivial)
    show "B Out C P"
    proof (rule perp_acute_out [where ?C="A"])
      show "Acute C B A" 
        by (simp add: ‹Acute A B C› acute_sym)
      show "C B Perp A P" 
        using Perp_perm ‹B C Perp A P› by blast
      show "Col C B P" 
        using ‹Col B C P› not_col_permutation_4 by blast
    qed
  qed
  hence "a P B A" 
    using anga_sym assms(1) by blast
  ultimately show ?thesis 
    using Lcos_def ‹⋀thesis. (⋀lp. ⟦QCong lp; lp B P⟧ ⟹ thesis) ⟹ thesis› 
      assms(1) assms(2) by fastforce
qed

lemma lcos_uniqueness: 
  assumes "Lcos l1 l a" and
    "Lcos l2 l a"
  shows "l1 EqLTarski l2" 
  using assms(1) assms(2) l13_6 by blast

lemma lcos_eqa_lcos: 
  assumes "Lcos lp l a" and
    "a EqA b"
  shows "Lcos lp l b"
proof -
  have "Lcos lp l a" 
    using lcos_lg_anga assms(1) by blast
  have "QCong l" 
    using lcos_lg_anga assms(1) by blast
  have "QCong lp" 
    using lcos_lg_anga assms(1) by blast
  have "QCongAAcute a" 
    using lcos_lg_anga assms(1) by blast
  have "∀ A B C. a A B C ⟷ b A B C" 
    using EqA_def assms(2) by presburger
  have "QCongA a" using anga_is_ang 
    by (simp add: ‹QCongAACute a›)
  have "QCongA b" 
    using eqA_preserves_ang ‹QCongA a› assms(2) by blast
  have "QCongAAcute b" 
    using eqA_preserves_anga ‹QCongAACute a› assms(2) by blast
  obtain A B C where "Per C B A" and "lp A B" and "l A C" and "a B A C" 
    using Lcos_def assms(1) by auto
  thus ?thesis 
    using ‹∀A B C. a A B C = b A B C› assms(1) by presburger
qed

lemma lcos_eq_refl:
  assumes "QCong la" and
    "¬ QCongNull la" and
    "QCongAAcute a"
  shows "EqLcos la a la a"
proof -
  obtain lp where "Lcos lp la a" 
    using lcos_exists assms(1) assms(2) assms(3) by blast
  thus ?thesis
    using EqLcos_def by blast
qed

lemma lcos_eq_sym:
  assumes "EqLcos la a lb b"
  shows "EqLcos lb b la a" 
proof -
  obtain lp where "Lcos lp la a" and "Lcos lp lb b" 
    using EqLcos_def assms(1) by blast
  thus ?thesis
    using EqLcos_def by blast
qed

lemma lcos_eq_trans:
  assumes "EqLcos la a lb b" and
    "EqLcos lb b lc c"
  shows "EqLcos la a lc c" 
proof -
  obtain lab where "Lcos lab la a" and "Lcos lab lb b" 
    using EqLcos_def assms(1) by blast
  obtain lbc where "Lcos lbc lb b" and "Lcos lbc lc c" 
    using EqLcos_def assms(2) by blast
  hence "lab EqLTarski lbc" 
    using ‹Lcos lab lb b› lcos_uniqueness by auto
  hence "Lcos lbc la a" 
    by (metis EqLTarski_def ‹Lcos lab la a› lcos_eql_lcos)
  thus ?thesis 
    using EqLcos_def ‹Lcos lbc lc c› by blast
qed

lemma lcos2_comm:
  assumes "Lcos2 lp l a b"
  shows "Lcos2 lp l b a" 
proof -
  obtain la where "Lcos la l a" and "Lcos lp la b" 
    using Lcos2_def assms(1) by blast
  hence "¬ QCongNull la ∧ ¬ QCongNull l" 
    using lcos_lg_not_null by blast
  then obtain lb where "Lcos lb l b" 
    using lcos_exists ‹Lcos la l a› ‹Lcos lp la b› lcos_lg_anga by blast
  moreover 
  obtain lp' where "Lcos lp' lb a" 
    by (meson ‹Lcos la l a› calculation lcos_exists lcos_lg_anga lcos_not_lg_null)
  hence "Lcos lp lb a"     
    by (meson ‹Lcos la l a› ‹Lcos lp la b› calculation l13_6 l13_7 lcos_eql_lcos)
  ultimately show ?thesis
    using Lcos2_def by blast
qed

lemma lcos2_exists:
  assumes "QCong l" and
    "¬ QCongNull l" and
    "QCongAAcute a" and
    "QCongAAcute b" 
  shows "∃ lp. Lcos2 lp l a b" 
proof -
  obtain la where "Lcos la l a" 
    using assms(1) assms(2) assms(3) lcos_exists by blast
  hence "¬ QCongNull la ∧ ¬ QCongNull l" 
    using lcos_lg_not_null by blast
  then obtain lab where "Lcos lab la b" 
    using ‹Lcos la l a› assms(4) lcos_exists lcos_lg_anga by blast
  thus ?thesis 
    using Lcos2_def ‹Lcos la l a› by blast
qed

lemma lcos2_exists': 
  assumes "QCong l" and
    "¬ QCongNull l" and
    "QCongAAcute a" and
    "QCongAAcute b"
  shows "∃ la lab. Lcos la l a ∧ Lcos lab la b" 
proof -
  obtain la where "Lcos la l a" 
    using assms(1) assms(2) assms(3) lcos_exists by blast
  hence "¬ QCongNull la ∧ ¬ QCongNull l" 
    using lcos_lg_not_null by blast
  then obtain lab where "Lcos lab la b" 
    using ‹Lcos la l a› assms(4) lcos_exists lcos_lg_anga by blast
  thus ?thesis 
    using ‹Lcos la l a› by blast
qed

lemma lcos2_eq_refl: 
  assumes "QCong l" and
    "¬ QCongNull l" and
    "QCongAAcute a" and
    "QCongAAcute b" 
  shows "EqLcos2 l a b l a b" 
  by (simp add: EqLcos2_def assms(1) assms(2) assms(3) assms(4) lcos2_exists)

lemma lcos2_eq_sym: 
  assumes "EqLcos2 l1 a b l2 c d"
  shows "EqLcos2 l2 c d l1 a b" 
  using EqLcos2_def assms by auto

lemma lcos2_uniqueness: 
  assumes "Lcos2 l1 l a b" and
    "Lcos2 l2 l a b"
  shows "l1 EqLTarski l2" 
  by (meson Lcos2_def assms(1) assms(2) l13_7 lcos2_comm)

lemma lcos2_eql_lcos2:
  assumes "Lcos2 la lla a b" and
    "lla EqLTarski llb" and
    "la EqLTarski lb"
  shows "Lcos2 lb llb a b" 
  by (meson Lcos2_def assms(1) assms(2) assms(3) l13_6 lcos_eql_lcos)

lemma lcos2_lg_anga: 
  assumes "Lcos2 lp l a b" 
  shows "Lcos2 lp l a b ∧ QCong lp ∧ QCong l ∧ QCongAAcute a ∧ QCongAAcute b" 
  using Lcos2_def assms lcos_lg_anga by blast

lemma lcos2_eq_trans: 
  assumes "EqLcos2 l1 a b l2 c d" and
    "EqLcos2 l2 c d l3 e f" 
  shows "EqLcos2 l1 a b l3 e f" 
proof -
  obtain lp where "Lcos2 lp l1 a b" and "Lcos2 lp l2 c d" 
    using EqLcos2_def assms(1) by blast
  obtain lq where "Lcos2 lq l2 c d" and "Lcos2 lq l3 e f" 
    using EqLcos2_def assms(2) by blast
  have "lp EqLTarski lq" 
    using ‹Lcos2 lp l2 c d› ‹Lcos2 lq l2 c d› lcos2_uniqueness by auto
  thus ?thesis 
    by (metis EqLTarski_def EqLcos2_def ‹Lcos2 lp l1 a b› ‹Lcos2 lq l3 e f› lcos2_eql_lcos2)
qed

lemma lcos_eq_lcos2_eq: 
  assumes "QCongAAcute c" and
    "EqLcos la a lb b"
  shows "EqLcos2 la a c lb b c" 
proof -
  obtain lp where "Lcos lp la a" and "Lcos lp lb b" 
    using EqLcos_def assms(2) by blast
  hence "¬ QCongNull lp ∧ ¬ QCongNull la" 
    using lcos_lg_not_null by blast
  then obtain lq where "Lcos lq lp c" 
    using lcos_exists lcos_lg_anga ‹Lcos lp la a› assms(1) by blast
  have "Lcos2 lq la a c" 
    using Lcos2_def ‹Lcos lp la a› ‹Lcos lq lp c› by blast
  moreover have "Lcos2 lq lb b c" 
    using Lcos2_def ‹Lcos lp lb b› ‹Lcos lq lp c› by blast
  ultimately show ?thesis
    using EqLcos2_def by blast
qed

lemma lcos2_lg_not_null:
  assumes "Lcos2 lp l a b" 
  shows "¬ QCongNull l ∧ ¬ QCongNull lp"
proof -
  obtain la where "Lcos la l a" and "Lcos lp la b" 
    using assms(1) Lcos2_def by auto
  thus ?thesis
    using lcos_lg_not_null by blast
qed

lemma lcos3_lcos_1_2_a: 
  assumes "Lcos3 lp l a b c"
  shows "∃ la. Lcos la l a ∧ Lcos2 lp la b c" 
  using Lcos2_def Lcos3_def assms by presburger

lemma lcos3_lcos_1_2_b: 
  assumes "∃ la. Lcos la l a ∧ Lcos2 lp la b c" 
  shows "Lcos3 lp l a b c" 
  using Lcos2_def Lcos3_def assms by blast

lemma lcos3_lcos_1_2: 
  shows "Lcos3 lp l a b c ⟷ (∃ la. Lcos la l a ∧ Lcos2 lp la b c)" 
  using lcos3_lcos_1_2_a lcos3_lcos_1_2_b by blast

lemma lcos3_lcos_2_1_a:
  assumes "Lcos3 lp l a b c"
  shows "∃ lab. Lcos2 lab l a b ∧ Lcos lp lab c" 
  using Lcos2_def assms lcos3_lcos_1_2 by auto

lemma lcos3_lcos_2_1_b:
  assumes "∃ lab. Lcos2 lab l a b ∧ Lcos lp lab c" 
  shows "Lcos3 lp l a b c" 
  using Lcos2_def Lcos3_def assms by blast

lemma lcos3_lcos_2_1:
  shows "Lcos3 lp l a b c ⟷ (∃ lab. Lcos2 lab l a b ∧ Lcos lp lab c)" 
  using lcos3_lcos_2_1_a lcos3_lcos_2_1_b by blast

lemma lcos3_permut3:
  assumes "Lcos3 lp l a b c"
  shows "Lcos3 lp l b a c" 
proof -
  have "Lcos3 lp l a b c ⟷ (∃ lab. Lcos2 lab l a b ∧ Lcos lp lab c)"
    by (simp add: lcos3_lcos_2_1)
  then obtain lab where "Lcos2 lab l a b" and "Lcos lp lab c" 
    using assms by blast
  thus ?thesis 
    using lcos2_comm lcos3_lcos_2_1_b by blast
qed

lemma lcos3_permut1: 
  assumes "Lcos3 lp l a b c"
  shows "Lcos3 lp l a c b" 
proof -
  have "Lcos3 lp l a b c ⟷ (∃ lab. Lcos2 lab l a b ∧ Lcos lp lab c)"
    by (simp add: lcos3_lcos_2_1)
  then obtain la where "Lcos la l a" and "Lcos2 lp la b c" 
    using assms lcos3_lcos_1_2_a by blast
  thus ?thesis 
    using lcos2_comm lcos3_lcos_1_2_b by blast
qed

lemma lcos3_permut2: 
  assumes "Lcos3 lp l a b c"
  shows "Lcos3 lp l c b a" 
  using assms lcos3_permut1 lcos3_permut3 by blast

lemma lcos3_exists: 
  assumes "QCong l" and
    "¬ QCongNull l" and
    "QCongAAcute a" and
    "QCongAAcute b" and
    "QCongAAcute c" 
  shows "∃ lp. Lcos3 lp l a b c" 
proof -
  obtain la where "Lcos la l a" 
    using assms(1) assms(2) assms(3) lcos2_exists' by blast
  hence "¬ QCongNull la ∧ ¬ QCongNull l" 
    using lcos_lg_not_null by blast
  then obtain lab where "Lcos lab la b" 
    using ‹Lcos la l a› assms(4) lcos_exists lcos_lg_anga by blast
  hence "¬ QCongNull lab ∧ ¬ QCongNull la" 
    using lcos_lg_not_null by blast
  then obtain lp where "Lcos lp lab c" 
    using ‹Lcos lab la b› assms(5) lcos2_exists' lcos_lg_anga by blast
  thus ?thesis 
    by (meson ‹Lcos la l a› assms(4) lcos2_exists lcos3_lcos_1_2 
        lcos_lg_anga lcos_not_lg_null)
qed

lemma lcos3_eq_refl:
  assumes "QCong l" and
    "¬ QCongNull l" and
    "QCongAAcute a" and
    "QCongAAcute b" and
    "QCongAAcute c"
  shows "EqLcos3 l a b c l a b c" 
  by (simp add: EqLcos3_def assms(1) assms(2) assms(3) assms(4) assms(5) lcos3_exists)

lemma lcos3_eq_sym:
  assumes "EqLcos3 l1 a b c l2 d e f"
  shows "EqLcos3 l2 d e f l1 a b c" 
  using EqLcos3_def assms by auto

lemma lcos3_uniqueness: 
  assumes "Lcos3 l1 l a b c" and
    "Lcos3 l2 l a b c"
  shows "l1 EqLTarski l2" 
proof -
  obtain la lab where "Lcos la l a" and "Lcos lab la b" and "Lcos l1 lab c" 
    using Lcos3_def assms(1) by blast
  obtain la' lab' where "Lcos la' l a" and "Lcos lab' la' b" and "Lcos l2 lab' c" 
    using Lcos3_def assms(2) by blast
  have "la EqLTarski la'" 
    using ‹Lcos la l a› ‹Lcos la' l a› lcos_uniqueness by auto
  have "Lcos lab' la b" 
    by (meson ‹Lcos la l a› ‹Lcos la' l a› ‹Lcos lab' la' b› l13_6 lcos_eql_lcos)
  have "lab EqLTarski lab'" 
    using ‹Lcos lab la b› ‹Lcos lab' la b› l13_6 by auto
  thus ?thesis 
    using ‹Lcos l1 lab c› ‹Lcos l2 lab' c› lcos_eql_lcos lcos_uniqueness by blast
qed

lemma lcos3_eql_lcos3: 
  assumes "Lcos3 la lla a b c" and
    "lla EqLTarski llb" and
    "la EqLTarski lb"
  shows "Lcos3 lb llb a b c" 
proof -
  obtain lpa lpab where "Lcos lpa lla a" and "Lcos lpab lpa b" and "Lcos la lpab c" 
    using Lcos3_def assms(1) by blast
  thus ?thesis
    by (meson Lcos3_def assms(2) assms(3) lcos_eql_lcos lcos_uniqueness)
qed

lemma lcos3_lg_anga: 
  assumes "Lcos3 lp l a b c" 
  shows "Lcos3 lp l a b c ∧ QCong lp ∧ QCong l ∧ QCongAAcute a ∧ QCongAAcute b ∧ QCongAAcute c" 
proof -
  obtain la lab where "Lcos la l a" and "Lcos lab la b" and "Lcos lp lab c" 
    using Lcos3_def assms(1) by blast
  thus ?thesis
    using assms lcos_lg_anga by blast
qed

lemma lcos3_lg_not_null: 
  assumes "Lcos3 lp l a b c"
  shows "¬ QCongNull l ∧ ¬ QCongNull lp" 
proof -
  obtain la lab where "Lcos la l a" and "Lcos lab la b" and "Lcos lp lab c" 
    using Lcos3_def assms(1) by blast
  thus ?thesis 
    using lcos_lg_not_null by blast
qed

lemma lcos3_eq_trans:
  assumes "EqLcos3 l1 a b c l2 d e f" and
    "EqLcos3 l2 d e f l3 g h i"
  shows "EqLcos3 l1 a b c l3 g h i" 
proof -
  obtain lp where "Lcos3 lp l1 a b c" and "Lcos3 lp l2 d e f" 
    using EqLcos3_def assms(1) by blast
  obtain lq where "Lcos3 lq l2 d e f" and "Lcos3 lq l3 g h i" 
    using EqLcos3_def assms(2) by blast
  thus ?thesis
    by (metis EqLTarski_def EqLcos3_def ‹Lcos3 lp l1 a b c› ‹Lcos3 lp l2 d e f›
        lcos3_eql_lcos3 lcos3_uniqueness)
qed

lemma lcos_eq_lcos3_eq: 
  assumes "QCongAAcute c" and
    "QCongAAcute d" and
    "EqLcos la a lb b"
  shows "EqLcos3 la a c d lb b c d" 
proof -
  obtain lp where "Lcos lp la a" and "Lcos lp lb b"
    using EqLcos_def assms(3) by blast
  hence "¬ QCongNull lp ∧ ¬ QCongNull la" 
    using lcos_lg_not_null by blast
  then obtain lq where "Lcos lq lp c" 
    using lcos_exists ‹Lcos lp lb b› assms(1) lcos_lg_anga by blast
  hence "¬ QCongNull lq ∧ ¬ QCongNull lp" 
    using lcos_lg_not_null by blast
  then obtain lm where "Lcos lm lq d" 
    using lcos_exists ‹Lcos lq lp c› assms(2) lcos_lg_anga by blast
  thus ?thesis
    using EqLcos3_def Lcos3_def ‹Lcos lp la a› ‹Lcos lp lb b› ‹Lcos lq lp c› by blast
qed

lemma lcos2_eq_lcos3_eq: 
  assumes "QCongAAcute e" and
    "EqLcos2 la a b lb c d"
  shows "EqLcos3 la a b e lb c d e" 
proof -
  obtain lp where "Lcos2 lp la a b" and "Lcos2 lp lb c d"
    using EqLcos2_def assms(2) by blast
  hence "¬ QCongNull la ∧ ¬ QCongNull lp" 
    using lcos2_lg_not_null by blast
  then obtain lq where "Lcos lq lp e" 
    using lcos_exists ‹Lcos2 lp la a b› assms(1) lcos2_lg_anga by blast
  hence "¬ QCongNull lq ∧ ¬ QCongNull lp" 
    using lcos_lg_not_null by blast
  have "Lcos3 lq la a b e" 
    using ‹Lcos lq lp e› ‹Lcos2 lp la a b› lcos3_lcos_2_1 by blast
  moreover have "Lcos3 lq lb c d e" 
    using ‹Lcos lq lp e› ‹Lcos2 lp lb c d› lcos3_lcos_2_1 by auto
  ultimately show ?thesis 
    using EqLcos3_def by blast
qed

lemma projp_id:
  assumes "P P' Projp A B" and 
    "P Q' Projp A B" 
  shows "P' = Q'" 
proof -
  have "Col A B P' ∧ A B Perp P P' ⟶ ?thesis" 
    by (metis Projp_def assms(2) l8_18_uniqueness perp_not_col2)
  moreover have "Col A B P ∧ P = P' ⟶ ?thesis" 
    by (metis Projp_def assms(2) perp_not_col2)
  ultimately show ?thesis 
    using Projp_def assms(1) by force
qed

lemma projp_idem:
  assumes "P P' Projp A B" 
  shows "P' P' Projp A B" 
  using Projp_def assms by force

lemma col_projp_eq: 
  assumes "Col A B P" and
    "P P' Projp A B"
  shows "P = P'" 
  by (meson Projp_def assms(1) assms(2) perp_not_col2)

lemma projp_col:
  assumes "P P' Projp A B"
  shows "Col A B P'" 
  using Projp_def assms by force

  (* Gabriel Braun March 2013 *)

lemma project_id:
  assumes "P P' Proj A B X Y" and
    "Col A B P"
  shows "P = P'" 
proof -
  {
    assume "P P' Par X Y"
    have "P' = A ⟶ A B Par X Y" 
      by (metis Proj_def ‹P P' Par X Y› assms(1) assms(2) not_col_permutation_5 
          par_col_par_2 par_left_comm)
    moreover 
    {
      assume "P' ≠ A"
      have "Col P' P A" 
        by (metis Proj_def assms(1) assms(2) col3 not_col_distincts)
      moreover have "P' P Par X Y" 
        by (simp add: ‹P P' Par X Y› par_left_comm)
      ultimately have "A P' Par X Y" 
        using ‹P' ≠ A› par_col_par_2 par_left_comm by presburger
      hence "A B Par X Y" 
        by (metis Proj_def assms(1) not_col_permutation_5 par_col_par_2)
    }
    ultimately have "A B Par X Y" 
      by blast
    hence False     
      using Proj_def assms(1) by force
  }
  thus ?thesis 
    using Proj_def assms(1) by force
qed

lemma project_not_id:
  assumes "P P' Proj A B X Y" and
    "¬ Col A B P"
  shows "P ≠ P'" 
  using Proj_def assms(1) assms(2) by force

lemma project_col: 
  assumes "P P Proj A B X Y"
  shows "Col A B P" 
  using assms project_not_id by blast

lemma project_not_col: 
  assumes "P P' Proj A B X Y" and
    "P ≠ P'"
  shows "¬ Col A B P" 
  using assms(1) assms(2) project_id by blast

lemma par_col_project:
  assumes "A ≠ B" and
    "¬ A B Par X Y" and
    "P P' Par X Y" and
    "Col A B P'"
  shows "P P' Proj A B X Y" 
  using Proj_def assms(1) assms(2) assms(3) assms(4) par_neq2 by presburger

lemma cong_conga3_cong3:
  assumes "¬ Col A B C" and
    "Cong A B A' B'" and
    "A B C CongA3 A' B' C'"
  shows "A B C Cong3 A' B' C'" 
  using CongA3_def assms(1) assms(2) assms(3) l11_50_2  Cong3_def by blast

lemma project_par_dir: 
  assumes "P ≠ P'" and
    "P P' Proj A B X Y"
  shows "P P' Par X Y" 
  using Proj_def assms(1) assms(2) by presburger

lemma project_idem: 
  assumes "P P' Proj A B X Y"
  shows "P' P' Proj A B X Y" 
  using Proj_def assms by force

lemma perp_projp:
  assumes "P' PerpAt A B P P'"
  shows "P P' Projp A B" 
proof -
  have "A ≠ B" 
    using assms perp_in_distinct by auto
  moreover have "Col A B P'" 
    using assms perp_in_col by blast
  moreover have "A B Perp P P'"     
    using assms perp_in_perp by auto
  ultimately show ?thesis
    using Projp_def by blast
qed

lemma proj_distinct:
  assumes "P P' Projp A B"
  shows "P' ≠ A ∨ P' ≠ B" 
proof -
  have "Col A B P' ∧ A B Perp P P' ⟶ ?thesis" 
    using perp_distinct by blast
  moreover have "Col A B P ∧ P = P' ⟶ ?thesis" 
    using Projp_def assms by presburger
  ultimately show ?thesis 
    using Projp_def assms by auto
qed

lemma l13_10_aux1:
  assumes "Col PO A B" and
    "Col PO P Q" and
    "PO P Perp P A" and
    "PO Q Perp Q B" and
    "QCong la" and 
    "QCong lb" and
    "QCong lp" and
    "QCong lq" and
    "la PO A" and
    "lb PO B" and
    "lp PO P" and
    "lq PO Q"
  shows "∃ a. QCongAAcute a ∧ Lcos lp la a ∧ Lcos lq lb a" 
proof -
  have "Acute A PO P" 
  proof (rule perp_acute [where ?C="P"])
    show "Col A P P" 
      using col_trivial_2 by auto
    show "P PerpAt PO P A P" 
      by (simp add: assms(3) col_trivial_2 l8_15_1 perp_right_comm)
  qed
  have "P ≠ PO" 
    using assms(3) perp_distinct by blast
  have "A ≠ PO" 
    using ‹Acute A PO P› acute_distincts by presburger
  have "Q ≠ PO" 
    using assms(4) perp_distinct by blast
  have "B ≠ PO" 
    using assms(4) col_trivial_2 perp_not_col by blast
  obtain a where "QCongAAcute a" and "a A PO P" 
    using ‹Acute A PO P› ex_anga by blast
  have "¬ PO P Par A P" 
    using Par_cases assms(3) perp_not_par by blast
  have "A ≠ P" 
    using assms(3) perp_distinct by blast
  have "PO PO Proj PO P A P" 
    using Proj_def ‹A ≠ P› ‹P ≠ PO› ‹¬ PO P Par A P› col_trivial_3 by presburger
  have "A P Proj PO P A P" 
    using Proj_def ‹A ≠ P› ‹P ≠ PO› ‹¬ PO P Par A P› col_trivial_2 par_reflexivity by auto
  have "B Q Par A P" 
  proof (rule l12_9 [where ?C1.0="PO" and ?C2.0="P"])
    show "Coplanar PO P B A" 
      using assms(1) ncop__ncols not_col_permutation_5 by blast
    show "Coplanar PO P B P" 
      using ncop_distincts by blast
    show "Coplanar PO P Q A" 
      using assms(2) ncop__ncols by blast
    show "Coplanar PO P Q P" 
      using ncop_distincts by blast
    show "B Q Perp PO P" 
      by (metis Col_cases Perp_cases ‹P ≠ PO› assms(2) assms(4) perp_col)
    show "A P Perp PO P" 
      using Perp_perm assms(3) by blast
  qed
  hence "B Q Proj PO P A P" 
    unfolding Proj_def using ‹A ≠ P› ‹P ≠ PO› ‹¬ PO P Par A P› assms(2) by blast
  {
    assume "Bet PO A B"
    have "Bet PO P Q"
    proof (rule per23_preserves_bet [where ?B="A" and ?C="B"],simp_all add: ‹Bet PO A B› assms(2))
      show "PO ≠ P" 
        using ‹P ≠ PO› by blast 
      show "PO ≠ Q" 
        using ‹Q ≠ PO› by blast
      show "Per PO P A" 
        by (simp add: assms(3) perp_comm perp_per_1)
      show "Per PO Q B" 
        using assms(4) perp_comm perp_per_1 by blast
    qed
    have "A PO P CongA B PO Q"
    proof (rule out2__conga)
      show "PO Out B A" 
        by (simp add: Out_def ‹A ≠ PO› ‹B ≠ PO› ‹Bet PO A B›)
      show "PO Out Q P" 
        using Out_def ‹Bet PO P Q› ‹P ≠ PO› ‹Q ≠ PO› by blast
    qed
    hence "a B PO Q" 
      using ‹QCongAACute a› ‹a A PO P› anga_conga_anga by blast
  }
  moreover 
  {
    assume "Bet A B PO"
    have "Bet PO Q P" 
    proof (rule per23_preserves_bet [where ?B="B" and ?C="A"])
      show "Bet PO B A" 
        using Bet_cases ‹Bet A B PO› by blast
      show "PO ≠ Q" 
        using ‹Q ≠ PO› by auto
      show "PO ≠ P" 
        using ‹P ≠ PO› by blast
      show "Col PO Q P" 
        using Col_cases assms(2) by auto
      show "Per PO Q B" 
        by (simp add: assms(4) perp_comm perp_per_1)
      show "Per PO P A" 
        by (simp add: assms(3) perp_left_comm perp_per_2)
    qed
    hence "Bet P Q PO" 
      using Bet_cases by blast
    have "A PO P CongA B PO Q"
    proof (rule out2__conga)
      show "PO Out B A" 
        by (simp add: ‹B ≠ PO› ‹Bet A B PO› bet_out_1)
      show "PO Out Q P" 
        by (simp add: ‹Bet P Q PO› ‹Q ≠ PO› bet_out_1)
    qed
    hence "a B PO Q" 
      using ‹QCongAACute a› ‹a A PO P› anga_conga_anga by blast
  }
  moreover 
  {
    assume "Bet B PO A"
    have "Bet Q PO P" 
    proof (rule per13_preserves_bet [where ?A="B" and ?C="A"])
      show "Bet B PO A" 
        by (simp add: ‹Bet B PO A›)
      show "PO ≠ Q" 
        using ‹Q ≠ PO› by auto
      show "PO ≠ P" 
        using ‹P ≠ PO› by blast
      show "Col Q PO P" 
        using Col_cases assms(2) by blast
      show "Per PO Q B" 
        by (simp add: assms(4) perp_comm perp_per_1)
      show "Per PO P A" 
        using Perp_cases assms(3) perp_per_1 by blast
    qed
    have "A PO P CongA B PO Q" 
      using ‹A ≠ PO› ‹B ≠ PO› ‹Bet B PO A› ‹Bet Q PO P› ‹P ≠ PO› ‹Q ≠ PO› 
        conga_sym_equiv l11_14 by blast
    hence "a B PO Q" 
      using ‹QCongAACute a› ‹a A PO P› anga_conga_anga by blast
  }
  ultimately have "a B PO Q" 
    using Col_def assms(1) by blast
  have "QCongAAcute a" 
    by (simp add: ‹QCongAACute a›)
  moreover have "Lcos lp la a"
  proof -
    have "Per A P PO" 
      using Perp_perm assms(3) perp_per_2 by blast
    moreover have "a P PO A" 
      using ‹a A PO P› anga_sym ‹QCongAACute a› by blast
    ultimately show ?thesis
      using assms(11) assms(9) Lcos_def ‹QCongAACute a› assms(5) assms(7) by auto
  qed
  moreover have "Lcos lq lb a" 
  proof -
    have "Per B Q PO" 
      using Perp_perm assms(4) perp_per_1 by blast
    moreover have "a Q PO B" 
      by (simp add: ‹QCongAACute a› ‹a B PO Q› anga_sym)
    ultimately show ?thesis
      using assms(10) assms(12) Lcos_def ‹QCongAACute a› assms(6) assms(8) by auto
  qed
  ultimately show ?thesis
    by blast
qed

lemma l13_10_aux2:
  assumes "Col PO A B" and
    "QCong la" and
    "QCong lla" and
    "QCong lb" and
    "QCong llb" and
    "la PO A" and
    "lla PO A" and
    "lb PO B" and
    "llb PO B" and
    "A ≠ PO" and
    "B ≠ PO" 
  shows "∃ a. QCongAAcute a ∧ Lcos lla la a ∧ Lcos llb lb a" 
proof -
  have "Acute A PO A" 
    using acute_trivial assms(10) by auto
  then obtain a where "QCongAAcute a" and "a A PO A" 
    using anga_exists ex_anga by fastforce
  have "Col A PO A" 
    using not_col_distincts by blast
  hence "QCongANullAcute a" 
    using anga_col_null ‹QCongAACute a› ‹a A PO A› by blast
  have "la EqLTarski lla" 
    using assms(2) assms(3) assms(6) assms(7) ex_eqL by auto
  moreover 
  have "Lcos la la a"
  proof (rule null_lcos)
    show "QCong la"     
      by (simp add: assms(2))
    show "¬ QCongNull la"     
      using assms(10) assms(2) assms(6) between_cong lg_cong 
        lg_null_instance not_bet_distincts by blast
    show "QCongANullAcute a"
      by (simp add: ‹QCongANullAcute a›)
  qed
  ultimately have "Lcos lla la a" 
    using l13_6 lcos_eql_lcos by blast
  moreover have "Lcos llb lb a" 
  proof -
    obtain b where "QCongAAcute b" and "b B PO B" 
      using anga_exists acute_trivial assms(11) by blast
    have "a EqA b" using null_anga 
      using AngAcute_def ‹QCongAACute a› ‹QCongAACute b› ‹a A PO A› ‹b B PO B› by presburger
    have "lb EqLTarski llb" 
      using assms(4) assms(5) assms(8) assms(9) ex_eqL by blast
    have "¬ QCongNull lb" 
      using assms(11) assms(4) assms(8) cong_identity lg_cong lg_null_instance by blast
    hence "Lcos lb lb a" 
      using null_lcos assms(4) ‹QCongANullAcute a› by blast
    thus ?thesis 
      using ‹lb EqLTarski llb› l13_6 lcos_eql_lcos by blast
  qed
  ultimately show ?thesis 
    using ‹QCongAACute a› by blast
qed

lemma l13_6_bis:
  assumes "Lcos lp l1 a" and
    "Lcos lp l2 a"
  shows "l1 EqLTarski l2" 
proof -
  have "QCongANullAcute a ⟶ ?thesis" 
    by (metis (full_types) EqLTarski_def assms(1) assms(2) null_lcos_eql)
  moreover 
  {
    assume "¬ QCongANullAcute a"
    obtain A B C where "Per C B A" and "lp A B" and "l2 A C" and "a B A C" 
      using Lcos_def assms(2) by auto
    obtain A' B' C' where "Per C' B' A'" and "lp A' B'" and "l1 A' C'" and "a B' A' C'" 
      using Lcos_def assms(1) by auto
    {
      assume "B = C"
      hence "Col B A B" 
        by (simp add: col_trivial_3)
      hence "Col B A C" 
        by (simp add: ‹B = C› col_trivial_2)
      moreover 
      have "QCongAACute a" 
        using lcos_lg_anga assms(2) by blast
      hence "¬ Col B A C"
        using not_null_not_col [where ?a="a"] ‹¬ QCongANullAcute a› ‹a B A C› by blast
      ultimately have False 
        by blast
    }
    hence "B ≠ C" 
      by blast
    {
      assume "B' = C'"
      hence "Col B' A' B'" 
        by (simp add: col_trivial_3)
      hence "Col B' A' C'" 
        by (simp add: ‹B' = C'› col_trivial_2)
      moreover 
      have "QCongAACute a" 
        using lcos_lg_anga assms(2) by blast
      hence "¬ Col B' A' C'"
        using not_null_not_col [where ?a="a"] ‹¬ QCongANullAcute a› ‹a B' A' C'› by blast
      ultimately have False 
        by blast
    }
    hence "B' ≠ C'" 
      by blast
    have "A ≠ B" 
      using ‹lp A B› assms(2) lcos_const_cb lcos_lg_distincts by blast
    have "A ≠ C" 
      using ‹A ≠ B› ‹Per C B A› per_distinct by blast
    have "QCong lp" 
      using assms(1) Lcos_def by blast
    hence "Cong A B A' B'" 
      using lg_cong [where ?l = "lp"] ‹lp A B› ‹lp A' B'› by blast
    have "QCongAACute a" 
      using lcos_lg_anga assms(2) by blast
    hence "B A C CongA B' A' C'" 
      using anga_conga [where ?a = "a"] ‹a B A C› ‹a B' A' C'› by blast
    have "C B A CongA C' B' A'" 
      using l11_16 ‹A ≠ B› ‹B ≠ C› ‹B' = C' ⟹ False› ‹Cong A B A' B'› ‹Per C B A› 
        ‹Per C' B' A'› cong_diff by blast
    hence "A B C CongA A' B' C'" 
      by (simp add: conga_comm)
    hence "Cong A C A' C' ∧ Cong B C B' C' ∧ A C B CongA A' C' B'" 
      using l11_50_1 ‹B A C CongA B' A' C'›  ‹Cong A B A' B'› Col_cases 
        ‹A ≠ B› ‹B ≠ C› ‹Per C B A› per_col_eq by blast
    have "Cong A C A' C'" 
      using ‹Cong A C A' C' ∧ Cong B C B' C' ∧ A C B CongA A' C' B'› by auto
    have "QCong l1" 
      using assms(1) Lcos_def by blast
    have "QCong l2" 
      using assms(2) Lcos_def by blast
    have "TarskiLen A' C' l1" 
      using ‹l1 A' C'› TarskiLen_def ‹QCong l1› by blast
    moreover have "l2 A' C'"
      using lg_cong_lg [where ?A = "A" and ?B = "C"] ‹QCong l2› ‹l2 A C› 
        ‹Cong A C A' C'› by blast
    hence "TarskiLen A' C' l2" 
      using TarskiLen_def ‹QCong l2› by blast
    ultimately have ?thesis 
      using all_eql by force
  }
  ultimately show ?thesis by blast
qed

lemma lcos3_lcos2:
  assumes "EqLcos3 l1 a b n l2 c d n"
  shows "EqLcos2 l1 a b l2 c d"
proof -
  obtain lp where "Lcos3 lp l1 a b n" and "Lcos3 lp l2 c d n" 
    using EqLcos3_def assms by blast
  obtain ll1 where "Lcos2 ll1 l1 a b" and "Lcos lp ll1 n" 
    using ‹Lcos3 lp l1 a b n› lcos3_lcos_2_1 by fastforce
  obtain ll2 where "Lcos2 ll2 l2 c d" and "Lcos lp ll2 n" 
    using ‹Lcos3 lp l2 c d n› lcos3_lcos_2_1 by blast
  have "ll1 EqLTarski ll2" 
    using l13_6_bis [where ?lp = "lp" and ?a = "n"] ‹Lcos lp ll1 n› ‹Lcos lp ll2 n› by blast
  have "Lcos2 ll1 l2 c d" 
  proof (rule lcos2_eql_lcos2 [where ?lla="l2" and ?la="ll2"])
    show "Lcos2 ll2 l2 c d" 
      by (simp add: ‹Lcos2 ll2 l2 c d›)
    show "l2 EqLTarski l2" 
      by (simp add: EqLTarski_def)
    show "ll2 EqLTarski ll1" 
      using EqLTarski_def ‹ll1 EqLTarski ll2› by auto
  qed
  thus ?thesis 
    using ‹Lcos2 ll1 l1 a b› EqLcos2_def by blast
qed

lemma lcos2_lcos:
  assumes "EqLcos2 l1 a c l2 b c"
  shows "EqLcos l1 a l2 b" 
proof -
  obtain lp where "Lcos2 lp l1 a c" and "Lcos2 lp l2 b c" 
    using EqLcos2_def assms by blast
  then obtain lx where "Lcos lx l1 a" and "Lcos lp lx c" 
    using Lcos2_def by blast
  obtain ly where "Lcos ly l2 b" and "Lcos lp ly c" 
    using Lcos2_def ‹Lcos2 lp l2 b c› by auto
  hence "Lcos lx l2 b" 
    by (meson ‹Lcos lp lx c› l13_6_bis lcos_eql_lcos)
  thus ?thesis 
    using ‹Lcos lx l1 a› EqLcos_def by blast
qed

lemma lcos_per_anga: 
  assumes "Lcos lp la a" and
    "la PO A" and
    "lp PO P" and
    "Per A P PO"
  shows "a A PO P" 
proof -
  obtain A' P' O' where "Per A' P' O'" and "lp O' P'" and "la O' A'" and "a P' O' A'" 
    using assms(1) Lcos_def by blast
  have "QCong la" 
    using assms(1) Lcos_def by blast
  hence "Cong PO A O' A'"
    using lg_cong [where ?l = "la"] assms(2) ‹la O' A'› by blast
  have "QCong lp" 
    using assms(1) Lcos_def by blast
  hence "Cong PO P O' P'" 
    using lg_cong [where ?l = "lp"] assms(3) ‹lp O' P'› by blast
  have "¬ QCongNull lp" 
    using lcos_lg_not_null assms(1) by blast
  have "¬ QCongNull la" 
    using lcos_lg_not_null assms(1) by blast
  {
    assume "A = P" 
    have "Cong O' A' O' P'" 
      using ‹A = P› ‹Cong PO A O' A'› ‹Cong PO P O' P'› cong_inner_transitivity by blast
    have "A' = P'" 
    proof -
      {
        assume "Col A' P' O'"
        have "A' = P' ∨ O' = P'" 
          using ‹Col A' P' O'› ‹Per A' P' O'› l8_9 by auto
        moreover have "O' = P' ⟶ A' = P'" 
          using ‹Cong O' A' O' P'› cong_identity by blast
        ultimately have ?thesis 
          by blast
      }
      moreover 
      {
        assume "¬ Col A' P' O'"
        have False
          by (metis ‹Cong O' A' O' P'› ‹Per A' P' O'› ‹¬ Col A' P' O'› 
              cong__nlt not_col_distincts not_cong_4312 per_lt)
      }
      ultimately show ?thesis 
        by blast
    qed
    have "QCongANullAcute a"
    proof (rule out_null_anga [where ?A="P'" and ?B="O'" and ?C="P'"])
      show "QCongAACute a" 
        using assms(1) Lcos_def by blast
      show "a P' O' P'" 
        using ‹A' = P'› ‹a P' O' A'› by auto
      have "P' ≠ O'" 
        using ‹A' = P'› ‹a P' O' P'› ‹la O' A'› assms(1) lcos_lg_distincts by blast
      thus "O' Out P' P'" 
        by (simp add: out_trivial)
    qed
    moreover have "P ≠ PO" 
      using ‹Cong PO P O' P'› ‹lp O' P'› assms(1) cong_diff_4 lcos_const_cb 
        lcos_lg_distincts by blast
    ultimately have ?thesis 
      by (simp add: ‹A = P› is_null_all)
  }
  moreover 
  {
    assume "A ≠ P"
    have "PO ≠ P" 
      using assms(1) assms(3) lcos_const_cb lcos_lg_distincts by blast
    hence "Col A P PO ⟶ ?thesis"
      using ‹A ≠ P› assms(4) l8_9 by blast
    moreover
    {
      assume "¬ Col A P PO" 
      have "P' ≠ O' ∨ A' ≠ O'" 
        using ‹A ≠ P› ‹Cong PO A O' A'› ‹Cong PO P O' P'› cong_identity by blast
      {
        assume "A' = P'"
        have "Cong PO P PO A" 
          using Cong_perm ‹A' = P'› ‹Cong PO A O' A'› ‹Cong PO P O' P'› 
            cong_transitivity by blast
        moreover have "P A Lt A PO ∧ P PO Lt A PO" 
          using ‹A ≠ P› ‹PO ≠ P› assms(4) lt_left_comm per_lt by blast
        ultimately have False 
          using cong__nlt not_cong_2143 by blast
      }
      hence "A' ≠ P'" 
        by blast
      have "A P PO CongA A' P' O'" 
        using ‹A ≠ P› ‹A' ≠ P'› ‹Cong PO P O' P'› ‹PO ≠ P› ‹Per A' P' O'› assms(4) 
          cong_diff l11_16 by blast
      have "Cong P A P' A' ∧ P A PO CongA P' A' O' ∧ P PO A CongA P' O' A'" 
        by (metis ‹A ≠ P› ‹Cong PO A O' A'› ‹Cong PO P O' P'› ‹PO ≠ P› 
            ‹Per A' P' O'› assms(4) cong2_per2__cong l11_51 not_cong_2143 per_distinct)
      have "QCongAACute a" 
        using assms(1) Lcos_def by blast
      moreover have "a A' O' P'" 
        by (simp add: ‹a P' O' A'› anga_sym calculation)
      moreover have "A' O' P' CongA A PO P" 
        by (simp add: ‹Cong P A P' A' ∧ P A PO CongA P' A' O' ∧ P PO A CongA P' O' A'› 
            conga_comm conga_sym_equiv)
      ultimately have ?thesis 
        using anga_conga_anga by blast
    }
    ultimately have ?thesis 
      by blast
  }
  ultimately show ?thesis 
    by blast
qed

lemma lcos_lcos_cop__col:
  assumes "Lcos lp la a" and
    "Lcos lp lb b" and
    "la PO A" and
    "lb PO B" and
    "lp PO P" and
    "a A PO P" and
    "b B PO P" and
    "Coplanar PO A B P"
  shows "Col A B P" 
proof -
  have "QCong la" 
    using assms(1) Lcos_def by blast
  have "QCong lp" 
    using assms(1) Lcos_def by blast
  have "QCong lb" 
    using assms(2) Lcos_def by blast
  have "QCongAACute a" 
    using assms(1) Lcos_def by blast
  have "QCongAACute b" 
    using assms(2) Lcos_def by blast
  have "Per PO P A" 
    using lcos_per ‹QCong la› ‹QCong lp› ‹QCongAACute a› anga_sym assms(1) 
      assms(3) assms(5) assms(6) by blast
  have "Per PO P B" 
    using lcos_per ‹QCong lb› ‹QCong lp› ‹QCongAACute b› anga_sym assms(2) 
      assms(4) assms(5) assms(7) by blast
  show ?thesis
  proof (rule cop_per2__col [where ?A="PO"], simp add: assms(8))
    show "PO ≠ P" 
      using assms(1) assms(5) lcos_const_cb lcos_lg_distincts by blast
    show "Per A P PO" 
      using ‹Per PO P A› l8_2 by blast
    show "Per B P PO" 
      using Per_cases ‹Per PO P B› by auto
  qed
qed

lemma l13_10_aux3:
  assumes "¬ Col PO A A'" and
    "B ≠ PO" and
    "C ≠ PO" and
    "Col PO A B" and
    "Col PO B C" and
    "B' ≠ PO" and
    "C' ≠ PO" and
    "Col PO A' B'" and
    "Col PO B' C'" and
    "PO Perp2 B C' C B'" and
    "PO Perp2 C A' A C'" and
    "Bet A PO B" 
  shows "Bet A' PO B'" 
proof -
  have "A ≠ PO" 
    using assms(1) col_trivial_1 by fastforce
  have "A' ≠ PO" 
    using assms(1) not_col_distincts by blast
  have "Col PO A C" 
    by (metis assms(2) assms(4) assms(5) col_trivial_3 colx)
  have "Col PO A' C'" 
    by (metis assms(6) assms(8) assms(9) col_trivial_3 colx)  
  have "Bet C A PO ∨ Bet A C PO ∨ Bet PO C B ∨ Bet PO B C" 
    by (metis NCol_perm ‹Col PO A C› assms(12) fourth_point not_bet_distincts)
  moreover 
  {
    assume "Bet C A PO"
    have "Bet PO C' A'"
    proof (rule perp2_preserves_bet23 [where ?A = "A" and ?B = "C"])
      show "Bet PO A C" 
        using Bet_cases ‹Bet C A PO› by blast
      show "Col PO C' A'"           
        using ‹Col PO A' C'› not_col_permutation_5 by blast
      show "¬ Col PO A C'"           
        by (metis ‹Col PO C' A'› assms(1) assms(7) col_trivial_3 colx)
      show "PO Perp2 A C' C A'" 
        by (simp add: assms(11) perp2_sym)
    qed
    moreover have "Bet B' PO C'" 
    proof (rule perp2_preserves_bet13 [where ?B="B" and ?C="C"])
      show "Bet B PO C" 
        using ‹A ≠ PO› ‹Bet C A PO› assms(12) between_symmetry 
          outer_transitivity_between2 by blast
      show "Col PO B' C'" 
        by (simp add: assms(9))
      show "¬ Col PO B B'" 
        by (metis assms(1) assms(2) assms(4) assms(6) assms(8) col_trivial_3 
            colx not_col_permutation_5)
      show "PO Perp2 B C' C B'" 
        using assms(10) by auto
    qed
    ultimately have "Bet A' PO B'" 
      using assms(7) between_symmetry outer_transitivity_between by blast
  }
  moreover 
  {
    assume "Bet A C PO" 
    have "Bet PO A' C'" 
      by (metis ‹Bet A C PO› ‹Col PO A' C'› assms(1) assms(11) assms(3) 
          bet_col between_symmetry col_transitivity_1 perp2_preserves_bet23)
    moreover have "Bet B' PO C'"
    proof (rule perp2_preserves_bet13 [where ?B = "B" and ?C = "C"], 
        simp_all add: assms(9) assms(10))
      have "Bet C PO B" 
        using ‹Bet A C PO› assms(12) between_exchange3 by blast
      thus "Bet B PO C" 
        using Bet_cases by blast
      show "¬ Col PO B B'" 
        by (metis assms(1) assms(2) assms(4) assms(6) assms(8) 
            colx not_col_distincts not_col_permutation_2)
    qed
    ultimately have "Bet A' PO B'" 
      using between_inner_transitivity between_symmetry by blast
  }
  moreover 
  {
    assume "Bet PO C B"
    have "Bet A PO C" 
      using ‹Bet PO C B› assms(12) between_inner_transitivity by blast
    have "Bet PO B' C'" 
      by (metis ‹Bet PO C B› ‹Col PO A C› assms(1) assms(10) assms(3) assms(6) 
          assms(8) assms(9) colx not_col_distincts not_col_permutation_5 
          perp2_preserves_bet23 perp2_sym)
    have "Bet C' PO A'" 
    proof (rule perp2_preserves_bet13 [where ?B = "C" and ?C = "A"])
      show "Bet C PO A" 
        by (simp add: ‹Bet A PO C› between_symmetry)
      show "Col PO C' A'" 
        using ‹Col PO A' C'› not_col_permutation_5 by blast
      show "¬ Col PO C C'" 
        by (metis ‹Col PO A C› ‹Col PO C' A'› assms(1) assms(3) assms(7) col_trivial_3 colx)
      show "PO Perp2 C A' A C'" 
        using assms(11) by auto
    qed
    have "Bet A' PO B'" 
      using ‹Bet C' PO A'› ‹Bet PO B' C'› between_exchange3 between_symmetry by blast
  }
  moreover 
  {
    assume "Bet PO C B"
    hence "Bet A PO C" 
      using ‹Bet PO C B› assms(12) between_inner_transitivity by blast
    moreover have "Bet PO B' C'" 
    proof (rule perp2_preserves_bet23 [where ?A = "C" and ?B = "B"])
      show "Bet PO C B" 
        by (simp add: ‹Bet PO C B›)
      show "Col PO B' C'" 
        by (simp add: assms(9))
      show "¬ Col PO C B'" 
        by (metis ‹Col PO A C› assms(1) assms(3) assms(6) assms(8) col_trivial_3 colx 
            not_col_permutation_5)
      show "PO Perp2 C B' B C'" 
        by (simp add: assms(10) perp2_sym)
    qed
    moreover have "Bet C' PO A'" 
      using ‹Bet A PO C› ‹Col PO A' C'› assms(1) assms(11) between_symmetry 
        perp2_preserves_bet13 perp2_sym by blast
    ultimately have "Bet A' PO B'" 
      using ‹Bet PO C B ⟹ Bet A' PO B'› ‹Bet PO C B› by blast
  }
  ultimately show ?thesis 
    by (metis ‹Col PO A C› ‹Col PO A' C'› assms(1) assms(10) assms(11) assms(2) 
        assms(4) assms(7) assms(9) between_symmetry colx not_col_distincts 
        not_col_permutation_5 outer_transitivity_between perp2_preserves_bet13 
        perp2_preserves_bet23 third_point)
qed

lemma l13_10_aux4:
  assumes "¬ Col PO A A'" and
    "B ≠ PO" and
    "C ≠ PO" and
    "Col PO A B" and
    "Col PO B C" and
    "B' ≠ PO" and
    "C' ≠ PO" and
    "Col PO A' B'" and
    "Col PO B' C'" and
    "PO Perp2 B C' C B'" and
    "PO Perp2 C A' A C'" and
    "Bet PO A B"
  shows "PO Out A' B'" 
proof -
  have "A ≠ PO" 
    using assms(1) not_col_distincts by blast
  have "A' ≠ PO" 
    using assms(1) not_col_distincts by blast
  have "Col PO A C" 
    by (metis assms(2) assms(4) assms(5) col_trivial_3 colx)
  {
    assume "A = B"
    have "¬ Col A C' PO" 
      by (metis assms(1) assms(6) assms(7) assms(8) assms(9) col2__eq 
          col_permutation_4 col_permutation_5)
    have "PO Perp2 C A' C B'"
    proof (rule perp2_pseudo_trans [where ?C = "C" and ?D = "B'"])
      show "PO Perp2 C A' C B'" 
        using ‹A = B› ‹¬ Col A C' PO› assms(10) assms(11) perp2_pseudo_trans by blast
      show "PO Perp2 C B' C B'" 
        by (metis ‹A = B› assms(1) assms(5) assms(6) assms(8) 
            col_transitivity_2 not_col_permutation_1 perp2_refl)
      show "¬ Col C B' PO" 
        by (metis ‹A = B› assms(1) assms(3) assms(5) assms(6) assms(8) col2__eq 
            col_permutation_4 col_permutation_5)
    qed
    have "C A' Par C B'" 
      by (metis ‹Col PO A C› ‹PO Perp2 C A' C B'› assms(1) assms(6) assms(8) 
          between_equality_2 between_trivial col_transitivity_1 not_col_permutation_5 
          not_par_not_col par_reflexivity perp2_preserves_bet23 perp2_sym)
    have "A' = B'" 
      using ‹A = B› ‹C A' Par C B'› assms(1) assms(3) assms(5) assms(8)
        col_trivial_3 l6_21 not_col_permutation_2 par_id_2 by blast
    hence ?thesis 
      using assms(6) out_trivial by blast
  }
  moreover 
  {
    assume "A ≠ B"
    have "Bet C PO A ∨ Bet PO C A ∨ Bet A C B ∨ Bet A B C" 
      using ‹A ≠ B› ‹A ≠ PO› ‹Col PO A C› assms(12) fourth_point by auto
    moreover 
    {
      assume "Bet C PO A"
      have "Bet C PO B" 
        using ‹A ≠ PO› ‹Bet C PO A› assms(12) outer_transitivity_between by blast
      hence "Bet B' PO C'" 
        by (metis Col_cases assms(1) assms(10) assms(2) assms(4) 
            assms(6) assms(8) assms(9) between_symmetry col2__eq perp2_preserves_bet13)
      moreover have "Bet A' PO C'" 
        by (metis ‹Bet C PO A› assms(1) assms(11) assms(6) assms(8) 
            assms(9) between_symmetry col_not_col_not_par not_col_distincts 
            not_par_not_col perp2_preserves_bet13 perp2_sym)
      ultimately have ?thesis 
        using ‹A' ≠ PO› assms(6) assms(7) l6_2 by blast
    }
    moreover 
    {
      assume "Bet PO C A"
      hence "Bet PO C B" 
        using assms(12) between_exchange4 by blast
      have "Bet PO B' C'"
      proof (rule perp2_preserves_bet23 [where ?A = "C" and ?B = "B"])
        show "Bet PO C B" 
          using ‹Bet PO C B› by auto
        show "Col PO B' C'" 
          by (simp add: assms(9))
        show "¬ Col PO C B'" 
          by (metis (full_types) ‹Col PO A C› assms(1) assms(3) assms(6) 
              assms(8) colx l6_16_1 not_col_permutation_5)
        show "PO Perp2 C B' B C'" 
          by (simp add: assms(10) perp2_sym)
      qed
      moreover have "Bet PO A' C'" 
        by (metis ‹Bet PO C A› ‹Col PO A C› assms(1) assms(11) assms(3) assms(6) 
            assms(8) assms(9) colx not_col_distincts perp2_preserves_bet23)
      ultimately have ?thesis 
        using ‹A' ≠ PO› assms(6) bet2__out by force
    }
    moreover 
    {
      assume "Bet A C B"
      have "Bet PO A C" 
        using ‹Bet A C B› assms(12) between_inner_transitivity by blast
      have "Bet PO C' A'"
      proof (rule perp2_preserves_bet23 [where ?A = "A" and ?B = "C"])
        show "Bet PO A C" 
          by (simp add: ‹Bet PO A C›)
        show "Col PO C' A'" 
          by (metis Col_cases assms(6) assms(8) assms(9) col_transitivity_1)
        show "¬ Col PO A C'" 
          by (metis ‹Col PO C' A'› assms(1) assms(7) col_trivial_3 colx)
        show "PO Perp2 A C' C A'"
          by (simp add: assms(11) perp2_sym)
      qed
      have "Bet PO C B" 
        using ‹Bet A C B› assms(12) between_exchange2 by blast
      have "Bet PO B' C'" 
      proof (rule perp2_preserves_bet23 [where ?A = "C" and ?B = "B"])
        show "Bet PO C B" 
          by (simp add: ‹Bet PO C B›)
        show "Col PO B' C'" 
          by (simp add: assms(9))
        {
          assume "Col PO C B'"
          have False 
            by (metis ‹Col PO A C› ‹Col PO C B'› assms(1) assms(3) assms(6) 
                assms(8) col_transitivity_1 not_col_permutation_5)          
        }
        thus "¬ Col PO C B'" 
          by blast
        show "PO Perp2 C B' B C'"
          by (simp add: assms(10) perp2_sym)
      qed
      hence ?thesis 
        by (meson Out_def ‹A' ≠ PO› ‹Bet PO C' A'› assms(6) between_exchange4)
    }
    moreover 
    {
      assume "Bet A B C"
      have "Bet PO A C" 
        using ‹A ≠ B› ‹Bet A B C› assms(12) outer_transitivity_between by blast
      have "Bet PO B C"
        using ‹Bet A B C› ‹Bet PO A C› between_exchange2 by blast
      have "Bet PO C' B'" 
      proof (rule perp2_preserves_bet23 [where ?A="B" and ?B="C"])
        show "Bet PO B C" 
          by (simp add: ‹Bet PO B C›)
        show "Col PO C' B'" 
          using Col_cases assms(9) by blast
        {
          assume "Col PO B C'"
          hence "Col PO A A'" 
            by (metis ‹Col PO C' B'› assms(2) assms(4) assms(6) assms(7) assms(8) 
                col_permutation_5 col_transitivity_1)
          hence False 
            using assms(1) by blast
        }
        thus "¬ Col PO B C'" 
          by blast
        show "PO Perp2 B C' C B'" 
          by (simp add: assms(10))
      qed
      have "Bet PO C' A'" 
      proof (rule perp2_preserves_bet23 [where ?A="A" and ?B="C"])
        show "Bet PO A C" 
          by (simp add: ‹Bet PO A C›)
        show "Col PO C' A'" 
          by (metis assms(6) assms(8) assms(9) col_permutation_5 col_trivial_3 colx)
        show "¬ Col PO A C'" 
          by (metis ‹Col PO C' A'› assms(1) assms(7) col_trivial_3 colx)
        show "PO Perp2 A C' C A'" 
          by (simp add: assms(11) perp2_sym)
      qed
      hence ?thesis 
        by (metis Out_def ‹Bet PO C' B'› assms(7) bet_out l5_1)
    }
    ultimately have ?thesis 
      by blast
  }
  ultimately show ?thesis
    by blast
qed

lemma l13_10_aux5:
  assumes "¬ Col PO A A'" and
    "B ≠ PO" and
    "C ≠ PO" and
    "Col PO A B" and
    "Col PO B C" and
    "B' ≠ PO" and
    "C' ≠ PO" and
    "Col PO A' B'" and
    "Col PO B' C'" and
    "PO Perp2 B C' C B'" and
    "PO Perp2 C A' A C'" and
    "PO Out A B" 
  shows "PO Out A' B'" 
proof -
  have "A' ≠ PO" 
    using assms(1) not_col_distincts by blast
  have "A ≠ PO" 
    using Out_def assms(12) by blast
  have "B ≠ PO" 
    using assms(2) by auto
  have "Bet PO A B ∨ Bet PO B A" 
    using Out_def assms(12) by force
  moreover have "Bet PO A B ⟶ ?thesis" 
    using assms(1) assms(10) assms(11) assms(2) assms(3) assms(4) assms(5) 
      assms(6) assms(7) assms(8) assms(9) l13_10_aux4 by blast
  moreover 
  {
    assume "Bet PO B A"
    have "PO Out B' A'"
    proof (rule l13_10_aux4 [where ?A = "B" and ?B = "A" and ?C = "C" and ?C'= "C'"])
      show "¬ Col PO B B'" 
        by (metis assms(1) assms(2) assms(4) assms(6) assms(8) col_trivial_3 
            colx not_col_permutation_5)
      show "A ≠ PO" 
        by (simp add: ‹A ≠ PO›)
      show "C ≠ PO" 
        by (simp add: assms(3))
      show "Col PO B A" 
        using Col_cases assms(4) by blast
      show "Col PO A C" 
        by (metis ‹Col PO B A› assms(2) assms(5) col_transitivity_1)
      show "A' ≠ PO" 
        by (simp add: ‹A' ≠ PO›)
      show "C' ≠ PO" 
        by (simp add: assms(7))
      show "Col PO B' A'" 
        using assms(8) not_col_permutation_5 by blast
      show "Col PO A' C'" 
        by (metis ‹Col PO B' A'› assms(6) assms(9) col_transitivity_1)
      show "PO Perp2 A C' C A'" 
        by (simp add: assms(11) perp2_sym)
      show "PO Perp2 C B' B C'" 
        by (simp add: assms(10) perp2_sym)
      show "Bet PO B A" 
        by (simp add: ‹Bet PO B A›)
    qed
    hence ?thesis 
      using l6_6 by blast
  }
  ultimately show ?thesis 
    by blast
qed

lemma cop_per2__perp_aux:
  assumes "A ≠ B" and
    "X ≠ Y" and
    "B ≠ X" and
    "Coplanar A B X Y" and
    "Per A B X" and
    "Per A B Y"
  shows "A B Perp X Y" 
proof -
  have "B B Perp B X ⟶ A B Perp X Y" 
    using perp_distinct by blast
  moreover
  {
    assume "A B Perp B X"
    hence "X B Perp A B" 
      using Perp_cases by blast
    have "Col X Y B"
    proof (rule cop_per2__col [where ?A = "A"])
      show "Coplanar A X Y B" 
        using assms(4) coplanar_perm_3 by blast
      show "A ≠ B" 
        by (simp add: assms(1))
      show "Per X B A" 
        by (simp add: assms(5) l8_2)
      show "Per Y B A" 
        by (simp add: assms(6) l8_2)
    qed
    have "X Y Perp A B" 
      using perp_col [where ?B = "B"] 
      by (meson Col_cases ‹Col X Y B› ‹X B Perp A B› assms(2))
    hence "A B Perp X Y" 
      using Perp_cases by blast
  }
  ultimately show ?thesis 
    using ‹B ≠ X› assms(1) assms(5) per_perp by blast
qed

lemma cop_per2__perp:
  assumes "A ≠ B" and
    "X ≠ Y" and
    "B ≠ X ∨ B ≠ Y" and
    "Coplanar A B X Y" and
    "Per A B X" and
    "Per A B Y"
  shows "A B Perp X Y" 
proof -
  have "B ≠ X ⟶ ?thesis" 
    by (simp add: assms(1) assms(2) assms(4) assms(5) assms(6) cop_per2__perp_aux)
  moreover hence "B ≠ Y ⟶ ?thesis" 
    using cop_per2__perp_aux assms(1) assms(6) per_perp by force
  ultimately show ?thesis 
    using assms(3) by blast
qed

lemma l13_10:
  assumes "¬ Col PO A A'" and
    "B ≠ PO" and 
    "C ≠ PO" and
    "Col PO A B" and 
    "Col PO B C" and
    "B' ≠ PO" and
    "C' ≠ PO" and
    "Col PO A' B'" and
    "Col PO B' C'" and
    "PO Perp2 B C' C B'" and
    "PO Perp2 C A' A C'"
  shows "PO Perp2 A B' B A'" 
proof -
  have "Col PO A C" 
    by (metis assms(2) assms(4) assms(5) col_trivial_3 colx)
  have "Col PO A' C'" 
    by (metis assms(6) assms(8) assms(9) col_trivial_3 colx)
  have "A ≠ PO" 
    using assms(1) not_col_distincts by auto
  have "¬ Col A B' PO" 
    by (meson assms(1) assms(6) assms(8) col_trivial_3 colx 
        not_col_permutation_3 not_col_permutation_5)
  have "∃ P Q. Col B C' P ∧ Col C B' Q ∧ Col PO P Q ∧ 
                P PerpAt PO P B C' ∧ Q PerpAt PO Q C B'"
  proof (rule perp2_perp_in)
    show "PO Perp2 B C' C B'" 
      by (simp add: assms(10))
    show "¬ Col PO B C'" 
      by (metis NCol_perm ‹Col PO A' C'› assms(1) assms(2) assms(4) 
          assms(7) colx not_col_distincts)
    show "¬ Col PO C B'" 
      by (meson ‹Col PO A C› ‹¬ Col A B' PO› assms(3) col_trivial_3 colx 
          not_col_permutation_3 not_col_permutation_5)
  qed
  then obtain L L' where "Col B C' L" and "Col C B' L'" and 
    "Col PO L L'" and "L PerpAt PO L B C'" and "L' PerpAt PO L' C B'"
    by blast
  have "∃ P Q. Col C A' P ∧ Col A C' Q ∧ Col PO P Q ∧ P PerpAt PO P C A' ∧ Q PerpAt PO Q A C'" 
  proof (rule perp2_perp_in)
    show "PO Perp2 C A' A C'" 
      by (simp add: assms(11))
    show "¬ Col PO C A'" 
      by (metis ‹Col PO A C› assms(1) assms(3) col_trivial_3 colx)
    show "¬ Col PO A C'" 
      using NCol_perm ‹Col PO A' C'› assms(1) assms(7) col_trivial_3 colx by blast
  qed
  then obtain M M' where "Col C A' M" and "Col A C' M'" and 
    "Col PO M M'" and "M PerpAt PO M C A'" and "M' PerpAt PO M' A C'"  
    by blast
  obtain N where "Col A B' N" and "A B' Perp PO N" 
    using l8_18_existence ‹¬ Col A B' PO› by blast
  have "Col PO PO N" 
    using col_trivial_1 by auto
  moreover have "PO N Perp A B'" 
    using Perp_perm ‹A B' Perp PO N› by blast
  moreover have "PO N Perp B A'" 
  proof -
    obtain la where "QCong la" and "la PO A" 
      using lg_exists by blast
    obtain lb where "QCong lb" and "lb PO B" 
      using lg_exists by blast
    obtain lc where "QCong lc" and "lc PO C" 
      using lg_exists by blast
    obtain la' where "QCong la'" and "la' PO A'" 
      using lg_exists by blast
    obtain lb' where "QCong lb'" and "lb' PO B'" 
      using lg_exists by blast
    obtain lc' where "QCong lc'" and "lc' PO C'" 
      using lg_exists by blast
    obtain ll where "QCong ll" and "ll PO L" 
      using lg_exists by blast
    obtain ll' where "QCong ll'" and "ll' PO L'" 
      using lg_exists by blast
    obtain lm where "QCong lm" and "lm PO M" 
      using lg_exists by blast
    obtain lm' where "QCong lm'" and "lm' PO M'" 
      using lg_exists by blast
    obtain ln where "QCong ln" and "ln PO N" 
      using lg_exists by blast
    have "PO ≠ L" 
      using ‹L PerpAt PO L B C'› perp_in_distinct by auto
    have "PO ≠ L'" 
      using ‹L' PerpAt PO L' C B'› perp_in_distinct by auto
    have "¬ Col PO B B'" 
      by (meson ‹¬ Col A B' PO› assms(2) assms(4) col_permutation_1 col_trivial_3 colx)
    have "¬ Col PO C C'" 
      by (meson ‹Col PO A C› ‹¬ Col A B' PO› assms(3) assms(7) assms(9) 
          col_transitivity_2 not_col_permutation_1)
    have "∃ a. QCongAAcute a ∧ Lcos ll lb a ∧ Lcos ll' lc a" 
    proof (cases "B = L")
      case True
      hence "B' ≠ L'" 
        using ‹Col PO L L'› ‹¬ Col PO B B'› by auto
      hence "C = L'" 
        by (metis Col_cases True ‹Col C B' L'› ‹Col PO L L'› ‹¬ Col PO B B'› assms(5) colx)
      thus ?thesis
        using True ‹Col PO L L'› ‹PO ≠ L'› ‹QCong lb› ‹QCong lc› ‹QCong ll'› 
          ‹QCong ll› ‹lb PO B› ‹lc PO C› ‹ll PO L› ‹ll' PO L'› assms(2) l13_10_aux2 by auto
    next
      case False
      have "PO L Perp L B" 
        by (meson False ‹L PerpAt PO L B C'› l8_15_2 perp_in_col 
            perp_in_col_perp_in perp_right_comm)
      moreover have "PO L' Perp L' C"
        by (metis Col_cases ‹Col PO L L'› ‹L' PerpAt PO L' C B'› ‹PO ≠ L'› assms(5) calculation
            col_transitivity_2 per_perp perp_in_per_1 perp_not_col2) 
      ultimately show ?thesis 
        using l13_10_aux1 
        using ‹Col PO L L'› ‹QCong lb› ‹QCong lc› ‹QCong ll'› ‹QCong ll› 
          ‹lb PO B› ‹lc PO C› ‹ll PO L› ‹ll' PO L'› assms(5) by auto
    qed
    then obtain l' where "QCongAAcute l'" and "Lcos ll lb l'" and "Lcos ll' lc l'" 
      by blast
    have "∃ a. QCongAAcute a ∧ Lcos ll lc' a ∧ Lcos ll' lb' a" 
    proof (cases "C' = L")
      case True
      have "C ≠ L'" 
        using ‹¬ Col PO C C'› True ‹Col PO L L'› not_col_permutation_5 by blast
      hence "B' = L'" 
        using l6_21 by (metis True ‹Col C B' L'› ‹Col PO L L'› ‹¬ Col PO C C'› 
            assms(9) col_transitivity_1 not_col_distincts)
      thus ?thesis 
        using l13_10_aux2 [where ?PO = "PO" and ?A = "A" and ?B = "B"]
        by (metis True ‹QCong lb'› ‹QCong lc'› ‹QCong ll'› ‹QCong ll› 
            ‹lb' PO B'› ‹lc' PO C'› ‹ll PO L› ‹ll' PO L'› assms(6) 
            assms(7) assms(9) l13_10_aux2)
    next
      case False
      show ?thesis 
      proof (rule l13_10_aux1 [where ?PO="PO" and ?A="C'" and ?B="B'" and ?P="L" and ?Q="L'"],
          simp_all add: ‹Col PO L L'› ‹QCong lc'› ‹QCong lb'› ‹QCong ll› ‹QCong ll'›
          ‹lc' PO C'›‹lb' PO B'›‹ll PO L›‹ll' PO L'›)
        show "Col PO C' B'" 
          using Col_cases assms(9) by auto
        show "PO L Perp L C'" 
          by (metis False ‹Col B C' L› ‹L PerpAt PO L B C'› col_permutation_5 
              col_transitivity_1 perp_col2_bis perp_in_perp)
        show "PO L' Perp L' B'" 
          by (metis ‹Col C B' L'› ‹Col PO L L'› ‹L' PerpAt PO L' C B'› 
              ‹PO L Perp L C'› assms(9) col_transitivity_2 not_col_permutation_1 
              perp_col2_bis perp_in_perp perp_not_col2)
      qed
    qed
    then obtain l where "QCongAAcute l" and "Lcos ll lc' l" and "Lcos ll' lb' l" 
      by blast
    have "∃ a. QCongAAcute a ∧ Lcos lm lc a ∧ Lcos lm' la a" 
    proof (cases "C = M")
      case True
      have "A = M'"
      proof (rule l6_21 [where ?A="PO" and ?B="C" and ?C="C'" and ?D="M'"])
        show "¬ Col PO C C'" 
          using ‹¬ Col PO C C'› by blast
        {
          assume "C' = M'" 
          hence False 
            using True ‹Col PO M M'› ‹¬ Col PO C C'› by blast
        }
        thus "C' ≠ M'" 
          by blast
        show "Col PO C A" 
          using Col_cases ‹Col PO A C› by blast
        show "Col PO C M'" 
          by (simp add: True ‹Col PO M M'›)
        show "Col C' M' A" 
          using Col_cases ‹Col A C' M'› by blast
        show "Col C' M' M'" 
          by (simp add: col_trivial_2)
      qed
      show ?thesis 
      proof (rule l13_10_aux2 [where ?PO="PO" and ?A="C" and ?B="A"],
          simp_all add: ‹QCong lc› ‹QCong lm› ‹QCong lm'› ‹QCong la› 
          ‹lc PO C› ‹la PO A› assms(3) ‹A ≠ PO›)
        show "Col PO C A" 
          by (simp add: True ‹A = M'› ‹Col PO M M'›)
        show "lm PO C" 
          by (simp add: True ‹lm PO M›)
        show "lm' PO A" 
          by (simp add: ‹A = M'› ‹lm' PO M'›)
      qed
    next
      case False
      hence "C ≠ M" 
        by blast
      have "PO M Perp M C" 
        using False ‹Col C A' M› ‹M PerpAt PO M C A'› col_trivial_3 
          perp_col2_bis perp_in_perp by blast
      moreover have "PO M' Perp M' A" 
        by (metis ‹Col A C' M'› ‹Col PO A C› ‹Col PO M M'› ‹M' PerpAt PO M' A C'› 
            calculation col3 not_col_distincts perp_col1 perp_in_perp 
            perp_not_col2 perp_right_comm)
      ultimately show ?thesis 
        using l13_10_aux1 by (metis ‹Col PO A C› ‹Col PO M M'› ‹QCong la› 
            ‹QCong lc› ‹QCong lm'› ‹QCong lm› ‹la PO A› ‹lc PO C› ‹lm PO M› 
            ‹lm' PO M'› not_col_permutation_5) 
    qed
    then obtain m' where "QCongAAcute m'" and "Lcos lm lc m'" and "Lcos lm' la m'" 
      by blast 
    have "∃ a. QCongAAcute a ∧ Lcos lm la' a ∧ Lcos lm' lc' a" 
    proof (cases "A' = M")
      case True
      have "C' = M'" 
      proof (rule l6_21 [where ?A="PO" and ?B="A'" and ?C="A" and ?D="M'"])
        show "¬ Col PO A' A" 
          using assms(1) not_col_permutation_5 by blast
        show "A ≠ M'" 
          using Col_cases True ‹Col PO M M'› assms(1) by blast
        show "Col PO A' C'" 
          by (simp add: ‹Col PO A' C'›)
        show "Col PO A' M'" 
          by (simp add: True ‹Col PO M M'›)
        show "Col A M' C'" 
          using Col_cases ‹Col A C' M'› by blast
        show "Col A M' M'" 
          by (simp add: col_trivial_2)
      qed
      show ?thesis
      proof (rule l13_10_aux2 [where PO="PO" and ?A="A'" and ?B="C'"],
          simp_all add:  ‹QCong la'› ‹QCong lc'› ‹QCong lm› ‹QCong lm'› 
          assms(7) ‹Col PO A' C'› ‹la' PO A'› ‹lc' PO C'›)
        show "lm PO A'" 
          by (simp add: True ‹lm PO M›)
        show "lm' PO C'" 
          using ‹C' = M'› ‹lm' PO M'› by auto
        show "A' ≠ PO" 
          using assms(1) col_trivial_3 by blast
      qed
    next
      case False 
      hence "A' ≠ M" 
        by simp
      have "PO M Perp M A'" 
        using False ‹Col C A' M› ‹M PerpAt PO M C A'› col_trivial_2 
          perp_col2_bis perp_in_perp by blast
      moreover have "PO M' Perp M' C'" 
        by (metis ‹Col A C' M'› ‹Col PO M M'› ‹M' PerpAt PO M' A C'› assms(6) 
            assms(8) assms(9) calculation col_transitivity_1 not_col_distincts 
            perp_col2_bis perp_in_perp perp_not_col2)
      ultimately show ?thesis
        using l13_10_aux1 [where ?PO="PO" and ?A="A'" and ?B="C'" and ?P="M" and ?Q="M'"]
        by (simp add: ‹Col PO A' C'› ‹Col PO M M'› ‹QCong la'› ‹QCong lc'› 
            ‹QCong lm'› ‹QCong lm› ‹la' PO A'› ‹lc' PO C'› ‹lm PO M› ‹lm' PO M'›)
    qed
    then obtain m where "QCongAAcute m" and "Lcos lm la' m" and "Lcos lm' lc' m"
      by blast
    have "∃ a. QCongAAcute a ∧ Lcos ln la a" 
    proof -
      have "∃ a. QCongAAcute a ∧ a A PO N" 
      proof (rule anga_exists,simp_all add:‹A ≠ PO›)
        show "N ≠ PO" 
          using ‹Col A B' N› ‹¬ Col A B' PO› by auto
        show "Acute A PO N" 
          by (meson ‹Col A B' N› calculation(2) l8_14_2_1b_bis not_col_distincts
              not_col_permutation_1 perp_acute)
      qed
      then obtain n' where "QCongAAcute n'" and "n' A PO N" 
        by blast
      have "Per A N PO" 
        by (meson ‹A B' Perp PO N› ‹Col A B' N› l8_16_1 l8_2 not_col_distincts)
      hence "Lcos ln la n'" 
        by (metis Lcos_def ‹QCong la› ‹QCong ln› ‹QCongAACute n'› 
            ‹la PO A› ‹ln PO N› ‹n' A PO N› anga_sym)
      thus ?thesis
        using ‹QCongAACute n'› by blast
    qed
    then obtain n' where "QCongAAcute n'" and "Lcos ln la n'" 
      by blast
    have "∃ a. QCongAAcute a ∧ Lcos ln lb' a" 
    proof -
      have "∃ a. QCongAAcute a ∧ a B' PO N" 
      proof (rule anga_exists, simp add: assms(6))
        show "N ≠ PO" 
          using ‹Col A B' N› ‹¬ Col A B' PO› by blast
        show "Acute B' PO N" 
        proof (cases "B' = N")
          case True
          thus ?thesis
            using ‹N ≠ PO› acute_trivial by auto
        next
          case False
          show ?thesis
          proof (rule perp_acute [where ?C = "N"])
            show "Col B' N N" 
              using col_trivial_2 by auto
            show "N PerpAt PO N B' N" 
              by (meson False ‹A B' Perp PO N› ‹Col A B' N› l8_15_1 not_col_permutation_4 
                  perp_in_col_perp_in perp_in_left_comm perp_in_sym)
          qed
        qed
      qed
      then obtain n where "QCongAAcute n" and "n B' PO N" 
        by blast
      have "Per B' N PO" 
        using ‹A B' Perp PO N› ‹Col A B' N› col_trivial_2 l8_16_1 l8_2 by blast
      moreover have "n N PO B'" 
        using ‹QCongAACute n› ‹n B' PO N› anga_sym by blast
      ultimately show ?thesis 
        by (metis ‹ln PO N› ‹lb' PO B'› Lcos_def ‹QCong lb'› ‹QCong ln› 
            ‹∃a. QCongAACute a ∧ a B' PO N› anga_sym)
    qed
    then obtain n where "QCongAAcute n" and "Lcos ln lb' n" 
      by blast
    have "EqLcos lc l' lb' l" 
      using EqLcos_def ‹Lcos ll' lb' l› ‹Lcos ll' lc l'› by auto
    have "EqLcos lb l' lc' l" 
      using EqLcos_def ‹Lcos ll lb l'› ‹Lcos ll lc' l› by blast
    have "EqLcos lc m' la' m" 
      using EqLcos_def ‹Lcos lm la' m› ‹Lcos lm lc m'› by auto
    have "EqLcos la m' lc' m" 
      using EqLcos_def ‹Lcos lm' la m'› ‹Lcos lm' lc' m› by blast
    have "EqLcos la n' lb' n" 
      using EqLcos_def ‹Lcos ln la n'› ‹Lcos ln lb' n› by blast
    have "∃ lp. Lcos lp lb n'" 
    proof (rule lcos_exists, simp_all add: ‹QCongAACute n'› ‹QCong lb›)
      {
        assume "QCongNull lb" 
        then obtain X where "lb X X" 
          by (simp add: lg_null_instance)
        have "Cong B PO X X" 
          using ‹QCong lb› ‹lb PO B› ‹lb X X› lg_cong lg_sym by blast
        hence "B = PO" 
          by (simp add: cong_identity)
        hence False 
          by (simp add: assms(2))
      }
      thus "¬ QCongNull lb" 
        by blast
    qed
    then obtain bn' where "Lcos bn' lb n'" 
      by blast
    have "¬ QCongNull ll" 
      using ‹Lcos ll lb l'› lcos_not_lg_null by auto
    hence "∃ lp. Lcos lp ll n'" 
      using ‹QCong ll› ‹QCongAACute n'› lcos_exists by auto 
    then obtain bl'n' where "Lcos bl'n' ll n'" 
      by blast
    have "∃ lp. Lcos lp bn' l'"
    proof (rule lcos_exists, simp add: ‹QCongAACute l'›)
      show "QCong bn'" 
        using ‹Lcos bn' lb n'› lcos_lg_anga by blast
      show "¬ QCongNull bn'" 
        using ‹Lcos bn' lb n'› lcos_lg_not_null by auto
    qed
    then obtain bn'l' where "Lcos bn'l' bn' l'"
      by blast
    have "Lcos2 bl'n' lb l' n'" 
      using Lcos2_def ‹Lcos bl'n' ll n'› ‹Lcos ll lb l'› by blast
    have "Lcos2 bn'l' lb n' l'" 
      using Lcos2_def ‹Lcos bn' lb n'› ‹Lcos bn'l' bn' l'› by blast
    have "bl'n' EqLTarski bn'l'" 
      using ‹Lcos bl'n' ll n'› ‹Lcos bn' lb n'› ‹Lcos bn'l' bn' l'› 
        ‹Lcos ll lb l'› l13_7 by blast
    have "EqLcos2 lb l' n' lb n' l'" 
      using EqLcos2_def ‹Lcos2 bn'l' lb n' l'› lcos2_comm by blast
    have "EqLcos2 lb l' n' lc' l n'" 
      by (simp add: ‹EqLcos lb l' lc' l› ‹QCongAACute n'› lcos_eq_lcos2_eq)
    have "EqLcos3 lb l' n' m lc' l n' m" 
      by (simp add: ‹EqLcos lb l' lc' l› ‹QCongAACute m› ‹QCongAACute n'› lcos_eq_lcos3_eq)
    have "EqLcos3 lb l' n' m lc' m l n'" 
    proof -
      obtain lp where "Lcos3 lp lb l' n' m" and "Lcos3 lp lc' l n' m" 
        using EqLcos3_def ‹EqLcos3 lb l' n' m lc' l n' m› by blast
      thus ?thesis
        by (meson EqLcos3_def lcos3_permut1 lcos3_permut3)
    qed
    have "EqLcos3 la m' l n' lc' m l n'" 
      using ‹EqLcos la m' lc' m› ‹QCongAACute l› ‹QCongAACute n'› lcos_eq_lcos3_eq by force
    hence "EqLcos3 lb l' n' m la m' l n'" 
      by (meson ‹EqLcos3 lb l' n' m lc' m l n'› 
          lcos3_eq_sym lcos3_eq_trans)
    hence "EqLcos3 lb l' n' m la n' m' l" 
      by (meson EqLcos3_def lcos3_permut1 lcos3_permut3)
    have "EqLcos3 la n' m' l lb' n m' l" 
      using ‹EqLcos la n' lb' n› ‹QCongAACute l› ‹QCongAACute m'› lcos_eq_lcos3_eq by blast
    hence "EqLcos3 lb l' n' m lb' n m' l" 
      using ‹EqLcos3 lb l' n' m la n' m' l› lcos3_eq_trans by blast
    hence "EqLcos3 lb l' n' m lb' l n m'" 
      by (meson EqLcos3_def lcos3_permut1 lcos3_permut3)
    have "EqLcos3 lb l' n' m lb' l n m'"
    proof -
      obtain lp where "Lcos3 lp lb l' n' m" and "Lcos3 lp lb' n m' l" 
        using EqLcos3_def ‹EqLcos3 lb l' n' m lb' n m' l› by auto
      thus ?thesis 
        using ‹EqLcos3 lb l' n' m lb' l n m'› by blast
    qed
    have "EqLcos3 lb' l n m' lc l' n m'" 
      by (simp add: ‹EqLcos lc l' lb' l› ‹QCongAACute m'› ‹QCongAACute n› 
          lcos_eq_lcos3_eq lcos_eq_sym)
    have "EqLcos3 lb l' n' m lc l' n m'" 
      using ‹EqLcos3 lb l' n' m lb' l n m'› ‹EqLcos3 lb' l n m' lc l' n m'› 
        lcos3_eq_trans by blast
    have "EqLcos3 lb l' n' m lc m' l' n" 
      by (meson EqLcos3_def ‹EqLcos3 lb l' n' m lc l' n m'› lcos3_permut1 lcos3_permut2)
    have "EqLcos3 la' m l' n lc m' l' n" 
      by (simp add: ‹EqLcos lc m' la' m› ‹QCongAACute l'› ‹QCongAACute n› 
          lcos_eq_lcos3_eq lcos_eq_sym)
    hence "EqLcos3 lb l' n' m la' m l' n" 
      by (meson ‹EqLcos3 lb l' n' m lc m' l' n› lcos3_eq_sym lcos3_eq_trans)
    hence "EqLcos3 lb l' n' m la' n l' m" 
      by (meson EqLcos3_def lcos3_permut2) 
    have "EqLcos2 lb l' n' la' n l'" 
      using ‹EqLcos3 lb l' n' m la' n l' m› lcos3_lcos2 by auto
    have "EqLcos2 lb n' l' la' n l'" 
      by (meson ‹EqLcos2 lb l' n' la' n l'› ‹EqLcos2 lb l' n' lb n' l'› lcos2_eq_sym lcos2_eq_trans)
    have "EqLcos lb n' la' n" 
      using ‹EqLcos2 lb n' l' la' n l'› lcos2_lcos by auto
    obtain ln' where "Lcos ln' lb n'" and "Lcos ln' la' n" 
      using EqLcos_def ‹EqLcos lb n' la' n› by blast
    have "PO ≠ N" 
      using ‹Col A B' N› ‹¬ Col A B' PO› by auto
    have "Per A N PO"         
      using ‹A B' Perp PO N› ‹Col A B' N› col_trivial_3 l8_16_1 l8_2 by blast
    hence "n' A PO N" 
      using lcos_per_anga [where ?lp="la" and ?la="ln"] ‹Lcos ln la n'› 
        ‹la PO A› ‹ln PO N› lcos_per_anga by blast
    have "Per B' N PO" 
      using ‹A B' Perp PO N› ‹Col A B' N› col_trivial_2 l8_16_1 l8_2 by blast
    hence "n B' PO N" 
      using lcos_per_anga [where ?lp="lb'" and ?la="ln"] ‹Lcos ln lb' n› 
        ‹lb' PO B'› ‹ln PO N› lcos_per_anga by blast
    have "Bet A PO B ∨ PO Out A B ∨ ¬ Col A PO B" 
      using or_bet_out by presburger
    moreover 
    {
      assume "Bet A PO B"
      have "QCong ln'" 
        using ‹Lcos ln' la' n› lcos_lg_anga by blast
      then obtain N' where "ln' PO N'" and "Bet N PO N'" 
        using ex_point_lg_bet by blast
      {
        assume "PO = N'"
        hence "ln' PO PO" 
          using ‹ln' PO N'› by auto
        hence "QCongNull ln'"
          using ‹QCong ln'› by (simp add: lg_null_trivial)
        moreover have "¬ QCongNull ln' ∧ ¬ QCongNull lb" 
          using lcos_lg_not_null ‹Lcos ln' lb n'› by force
        hence "¬ QCongNull ln'" 
          by blast
        ultimately have False 
          by blast
      }
      hence "PO ≠ N'" 
        by blast
      {
        assume "A' = B"
        hence False 
          using assms(1) assms(4) by auto
      }
      hence "A' ≠ B" 
        by blast
      have "Per PO N' B"
      proof (rule lcos_per [where ?a = "n'" and ?l="lb" and ?lp="ln'"],
          simp_all add: ‹QCongAACute n'› ‹QCong lb› ‹QCong ln'› ‹Lcos ln' lb n'› 
          ‹lb PO B› ‹ln' PO N'›)
        have "N PO A CongA B PO N'" 
        proof (rule l11_13 [where ?A = "N'" and ?D = "A"], 
            simp_all add: ‹Bet A PO B› assms(2))
          show "N' PO A CongA A PO N'" 
            using ‹A ≠ PO› ‹PO ≠ N'› conga_pseudo_refl by force
          show "Bet N' PO N" 
            by (simp add: ‹Bet N PO N'› between_symmetry)
          show "N ≠ PO" 
            using ‹PO ≠ N› by blast
        qed
        thus "n' N' PO B" 
          using ‹QCongAACute n'› ‹n' A PO N› anga_conga_anga anga_sym by blast
      qed
      have "N PO B' CongA A' PO N'" 
      proof (rule l11_13 [where ?A = "N'" and ?D = "B'"])
        show "N' PO B' CongA B' PO N'" 
          using ‹PO ≠ N'› assms(6) conga_pseudo_refl by force
        show "Bet N' PO N" 
          using Bet_cases ‹Bet N PO N'› by auto
        show "N ≠ PO"  
          using ‹PO ≠ N› by blast
        have "Bet A' PO B'" 
          using l13_10_aux3 [where ?A="A" and ?B="B" and ?C="C"] ‹Bet A PO B› assms(1) 
            assms(10) assms(11) assms(2) assms(3) assms(4) assms(5) assms(6) 
            assms(7) assms(8) assms(9) by blast
        thus "Bet B' PO A'" 
          using between_symmetry by blast
        show "A' ≠ PO" 
          using assms(1) not_col_distincts by blast
      qed
      hence "n N' PO A'" 
        using ‹QCongAACute n› ‹n B' PO N› anga_conga_anga anga_sym by blast
      hence "Per PO N' A'"
        using lcos_per [where ?a="n" and ?l="ln'" and ?lp="la'"] 
          ‹Lcos ln' la' n› ‹la' PO A'› ‹ln' PO N'› lcos_lg_anga lcos_per by auto
      have ?thesis 
      proof (rule perp_col [where ?B="N'"])
        show "PO ≠ N" 
          by (simp add: ‹PO ≠ N›)
        show "PO N' Perp B A'"
        proof (rule cop_per2__perp)
          show "PO ≠ N'"                 
            by (simp add: ‹PO ≠ N'›)
          show "B ≠ A'"                 
            using ‹A' ≠ B› by auto
          show "N' ≠ B ∨ N' ≠ A'"                 
            using ‹B ≠ A'› by blast 
          have "Coplanar B N PO A'" 
          proof (rule col_cop__cop [where ?D="B'"])
            show "Coplanar B N PO B'" 
              using Coplanar_def ‹Col A B' N› assms(4) not_col_permutation_1 
                not_col_permutation_3 by blast
            show "PO ≠ B'" 
              using assms(6) by auto
            show "Col PO B' A'" 
              using Col_cases assms(8) by blast
          qed
          thus "Coplanar PO N' B A'"                 
            by (metis ‹Bet N PO N'› ‹PO ≠ N› bet_col bet_col1 col2_cop__cop 
                ncoplanar_perm_23 ncoplanar_perm_9)
          show "Per PO N' B"                 
            by (simp add: ‹Per PO N' B›)
          show "Per PO N' A'"             
            by (simp add: ‹Per PO N' A'›)
        qed
        show "Col PO N' N"     
          by (simp add: Col_def ‹Bet N PO N'›)
      qed
    }
    moreover 
    {
      assume "PO Out A B" 
      have "∃ N'. ln' PO N' ∧ PO Out N' N" 
      proof (rule ex_point_lg_out)
        show "PO ≠ N"             
          using ‹PO ≠ N› by blast
        show "QCong ln'"             
          using ‹Lcos ln' la' n› lcos_lg_anga by blast
        show "¬ QCongNull ln'"
          using ‹Lcos ln' la' n› lcos_lg_not_null by blast
      qed
      then obtain N' where "ln' PO N'" and "PO Out N' N" 
        by blast
      have "Per PO N' B" 
      proof (rule lcos_per [where ?a="n'" and ?lp="ln'" and ?l="lb"],
          simp_all add: ‹QCongAACute n'› ‹QCong lb›  ‹Lcos ln' lb n'› 
          ‹lb PO B› ‹ln' PO N'›)
        show "QCong ln'" 
          using ‹Lcos ln' la' n› lcos_lg_anga by blast
        show "n' N' PO B" 
          using Out_cases ‹PO Out A B› ‹PO Out N' N› ‹QCongAACute n'› 
            ‹n' A PO N› anga_out_anga anga_sym by blast
      qed
      have "Per PO N' A'" 
      proof (rule lcos_per [where ?a="n" and ?lp="ln'" and ?l="la'"])
        show "QCongAACute n"  
          by (simp add: ‹QCongAACute n›)
        show "QCong la'"  
          using ‹QCong la'› by auto
        show "QCong ln'"  
          using ‹Lcos ln' la' n› lcos_lg_anga by blast
        show "Lcos ln' la' n"  
          by (simp add: ‹Lcos ln' la' n›)
        show "la' PO A'"  
          by (simp add: ‹la' PO A'›)
        show "ln' PO N'"  
          by (simp add: ‹ln' PO N'›)
        have "B' PO N CongA A' PO N'" 
        proof (rule out2__conga)
          show "PO Out A' B'" 
            using ‹PO Out A B› assms(1) assms(10) assms(11) assms(2) assms(3) 
              assms(4) assms(5) assms(6) assms(7) assms(8) assms(9) l13_10_aux5 by blast
          show "PO Out N' N" 
            by (simp add: ‹PO Out N' N›)
        qed
        thus "n N' PO A'" 
          using ‹QCongAACute n› ‹n B' PO N› anga_conga_anga anga_sym by blast
      qed
      have ?thesis 
      proof (rule perp_col [where ?B = "N'"])
        show "PO ≠ N" 
          by (simp add: ‹PO ≠ N›)
        show "PO N' Perp B A'" 
        proof (rule cop_per2__perp)
          show "PO ≠ N'" 
            using ‹PO Out N' N› out_distinct by blast
          show "B ≠ A'" 
            using assms(1) assms(4) by fastforce
          show "N' ≠ B ∨ N' ≠ A'" 
            using ‹B ≠ A'› by force
          have "Coplanar B A' PO N'"
          proof (rule col_cop__cop [where ?D = "N"])
            have "Coplanar B N PO A'"
            proof (rule col_cop__cop [where ?D = "B'"])
              show "Coplanar B N PO B'"     
                using Col_cases Coplanar_def ‹Col A B' N› assms(4) by auto
              show "PO ≠ B'"     
                using assms(6) by auto
              show "Col PO B' A'"
                using assms(8) not_col_permutation_5 by blast
            qed
            thus "Coplanar B A' PO N" 
              using coplanar_perm_5 by blast
            show "PO ≠ N" 
              by (simp add: ‹PO ≠ N›)
            show "Col PO N N'" 
              using Out_cases ‹PO Out N' N› out_col by blast
          qed
          thus  "Coplanar PO N' B A'" 
            using coplanar_perm_16 by blast
          show "Per PO N' B" 
            using ‹Per PO N' B› by blast
          show "Per PO N' A'" 
            using ‹Per PO N' A'› by blast
        qed
        show "Col PO N' N" 
          by (simp add: ‹PO Out N' N› out_col)
      qed
    }
    moreover have "¬ Col A PO B ⟶ ?thesis" 
      using assms(4) not_col_permutation_4 by blast
    ultimately show ?thesis by blast
  qed
  ultimately show ?thesis 
    using Perp2_def by blast
qed

lemma Pj_exists: 
  fixes A B C
  shows "∃ D. A B Pj C D"
  using Pj_def by blast 

lemma project_trivial:
  assumes "A ≠ B"
    and "X ≠ Y"
    and "Col A B P"
    and "¬ A B Par X Y"
  shows "P P Proj A B X Y"
  by (simp add: Proj_def assms(1) assms(2) assms(3) assms(4)) 

lemma pj_col_project:
  assumes "A ≠ B"
    and "X ≠ Y"
    and "Col P' A B"
    and "¬ A B Par X Y"
    and "X Y Pj P P'"
  shows "P P' Proj A B X Y"
  by (metis Pj_def assms(1) assms(2) assms(3) assms(4) assms(5) not_col_permutation_2 
      par_col_project par_symmetry project_trivial) 

lemma pj_trivial:
  shows "A B Pj C C"
  by (simp add: Pj_def) 

(** Lemma 14.37 *)
lemma O_not_positive:
  shows "¬ Ps PO E PO"
  using Ps_def out_distinct by blast 

(** Lemma 14.40 states that we have an ordered field. *)

lemma col_pos_or_neg:
  assumes "PO ≠ E"
    and "PO ≠ X"
    and "Col PO E X"
  shows "Ps PO E X ∨ Ng PO E X"
  by (metis NCol_cases Ng_def Ps_def assms(1,2,3) or_bet_out) 

lemma length_cong:
  assumes "Length PO E E' A B AB"
  shows "Cong A B PO AB"
  using Cong_cases Length_def assms by auto 

lemma triangular_equality_equiv_a :
  assumes "∀ PO E A. PO ≠ E ⟶ (∀ E' B C AB BC AC. Bet A B C ∧ Length PO E E' A B AB ∧ 
                                                     Length PO E E' B C BC ∧ 
                                                     Length PO E E' A C AC 
                                                     ⟶ Sum PO E E' AB BC AC)"
  shows "∀ PO E E' A B C AB BC AC. PO ≠ E ∧ Bet A B C ∧ Length PO E E' A B AB ∧ 
                                   Length PO E E' B C BC ∧ Length PO E E' A C AC 
                                   ⟶ Sum PO E E' AB BC AC"
  using assms by force

lemma triangular_equality_equiv_b :
  assumes "∀ PO E E' A B C AB BC AC. PO ≠ E ∧ Bet A B C ∧ Length PO E E' A B AB ∧ 
                                     Length PO E E' B C BC ∧ Length PO E E' A C AC 
                                     ⟶ Sum PO E E' AB BC AC"
  shows "∀ PO E A. PO ≠ E ⟶ (∀ E' B C AB BC AC. Bet A B C ∧ Length PO E E' A B AB ∧ 
                                                   Length PO E E' B C BC ∧ Length PO E E' A C AC 
                                                   ⟶ Sum PO E E' AB BC AC)"
  by (simp add: assms)

lemma triangular_equality_equiv :
  shows "(∀ PO E A. PO ≠ E ⟶ (∀ E' B C AB BC AC. Bet A B C ∧ Length PO E E' A B AB ∧ 
                                                    Length PO E E' B C BC ∧ Length PO E E' A C AC 
                                                    ⟶ Sum PO E E' AB BC AC)) 
         ⟷ 
        (∀ PO E E' A B C AB BC AC. PO ≠ E ∧ Bet A B C ∧ Length PO E E' A B AB ∧ 
                                   Length PO E E' B C BC ∧ Length PO E E' A C AC 
                                   ⟶ Sum PO E E' AB BC AC)"
  by blast

lemma sign_dec:
  assumes "Col PO E A"
    and "PO ≠ E"
  shows "A = PO ∨ Ps PO E A ∨ Ng PO E A"
  by (metis assms(1,2) col_pos_or_neg) 

lemma not_neg_pos:
  assumes "E ≠ PO"
    and "Col PO E A"
    and "¬ Ng PO E A"
  shows "Ps PO E A ∨ A = PO"
  using assms(1,2,3) sign_dec by blast 

lemma Tarski_Pre_Non_Euclidean_aux_pre:
  assumes "∃ A B C D T. ¬ ((Bet A D T ∧ Bet B D C ∧ A ≠ D) 
                         ⟶
                      (∃ X Y. Bet A B X ∧ Bet A C Y ∧ Bet X T Y))" 
  shows "∃ A0 B0 C0 D0 T0. (Bet A0 D0 T0 ∧ Bet B0 D0 C0 ∧ A0 ≠ D0 ∧
                           (∀ X Y. ((Bet A0 B0 X ∧ Bet A0 C0 Y) ⟶ ¬ Bet X T0 Y)))" 
  using assms by blast

end
end