ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.erase_cons_subperm_cons_erase
theorem erase_cons_subperm_cons_erase (a b : α) (l : List α) :
    (a :: l).erase b <+~ a :: l.erase b 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (l : List α)
Goal: (a :: l).erase b <+~ a :: l.erase b
-- List.subperm_cons_diff
theorem subperm_cons_diff {a : α} {l₁ l₂ : List α} : (a :: l₁).diff l₂ <+~ a :: l₁.diff l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: (a :: l₁).diff l₂ <+~ a :: l₁.diff l₂
-- List.subset_cons_diff
theorem subset_cons_diff {a : α} {l₁ l₂ : List α} : (a :: l₁).diff l₂ ⊆ a :: l₁.diff l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: (a :: l₁).diff l₂ ⊆ a :: l₁.diff l₂
-- List.cons_perm_iff_perm_erase
theorem cons_perm_iff_perm_erase {a : α} {l₁ l₂ : List α} :
    a :: l₁ ~ l₂ ↔ a ∈ l₂ ∧ l₁ ~ l₂.erase a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: a :: l₁ ~ l₂ ↔ a ∈ l₂ ∧ l₁ ~ l₂.erase a
-- List.perm_iff_count
theorem perm_iff_count {l₁ l₂ : List α} : l₁ ~ l₂ ↔ ∀ a, count a l₁ = count a l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁ ~ l₂ ↔ ∀ (a : α), List.count a l₁ = List.count a l₂
-- List.subperm_append_diff_self_of_count_le
theorem subperm_append_diff_self_of_count_le {l₁ l₂ : List α}
    (h : ∀ x ∈ l₁, count x l₁ ≤ count x l₂) : l₁ ++ l₂.diff l₁ ~ l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (h : ∀ (x : α), x ∈ l₁ → List.count x l₁ ≤ List.count x l₂)
Goal: l₁ ++ l₂.diff l₁ ~ l₂
-- List.subperm_ext_iff
theorem subperm_ext_iff {l₁ l₂ : List α} : l₁ <+~ l₂ ↔ ∀ x ∈ l₁, count x l₁ ≤ count x l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁ <+~ l₂ ↔ ∀ (x : α), x ∈ l₁ → List.count x l₁ ≤ List.count x l₂
-- List.isSubperm_iff
theorem isSubperm_iff {l₁ l₂ : List α} : l₁.isSubperm l₂ ↔ l₁ <+~ l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁.isSubperm l₂ = true ↔ l₁ <+~ l₂
-- List.Subperm.cons_left
theorem Subperm.cons_left {l₁ l₂ : List α} (h : l₁ <+~ l₂) (x : α) (hx : count x l₁ < count x l₂) :
    x :: l₁ <+~ l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (h : l₁ <+~ l₂) (x : α) (hx : List.count x l₁ < List.count x l₂)
Goal: x :: l₁ <+~ l₂
-- List.isPerm_iff
theorem isPerm_iff : ∀ {l₁ l₂ : List α}, l₁.isPerm l₂ ↔ l₁ ~ l₂
  
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁.isPerm l₂ = true ↔ l₁ ~ l₂
-- List.Perm.insert
protected theorem Perm.insert (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    l₁.insert a ~ l₂.insert a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: List.insert a l₁ ~ List.insert a l₂
-- List.perm_insert_swap
theorem perm_insert_swap (x y : α) (l : List α) :
    List.insert x (List.insert y l) ~ List.insert y (List.insert x l) 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α) (l : List α)
Goal: List.insert x (List.insert y l) ~ List.insert y (List.insert x l)
-- List.perm_insertNth
theorem perm_insertNth {α} (x : α) (l : List α) {n} (h : n ≤ l.length) :
    insertNth n x l ~ x :: l 
Arguments: {α : Type u_1} (x : α) (l : List α) {n : Nat} (h : n ≤ l.length)
Goal: List.insertNth n x l ~ x :: l
-- List.Perm.union_right
theorem Perm.union_right {l₁ l₂ : List α} (t₁ : List α) (h : l₁ ~ l₂) : l₁ ∪ t₁ ~ l₂ ∪ t₁ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (t₁ : List α) (h : l₁ ~ l₂)
Goal: l₁ ∪ t₁ ~ l₂ ∪ t₁
-- List.Perm.union_left
theorem Perm.union_left (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂) : l ∪ t₁ ~ l ∪ t₂ 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂)
Goal: l ∪ t₁ ~ l ∪ t₂
-- List.Perm.union
theorem Perm.union {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂) : l₁ ∪ t₁ ~ l₂ ∪ t₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂)
Goal: l₁ ∪ t₁ ~ l₂ ∪ t₂
-- List.Perm.inter_right
theorem Perm.inter_right {l₁ l₂ : List α} (t₁ : List α) : l₁ ~ l₂ → l₁ ∩ t₁ ~ l₂ ∩ t₁ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (t₁ : List α)
Goal: l₁ ~ l₂ → l₁ ∩ t₁ ~ l₂ ∩ t₁
-- List.Perm.inter_left
theorem Perm.inter_left (l : List α) {t₁ t₂ : List α} (p : t₁ ~ t₂) : l ∩ t₁ = l ∩ t₂ 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) {t₁ t₂ : List α} (p : t₁ ~ t₂)
Goal: l ∩ t₁ = l ∩ t₂
-- List.Perm.inter
theorem Perm.inter {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂) : l₁ ∩ t₁ ~ l₂ ∩ t₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂)
Goal: l₁ ∩ t₁ ~ l₂ ∩ t₂
-- List.Perm.pairwise_iff
theorem Perm.pairwise_iff {R : α → α → Prop} (S : ∀ {x y}, R x y → R y x) :
    ∀ {l₁ l₂ : List α} (_p : l₁ ~ l₂), Pairwise R l₁ ↔ Pairwise R l₂ 
Arguments: {α : Type u_1} {R : α → α → Prop} (S : ∀ {x y : α}, R x y → R y x) {l₁ l₂ : List α} (_p : l₁ ~ l₂)
Goal: List.Pairwise R l₁ ↔ List.Pairwise R l₂
-- List.Pairwise.perm
theorem Pairwise.perm {R : α → α → Prop} {l l' : List α} (hR : l.Pairwise R) (hl : l ~ l')
    (hsymm : ∀ {x y}, R x y → R y x) : l'.Pairwise R 
Arguments: {α : Type u_1} {R : α → α → Prop} {l l' : List α} (hR : List.Pairwise R l) (hl : l ~ l') (hsymm : ∀ {x y : α}, R x y → R y x)
Goal: List.Pairwise R l'
-- List.Perm.pairwise
theorem Perm.pairwise {R : α → α → Prop} {l l' : List α} (hl : l ~ l') (hR : l.Pairwise R)
    (hsymm : ∀ {x y}, R x y → R y x) : l'.Pairwise R 
Arguments: {α : Type u_1} {R : α → α → Prop} {l l' : List α} (hl : l ~ l') (hR : List.Pairwise R l) (hsymm : ∀ {x y : α}, R x y → R y x)
Goal: List.Pairwise R l'
-- List.Perm.nodup_iff
theorem Perm.nodup_iff {l₁ l₂ : List α} : l₁ ~ l₂ → (Nodup l₁ ↔ Nodup l₂) 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ ~ l₂ → (l₁.Nodup ↔ l₂.Nodup)
-- List.Perm.join
theorem Perm.join {l₁ l₂ : List (List α)} (h : l₁ ~ l₂) : l₁.join ~ l₂.join 
Arguments: {α : Type u_1} {l₁ l₂ : List (List α)} (h : l₁ ~ l₂)
Goal: l₁.join ~ l₂.join
-- List.Perm.bind_right
theorem Perm.bind_right {l₁ l₂ : List α} (f : α → List β) (p : l₁ ~ l₂) : l₁.bind f ~ l₂.bind f 
Arguments: {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (f : α → List β) (p : l₁ ~ l₂)
Goal: l₁.bind f ~ l₂.bind f
-- List.Perm.join_congr
theorem Perm.join_congr :
    ∀ {l₁ l₂ : List (List α)} (_ : List.Forall₂ (· ~ ·) l₁ l₂), l₁.join ~ l₂.join
  
Arguments: {α : Type u_1} {l₁ l₂ : List (List α)}
Goal: List.Forall₂ (fun x x_1 => x ~ x_1) l₁ l₂ → l₁.join ~ l₂.join
-- List.Perm.eraseP
theorem Perm.eraseP (f : α → Bool) {l₁ l₂ : List α}
    (H : Pairwise (fun a b => f a → f b → False) l₁) (p : l₁ ~ l₂) : eraseP f l₁ ~ eraseP f l₂ 
Arguments: {α : Type u_1} (f : α → Bool) {l₁ l₂ : List α} (H : List.Pairwise (fun a b => f a = true → f b = true → False) l₁) (p : l₁ ~ l₂)
Goal: List.eraseP f l₁ ~ List.eraseP f l₂
-- List.perm_merge
theorem perm_merge (s : α → α → Bool) (l r) : merge s l r ~ l ++ r 
Arguments: {α : Type u_1} (s : α → α → Bool) (l r : List α)
Goal: List.merge s l r ~ l ++ r
-- List.Perm.merge
theorem Perm.merge (s₁ s₂ : α → α → Bool) (hl : l₁ ~ l₂) (hr : r₁ ~ r₂) :
    merge s₁ l₁ r₁ ~ merge s₂ l₂ r₂ 
Arguments: {α : Type u_1} {l₁ l₂ r₁ r₂ : List α} (s₁ s₂ : α → α → Bool) (hl : l₁ ~ l₂) (hr : r₁ ~ r₂)
Goal: List.merge s₁ l₁ r₁ ~ List.merge s₂ l₂ r₂
-- IncidenceGeometry.pts_of_circlesInter
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {α β : IncidenceGeometry.Circle}
Goal: IncidenceGeometry.circlesInter α β →
  ∃ a b,
    a ≠ b ∧
      IncidenceGeometry.onCircle a α ∧
        IncidenceGeometry.onCircle a β ∧ IncidenceGeometry.onCircle b α ∧ IncidenceGeometry.onCircle b β
-- IncidenceGeometry.onLine_2_of_between
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {a b c : IncidenceGeometry.Point} {L : IncidenceGeometry.Line}
Goal: IncidenceGeometry.between a b c →
  IncidenceGeometry.onLine a L → IncidenceGeometry.onLine c L → IncidenceGeometry.onLine b L
-- IncidenceGeometry.line_unique_of_pts
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {a b : IncidenceGeometry.Point} {L M : IncidenceGeometry.Line}
Goal: a ≠ b →
  IncidenceGeometry.onLine a L →
    IncidenceGeometry.onLine b L → IncidenceGeometry.onLine a M → IncidenceGeometry.onLine b M → L = M
-- IncidenceGeometry.circlesInter_of_onCircle_inCircle
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {a b : IncidenceGeometry.Point} {α β : IncidenceGeometry.Circle}
Goal: IncidenceGeometry.onCircle b α →
  IncidenceGeometry.onCircle a β →
    IncidenceGeometry.inCircle a α → IncidenceGeometry.inCircle b β → IncidenceGeometry.circlesInter α β
-- IncidenceGeometry.ne_23_of_between
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {a b c : IncidenceGeometry.Point}
Goal: IncidenceGeometry.between a b c → b ≠ c
-- IncidenceGeometry.inCircle_of_centerCircle
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] {a : IncidenceGeometry.Point} {α : IncidenceGeometry.Circle}
Goal: IncidenceGeometry.centerCircle a α → IncidenceGeometry.inCircle a α
-- IncidenceGeometry.line_of_pts
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] (a b : IncidenceGeometry.Point)
Goal: ∃ L, IncidenceGeometry.onLine a L ∧ IncidenceGeometry.onLine b L
-- IncidenceGeometry.circle_of_ne
class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α
Arguments: [self : IncidenceGeometry] (a b : IncidenceGeometry.Point)
Goal: a ≠ b → ∃ C, IncidenceGeometry.centerCircle a C ∧ IncidenceGeometry.onCircle b C
-- Except.map_id
@[simp] theorem map_id : Except.map (ε := ε) (α := α) (β := α) id = id 
Arguments: {ε : Type u} {α : Type u_1}
Goal: Except.map id = id
-- StateCpsT.runK_pure
@[simp] theorem runK_pure (a : α) (s : σ) (k : α → σ → m β) : (pure a : StateCpsT σ m α).runK s k = k a s 
Arguments: {α σ : Type u} {m : Type u → Type v} {β : Type u} (a : α) (s : σ) (k : α → σ → m β)
Goal: (pure a).runK s k = k a s
-- StateCpsT.runK_get
@[simp] theorem runK_get (s : σ) (k : σ → σ → m β) : (get : StateCpsT σ m σ).runK s k = k s s 
Arguments: {σ : Type u} {m : Type u → Type v} {β : Type u} (s : σ) (k : σ → σ → m β)
Goal: get.runK s k = k s s
-- StateCpsT.runK_set
@[simp] theorem runK_set (s s' : σ) (k : PUnit → σ → m β) : (set s' : StateCpsT σ m PUnit).runK s k = k ⟨⟩ s' 
Arguments: {σ : Type u} {m : Type u → Type v} {β : Type u} (s s' : σ) (k : PUnit → σ → m β)
Goal: (set s').runK s k = k PUnit.unit s'
-- StateCpsT.runK_modify
@[simp] theorem runK_modify (f : σ → σ) (s : σ) (k : PUnit → σ → m β) : (modify f : StateCpsT σ m PUnit).runK s k = k ⟨⟩ (f s) 
Arguments: {σ : Type u} {m : Type u → Type v} {β : Type u} (f : σ → σ) (s : σ) (k : PUnit → σ → m β)
Goal: (modify f).runK s k = k PUnit.unit (f s)
-- StateCpsT.runK_lift
@[simp] theorem runK_lift [Monad m] (x : m α) (s : σ) (k : α → σ → m β) : (StateCpsT.lift x : StateCpsT σ m α).runK s k = x >>= (k . s) 
Arguments: {α σ : Type u} {m : Type u → Type v} {β : Type u} [Monad m] (x : m α) (s : σ) (k : α → σ → m β)
Goal: (StateCpsT.lift x).runK s k = do
  let x ← x
  k x s
-- StateCpsT.runK_monadLift
@[simp] theorem runK_monadLift [Monad m] [MonadLiftT n m] (x : n α) (s : σ) (k : α → σ → m β)
    : (monadLift x : StateCpsT σ m α).runK s k = (monadLift x : m α) >>= (k . s) 
Arguments: {α σ : Type u} {m : Type u → Type v} {n : Type u → Type u_1} {β : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ) (k : α → σ → m β)
Goal: (monadLift x).runK s k = do
  let x ← monadLift x
  k x s
-- StateCpsT.runK_bind_pure
@[simp] theorem runK_bind_pure (a : α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ) : (pure a >>= f).runK s k = (f a).runK s k 
Arguments: {α σ : Type u} {m : Type u → Type v} {β γ : Type u} (a : α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ)
Goal: (pure a >>= f).runK s k = (f a).runK s k
-- StateCpsT.runK_bind_lift
@[simp] theorem runK_bind_lift [Monad m] (x : m α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ)
    : (StateCpsT.lift x >>= f).runK s k = x >>= fun a => (f a).runK s k 
Arguments: {α σ : Type u} {m : Type u → Type v} {β γ : Type u} [Monad m] (x : m α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ)
Goal: (StateCpsT.lift x >>= f).runK s k = do
  let a ← x
  (f a).runK s k
-- StateCpsT.runK_bind_get
@[simp] theorem runK_bind_get (f : σ → StateCpsT σ m β) (s : σ) (k : β → σ → m γ) : (get >>= f).runK s k = (f s).runK s k 
Arguments: {σ : Type u} {m : Type u → Type v} {β γ : Type u} (f : σ → StateCpsT σ m β) (s : σ) (k : β → σ → m γ)
Goal: (get >>= f).runK s k = (f s).runK s k
-- StateCpsT.runK_bind_set
@[simp] theorem runK_bind_set (f : PUnit → StateCpsT σ m β) (s s' : σ) (k : β → σ → m γ) : (set s' >>= f).runK s k = (f ⟨⟩).runK s' k 
Arguments: {σ : Type u} {m : Type u → Type v} {β γ : Type u} (f : PUnit → StateCpsT σ m β) (s s' : σ) (k : β → σ → m γ)
Goal: (set s' >>= f).runK s k = (f PUnit.unit).runK s' k
-- StateCpsT.runK_bind_modify
@[simp] theorem runK_bind_modify (f : σ → σ) (g : PUnit → StateCpsT σ m β) (s : σ) (k : β → σ → m γ) : (modify f >>= g).runK s k = (g ⟨⟩).runK (f s) k 
Arguments: {σ : Type u} {m : Type u → Type v} {β γ : Type u} (f : σ → σ) (g : PUnit → StateCpsT σ m β) (s : σ) (k : β → σ → m γ)
Goal: (modify f >>= g).runK s k = (g PUnit.unit).runK (f s) k
-- StateCpsT.run_eq
@[simp] theorem run_eq [Monad m] (x : StateCpsT σ m α) (s : σ) : x.run s = x.runK s (fun a s => pure (a, s)) 
Arguments: {α σ : Type u} {m : Type u → Type v} [Monad m] (x : StateCpsT σ m α) (s : σ)
Goal: x.run s = x.runK s fun a s => pure { fst := a, snd := s }
-- StateCpsT.run'_eq
@[simp] theorem run'_eq [Monad m] (x : StateCpsT σ m α) (s : σ) : x.run' s = x.runK s (fun a _ => pure a) 
Arguments: {α σ : Type u} {m : Type u → Type v} [Monad m] (x : StateCpsT σ m α) (s : σ)
Goal: x.run' s = x.runK s fun a x => pure a
-- ExceptCpsT.run_pure
@[simp] theorem run_pure [Monad m] : run (pure x : ExceptCpsT ε m α) = pure (Except.ok x) 
Arguments: {m : Type u_1 → Type u_2} {ε α : Type u_1} {x : α} [Monad m]
Goal: (pure x).run = pure (Except.ok x)
-- ExceptCpsT.run_lift
@[simp] theorem run_lift {α ε : Type u} [Monad m] (x : m α) : run (ExceptCpsT.lift x : ExceptCpsT ε m α) = (x >>= fun a => pure (Except.ok a) : m (Except ε α)) 
Arguments: {m : Type u → Type u_1} {α ε : Type u} [Monad m] (x : m α)
Goal: (ExceptCpsT.lift x).run = do
  let a ← x
  pure (Except.ok a)
-- ExceptCpsT.run_throw
@[simp] theorem run_throw [Monad m] : run (throw e : ExceptCpsT ε m β) = pure (Except.error e) 
Arguments: {m : Type u_1 → Type u_2} {ε β : Type u_1} {e : ε} [Monad m]
Goal: (throw e).run = pure (Except.error e)
-- ExceptCpsT.run_bind_lift
@[simp] theorem run_bind_lift [Monad m] (x : m α) (f : α → ExceptCpsT ε m β) : run (ExceptCpsT.lift x >>= f : ExceptCpsT ε m β) = x >>= fun a => run (f a) 
Arguments: {m : Type u_1 → Type u_2} {α ε β : Type u_1} [Monad m] (x : m α) (f : α → ExceptCpsT ε m β)
Goal: (ExceptCpsT.lift x >>= f).run = do
  let a ← x
  (f a).run
-- ExceptCpsT.run_bind_throw
@[simp] theorem run_bind_throw [Monad m] (e : ε) (f : α → ExceptCpsT ε m β) : run (throw e >>= f : ExceptCpsT ε m β) = run (throw e) 
Arguments: {m : Type u_1 → Type u_2} {ε α β : Type u_1} [Monad m] (e : ε) (f : α → ExceptCpsT ε m β)
Goal: (throw e >>= f).run = (throw e).run
-- ExceptCpsT.runCatch_pure
@[simp] theorem runCatch_pure [Monad m] : runCatch (pure x : ExceptCpsT α m α) = pure x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {x : α} [Monad m]
Goal: (pure x).runCatch = pure x
-- ExceptCpsT.runCatch_lift
@[simp] theorem runCatch_lift {α : Type u} [Monad m] [LawfulMonad m] (x : m α) : runCatch (ExceptCpsT.lift x : ExceptCpsT α m α) = x 
Arguments: {m : Type u → Type u_1} {α : Type u} [Monad m] [LawfulMonad m] (x : m α)
Goal: (ExceptCpsT.lift x).runCatch = x
-- ExceptCpsT.runCatch_throw
@[simp] theorem runCatch_throw [Monad m] : runCatch (throw a : ExceptCpsT α m α) = pure a 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {a : α} [Monad m]
Goal: (throw a).runCatch = pure a