ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.Embedding.coe_sigmaSet
@[norm_cast] lemma Function.Embedding.coe_sigmaSet {s : ι → Set α} (h) :
    (Function.Embedding.sigmaSet h : ((i : ι) × s i) → α) = fun x ↦ x.2.1 
Arguments: {α : Type u_1} {ι : Type u_2} {s : ι → Set α} (h : Pairwise (Disjoint on s))
Goal: ⇑(Function.Embedding.sigmaSet h) = fun x => ↑x.snd
-- Function.Embedding.sigmaSet_preimage
@[simp] theorem Function.Embedding.sigmaSet_preimage {s : ι → Set α}
    (h : Pairwise (Disjoint on s)) (i : ι) (r : Set α) :
    Sigma.mk i ⁻¹' (Function.Embedding.sigmaSet h ⁻¹' r) = r ∩ s i 
Arguments: {α : Type u_1} {ι : Type u_2} {s : ι → Set α} (h : Pairwise (Disjoint on s)) (i : ι) (r : Set α)
Goal: ↑(Sigma.mk i ⁻¹' (⇑(Function.Embedding.sigmaSet h) ⁻¹' r)) = r ∩ s i
-- Function.Embedding.sigmaSet_range
@[simp] theorem Function.Embedding.sigmaSet_range {s : ι → Set α}
    (h : Pairwise (Disjoint on s)) : Set.range (Function.Embedding.sigmaSet h) = ⋃ i, s i 
Arguments: {α : Type u_1} {ι : Type u_2} {s : ι → Set α} (h : Pairwise (Disjoint on s))
Goal: Set.range ⇑(Function.Embedding.sigmaSet h) = ⋃ i, s i
-- Function.Embedding.inj'
structure Embedding (α : Sort*) (β : Sort*) where
    toFun : α → β
    inj' : Injective toFun
Arguments: {α : Sort u_1} {β : Sort u_2} (self : α ↪ β)
Goal: Function.Injective self.toFun
-- Function.exists_surjective_iff
theorem exists_surjective_iff {α β : Sort*} :
    (∃ f : α → β, Surjective f) ↔ Nonempty (α → β) ∧ Nonempty (β ↪ α) 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: (∃ f, Function.Surjective f) ↔ Nonempty (α → β) ∧ Nonempty (β ↪ α)
-- Equiv.coe_toEmbedding
@[simp]
theorem Equiv.coe_toEmbedding : (f.toEmbedding : α → β) = f 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β)
Goal: ⇑f.toEmbedding = ⇑f
-- Equiv.toEmbedding_apply
theorem Equiv.toEmbedding_apply (a : α) : f.toEmbedding a = f a 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β) (a : α)
Goal: f.toEmbedding a = f a
-- Equiv.toEmbedding_injective
theorem Equiv.toEmbedding_injective : Function.Injective (Equiv.toEmbedding : (α ≃ β) → (α ↪ β)) 
Arguments: {α : Sort u} {β : Sort v}
Goal: Function.Injective Equiv.toEmbedding
-- Function.Embedding.coe_injective
theorem coe_injective {α β} : @Injective (α ↪ β) (α → β) (fun f ↦ ↑f) 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: Function.Injective fun f => ⇑f
-- Function.Embedding.ext
@[ext]
theorem ext {α β} {f g : Embedding α β} (h : ∀ x, f x = g x) : f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f g : α ↪ β} (h : ∀ (x : α), f x = g x)
Goal: f = g
-- Function.Embedding.ext_iff
theorem ext_iff {α β} {f g : Embedding α β} : (∀ x, f x = g x) ↔ f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f g : α ↪ β}
Goal: (∀ (x : α), f x = g x) ↔ f = g
-- Function.Embedding.toFun_eq_coe
@[simp]
theorem toFun_eq_coe {α β} (f : α ↪ β) : toFun f = f 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α ↪ β)
Goal: f.toFun = ⇑f
-- Function.Embedding.coeFn_mk
@[simp]
theorem coeFn_mk {α β} (f : α → β) (i) : (@mk _ _ f i : α → β) = f 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (i : Function.Injective f)
Goal: ⇑{ toFun := f, inj' := i } = f
-- Function.Embedding.mk_coe
@[simp]
theorem mk_coe {α β : Type*} (f : α ↪ β) (inj) : (⟨f, inj⟩ : α ↪ β) = f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (inj : Function.Injective ⇑f)
Goal: { toFun := ⇑f, inj' := inj } = f
-- Function.Embedding.injective
protected theorem injective {α β} (f : α ↪ β) : Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α ↪ β)
Goal: Function.Injective ⇑f
-- Function.Embedding.apply_eq_iff_eq
theorem apply_eq_iff_eq {α β} (f : α ↪ β) (x y : α) : f x = f y ↔ x = y 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α ↪ β) (x y : α)
Goal: f x = f y ↔ x = y
-- Function.Embedding.refl_apply
@[refl, simps (config := { simpRhs := true })]
protected def refl (α : Sort*) : α ↪ α 
Arguments: (α : Sort u_1) (a : α)
Goal: (Function.Embedding.refl α) a = a
-- Function.Embedding.trans_apply
@[trans, simps (config := { simpRhs := true })]
protected def trans {α β γ} (f : α ↪ β) (g : β ↪ γ) : α ↪ γ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α ↪ β) (g : β ↪ γ)
Goal: ∀ (a : α), (f.trans g) a = g (f a)
-- Function.Embedding.equiv_toEmbedding_trans_symm_toEmbedding
@[simp]
theorem equiv_toEmbedding_trans_symm_toEmbedding {α β : Sort*} (e : α ≃ β) :
    e.toEmbedding.trans e.symm.toEmbedding = Embedding.refl _ 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β)
Goal: e.toEmbedding.trans e.symm.toEmbedding = Function.Embedding.refl α
-- Function.Embedding.equiv_symm_toEmbedding_trans_toEmbedding
@[simp]
theorem equiv_symm_toEmbedding_trans_toEmbedding {α β : Sort*} (e : α ≃ β) :
    e.symm.toEmbedding.trans e.toEmbedding = Embedding.refl _ 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β)
Goal: e.symm.toEmbedding.trans e.toEmbedding = Function.Embedding.refl β
-- Function.Embedding.congr_apply
@[simps! (config := { fullyApplied := false, simpRhs := true })]
protected def congr {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort x} (e₁ : α ≃ β) (e₂ : γ ≃ δ)
    (f : α ↪ γ) : β ↪ δ 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort x} (e₁ : α ≃ β) (e₂ : γ ≃ δ) (f : α ↪ γ)
Goal: ⇑(Function.Embedding.congr e₁ e₂ f) = ⇑(f.trans e₂.toEmbedding) ∘ ⇑e₁.symm
-- Function.Embedding.setValue_eq
@[simp]
theorem setValue_eq {α β} (f : α ↪ β) (a : α) (b : β) [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α ↪ β) (a : α) (b : β) [(a' : α) → Decidable (a' = a)] [(a' : α) → Decidable (f a' = b)]
Goal: (f.setValue a b) a = b
-- Function.Embedding.setValue_eq_iff
@[simp]
theorem setValue_eq_iff {α β} (f : α ↪ β) {a a' : α} {b : β} [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a' = b ↔ a' = a 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α ↪ β) {a a' : α} {b : β} [(a' : α) → Decidable (a' = a)] [(a' : α) → Decidable (f a' = b)]
Goal: (f.setValue a b) a' = b ↔ a' = a
-- Function.Embedding.some_apply
@[simps (config := .asFn)]
protected def some {α} : α ↪ Option α 
Arguments: {α : Type u_1}
Goal: ⇑Function.Embedding.some = some
-- Function.Embedding.optionMap_apply
@[simps (config := .asFn)]
def optionMap {α β} (f : α ↪ β) : Option α ↪ Option β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β)
Goal: ⇑f.optionMap = Option.map ⇑f
-- Function.Embedding.coe_subtype
@[simp]
theorem coe_subtype {α} (p : α → Prop) : ↑(subtype p) = Subtype.val 
Arguments: {α : Sort u_1} (p : α → Prop)
Goal: ⇑(Function.Embedding.subtype p) = Subtype.val
-- Function.Embedding.coe_quotientOut
@[simp]
theorem coe_quotientOut (α) [Setoid α] : ↑(quotientOut α) = Quotient.out 
Arguments: (α : Sort u_1) [Setoid α]
Goal: ⇑(Function.Embedding.quotientOut α) = Quotient.out
-- Function.Embedding.sectl_apply
@[simps]
def sectl (α : Sort _) {β : Sort _} (b : β) : α ↪ α × β 
Arguments: (α : Type u_1) {β : Type u_2} (b : β) (a : α)
Goal: (Function.Embedding.sectl α b) a = (a, b)
-- Function.Embedding.sectr_apply
@[simps]
def sectr {α : Sort _} (a : α) (β : Sort _) : β ↪ α × β 
Arguments: {α : Type u_1} (a : α) (β : Type u_2) (b : β)
Goal: (Function.Embedding.sectr a β) b = (a, b)
-- Function.Embedding.coe_prodMap
@[simp]
theorem coe_prodMap {α β γ δ : Type*} (e₁ : α ↪ β) (e₂ : γ ↪ δ) :
    e₁.prodMap e₂ = Prod.map e₁ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e₁ : α ↪ β) (e₂ : γ ↪ δ)
Goal: ⇑(e₁.prodMap e₂) = Prod.map ⇑e₁ ⇑e₂
-- Function.Embedding.coe_sumMap
@[simp]
theorem coe_sumMap {α β γ δ} (e₁ : α ↪ β) (e₂ : γ ↪ δ) : sumMap e₁ e₂ = Sum.map e₁ e₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e₁ : α ↪ β) (e₂ : γ ↪ δ)
Goal: ⇑(e₁.sumMap e₂) = Sum.map ⇑e₁ ⇑e₂
-- Function.Embedding.inl_apply
@[simps]
def inl {α β : Type*} : α ↪ α ⊕ β 
Arguments: {α : Type u_1} {β : Type u_2} (val : α)
Goal: Function.Embedding.inl val = Sum.inl val
-- Function.Embedding.inr_apply
@[simps]
def inr {α β : Type*} : β ↪ α ⊕ β 
Arguments: {α : Type u_1} {β : Type u_2} (val : β)
Goal: Function.Embedding.inr val = Sum.inr val
-- Function.Embedding.sigmaMk_apply
@[simps apply]
def sigmaMk (a : α) : β a ↪ Σx, β x 
Arguments: {α : Type u_1} {β : α → Type u_3} (a : α) (snd : β a)
Goal: (Function.Embedding.sigmaMk a) snd = ⟨a, snd⟩
-- Function.Embedding.sigmaMap_apply
@[simps apply]
def sigmaMap (f : α ↪ α') (g : ∀ a, β a ↪ β' (f a)) : (Σa, β a) ↪ Σa', β' a' 
Arguments: {α : Type u_1} {α' : Type u_2} {β : α → Type u_3} {β' : α' → Type u_4} (f : α ↪ α') (g : (a : α) → β a ↪ β' (f a)) (x : (a : α) × β a)
Goal: (f.sigmaMap g) x = Sigma.map (⇑f) (fun a => ⇑(g a)) x
-- Function.Embedding.piCongrRight_apply
@[simps]
def piCongrRight {α : Sort*} {β γ : α → Sort*} (e : ∀ a, β a ↪ γ a) : (∀ a, β a) ↪ ∀ a, γ a 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : α → Sort u_3} (e : (a : α) → β a ↪ γ a) (f : (a : α) → β a) (a : α)
Goal: (Function.Embedding.piCongrRight e) f a = (e a) (f a)
-- Function.Embedding.arrowCongrRight_apply
@[simp]
theorem arrowCongrRight_apply {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ↪ β) (f : γ → α) :
    arrowCongrRight e f = e ∘ f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ↪ β) (f : γ → α)
Goal: e.arrowCongrRight f = ⇑e ∘ f
-- Function.Embedding.swap_apply
theorem swap_apply {α β : Type*} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y z : α) :
    Equiv.swap (f x) (f y) (f z) = f (Equiv.swap x y z) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y z : α)
Goal: (Equiv.swap (f x) (f y)) (f z) = f ((Equiv.swap x y) z)
-- Function.Embedding.swap_comp
theorem swap_comp {α β : Type*} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y : α) :
    Equiv.swap (f x) (f y) ∘ f = f ∘ Equiv.swap x y 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y : α)
Goal: ⇑(Equiv.swap (f x) (f y)) ∘ ⇑f = ⇑f ∘ ⇑(Equiv.swap x y)
-- Equiv.asEmbedding_apply
@[simps!]
def asEmbedding {β α : Sort*} {p : β → Prop} (e : α ≃ Subtype p) : α ↪ β 
Arguments: {β : Sort u_1} {α : Sort u_2} {p : β → Prop} (e : α ≃ Subtype p)
Goal: ∀ (a : α), e.asEmbedding a = ↑(e a)
-- Equiv.embeddingCongr_apply
@[simps apply]
def embeddingCongr {α β γ δ : Sort*} (h : α ≃ β) (h' : γ ≃ δ) : (α ↪ γ) ≃ (β ↪ δ) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} (h : α ≃ β) (h' : γ ≃ δ) (f : α ↪ γ)
Goal: (h.embeddingCongr h') f = Function.Embedding.congr h h' f
-- Equiv.embeddingCongr_refl
@[simp]
theorem embeddingCongr_refl {α β : Sort*} :
    embeddingCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α ↪ β) 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: (Equiv.refl α).embeddingCongr (Equiv.refl β) = Equiv.refl (α ↪ β)
-- Equiv.embeddingCongr_trans
@[simp]
theorem embeddingCongr_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Sort*} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂)
    (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
    embeddingCongr (e₁.trans e₂) (e₁'.trans e₂') =
      (embeddingCongr e₁ e₁').trans (embeddingCongr e₂ e₂') 
Arguments: {α₁ : Sort u_1} {β₁ : Sort u_2} {α₂ : Sort u_3} {β₂ : Sort u_4} {α₃ : Sort u_5} {β₃ : Sort u_6} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃)
Goal: (e₁.trans e₂).embeddingCongr (e₁'.trans e₂') = (e₁.embeddingCongr e₁').trans (e₂.embeddingCongr e₂')
-- Equiv.embeddingCongr_symm
@[simp]
theorem embeddingCongr_symm {α₁ β₁ α₂ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (embeddingCongr e₁ e₂).symm = embeddingCongr e₁.symm e₂.symm 
Arguments: {α₁ : Sort u_1} {β₁ : Sort u_2} {α₂ : Sort u_3} {β₂ : Sort u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂)
Goal: (e₁.embeddingCongr e₂).symm = e₁.symm.embeddingCongr e₂.symm
-- Equiv.embeddingCongr_apply_trans
theorem embeddingCongr_apply_trans {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
    (ec : γ₁ ≃ γ₂) (f : α₁ ↪ β₁) (g : β₁ ↪ γ₁) :
    Equiv.embeddingCongr ea ec (f.trans g) =
      (Equiv.embeddingCongr ea eb f).trans (Equiv.embeddingCongr eb ec g) 
Arguments: {α₁ : Sort u_1} {β₁ : Sort u_2} {γ₁ : Sort u_3} {α₂ : Sort u_4} {β₂ : Sort u_5} {γ₂ : Sort u_6} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂) (f : α₁ ↪ β₁) (g : β₁ ↪ γ₁)
Goal: (ea.embeddingCongr ec) (f.trans g) = ((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)
-- Equiv.refl_toEmbedding
@[simp]
theorem refl_toEmbedding {α : Type*} : (Equiv.refl α).toEmbedding = Embedding.refl α 
Arguments: {α : Type u_1}
Goal: (Equiv.refl α).toEmbedding = Function.Embedding.refl α
-- Equiv.trans_toEmbedding
@[simp]
theorem trans_toEmbedding {α β γ : Type*} (e : α ≃ β) (f : β ≃ γ) :
    (e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ)
Goal: (e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding
-- subtypeOrLeftEmbedding_apply_left
theorem subtypeOrLeftEmbedding_apply_left {p q : α → Prop} [DecidablePred p]
    (x : { x // p x ∨ q x }) (hx : p x) :
    subtypeOrLeftEmbedding p q x = Sum.inl ⟨x, hx⟩ 
Arguments: {α : Type u_1} {p q : α → Prop} [DecidablePred p] (x : { x // p x ∨ q x }) (hx : p ↑x)
Goal: (subtypeOrLeftEmbedding p q) x = Sum.inl ⟨↑x, hx⟩
-- subtypeOrLeftEmbedding_apply_right
theorem subtypeOrLeftEmbedding_apply_right {p q : α → Prop} [DecidablePred p]
    (x : { x // p x ∨ q x }) (hx : ¬p x) :
    subtypeOrLeftEmbedding p q x = Sum.inr ⟨x, x.prop.resolve_left hx⟩ 
Arguments: {α : Type u_1} {p q : α → Prop} [DecidablePred p] (x : { x // p x ∨ q x }) (hx : ¬p ↑x)
Goal: (subtypeOrLeftEmbedding p q) x = Sum.inr ⟨↑x, ⋯⟩
-- Subtype.impEmbedding_apply_coe
@[simps]
def Subtype.impEmbedding (p q : α → Prop) (h : ∀ x, p x → q x) : { x // p x } ↪ { x // q x } 
Arguments: {α : Type u_1} (p q : α → Prop) (h : ∀ (x : α), p x → q x) (x : { x // p x })
Goal: ↑((Subtype.impEmbedding p q h) x) = ↑x
-- InnerProductGeometry.norm_sub_sq_eq_norm_sq_add_norm_sq_sub_two_mul_norm_mul_norm_mul_cos_angle
theorem norm_sub_sq_eq_norm_sq_add_norm_sq_sub_two_mul_norm_mul_norm_mul_cos_angle (x y : V) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - 2 * ‖x‖ * ‖y‖ * Real.cos (angle x y) 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] (x y : V)
Goal: ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - 2 * ‖x‖ * ‖y‖ * Real.cos (InnerProductGeometry.angle x y)
-- InnerProductGeometry.angle_sub_eq_angle_sub_rev_of_norm_eq
theorem angle_sub_eq_angle_sub_rev_of_norm_eq {x y : V} (h : ‖x‖ = ‖y‖) :
    angle x (x - y) = angle y (y - x) 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (h : ‖x‖ = ‖y‖)
Goal: InnerProductGeometry.angle x (x - y) = InnerProductGeometry.angle y (y - x)
-- InnerProductGeometry.norm_eq_of_angle_sub_eq_angle_sub_rev_of_angle_ne_pi
theorem norm_eq_of_angle_sub_eq_angle_sub_rev_of_angle_ne_pi {x y : V}
    (h : angle x (x - y) = angle y (y - x)) (hpi : angle x y ≠ π) : ‖x‖ = ‖y‖ 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (h : InnerProductGeometry.angle x (x - y) = InnerProductGeometry.angle y (y - x)) (hpi : InnerProductGeometry.angle x y ≠ π)
Goal: ‖x‖ = ‖y‖
-- InnerProductGeometry.cos_angle_sub_add_angle_sub_rev_eq_neg_cos_angle
theorem cos_angle_sub_add_angle_sub_rev_eq_neg_cos_angle {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.cos (angle x (x - y) + angle y (y - x)) = -Real.cos (angle x y) 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.cos (InnerProductGeometry.angle x (x - y) + InnerProductGeometry.angle y (y - x)) =
  -Real.cos (InnerProductGeometry.angle x y)
-- InnerProductGeometry.sin_angle_sub_add_angle_sub_rev_eq_sin_angle
theorem sin_angle_sub_add_angle_sub_rev_eq_sin_angle {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.sin (angle x (x - y) + angle y (y - x)) = Real.sin (angle x y) 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.sin (InnerProductGeometry.angle x (x - y) + InnerProductGeometry.angle y (y - x)) =
  Real.sin (InnerProductGeometry.angle x y)
-- InnerProductGeometry.cos_angle_add_angle_sub_add_angle_sub_eq_neg_one
theorem cos_angle_add_angle_sub_add_angle_sub_eq_neg_one {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.cos (angle x y + angle x (x - y) + angle y (y - x)) = -1 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.cos
    (InnerProductGeometry.angle x y + InnerProductGeometry.angle x (x - y) + InnerProductGeometry.angle y (y - x)) =
  -1
-- InnerProductGeometry.sin_angle_add_angle_sub_add_angle_sub_eq_zero
theorem sin_angle_add_angle_sub_add_angle_sub_eq_zero {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.sin (angle x y + angle x (x - y) + angle y (y - x)) = 0 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.sin
    (InnerProductGeometry.angle x y + InnerProductGeometry.angle x (x - y) + InnerProductGeometry.angle y (y - x)) =
  0
-- InnerProductGeometry.angle_add_angle_sub_add_angle_sub_eq_pi
theorem angle_add_angle_sub_add_angle_sub_eq_pi {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    angle x y + angle x (x - y) + angle y (y - x) = π 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: InnerProductGeometry.angle x y + InnerProductGeometry.angle x (x - y) + InnerProductGeometry.angle y (y - x) = π
-- EuclideanGeometry.dist_sq_eq_dist_sq_add_dist_sq_sub_two_mul_dist_mul_dist_mul_cos_angle
theorem dist_sq_eq_dist_sq_add_dist_sq_sub_two_mul_dist_mul_dist_mul_cos_angle (p1 p2 p3 : P) :
    dist p1 p3 * dist p1 p3 = dist p1 p2 * dist p1 p2 + dist p3 p2 * dist p3 p2 -
      2 * dist p1 p2 * dist p3 p2 * Real.cos (∠ p1 p2 p3) 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (p1 p2 p3 : P)
Goal: dist p1 p3 * dist p1 p3 =
  dist p1 p2 * dist p1 p2 + dist p3 p2 * dist p3 p2 -
    2 * dist p1 p2 * dist p3 p2 * Real.cos (EuclideanGeometry.angle p1 p2 p3)
-- EuclideanGeometry.angle_eq_angle_of_dist_eq
theorem angle_eq_angle_of_dist_eq {p1 p2 p3 : P} (h : dist p1 p2 = dist p1 p3) :
    ∠ p1 p2 p3 = ∠ p1 p3 p2 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {p1 p2 p3 : P} (h : dist p1 p2 = dist p1 p3)
Goal: EuclideanGeometry.angle p1 p2 p3 = EuclideanGeometry.angle p1 p3 p2
-- EuclideanGeometry.dist_eq_of_angle_eq_angle_of_angle_ne_pi
theorem dist_eq_of_angle_eq_angle_of_angle_ne_pi {p1 p2 p3 : P} (h : ∠ p1 p2 p3 = ∠ p1 p3 p2)
    (hpi : ∠ p2 p1 p3 ≠ π) : dist p1 p2 = dist p1 p3 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {p1 p2 p3 : P} (h : EuclideanGeometry.angle p1 p2 p3 = EuclideanGeometry.angle p1 p3 p2) (hpi : EuclideanGeometry.angle p2 p1 p3 ≠ π)
Goal: dist p1 p2 = dist p1 p3
-- EuclideanGeometry.angle_add_angle_add_angle_eq_pi
theorem angle_add_angle_add_angle_eq_pi {p1 p2 p3 : P} (h2 : p2 ≠ p1) (h3 : p3 ≠ p1) :
    ∠ p1 p2 p3 + ∠ p2 p3 p1 + ∠ p3 p1 p2 = π 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {p1 p2 p3 : P} (h2 : p2 ≠ p1) (h3 : p3 ≠ p1)
Goal: EuclideanGeometry.angle p1 p2 p3 + EuclideanGeometry.angle p2 p3 p1 + EuclideanGeometry.angle p3 p1 p2 = π
-- EuclideanGeometry.oangle_add_oangle_add_oangle_eq_pi
theorem oangle_add_oangle_add_oangle_eq_pi [Module.Oriented ℝ V (Fin 2)]
    [Fact (FiniteDimensional.finrank ℝ V = 2)] {p1 p2 p3 : P} (h21 : p2 ≠ p1) (h32 : p3 ≠ p2)
    (h13 : p1 ≠ p3) : ∡ p1 p2 p3 + ∡ p2 p3 p1 + ∡ p3 p1 p2 = π 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [Module.Oriented ℝ V (Fin 2)] [Fact (FiniteDimensional.finrank ℝ V = 2)] {p1 p2 p3 : P} (h21 : p2 ≠ p1) (h32 : p3 ≠ p2) (h13 : p1 ≠ p3)
Goal: EuclideanGeometry.oangle p1 p2 p3 + EuclideanGeometry.oangle p2 p3 p1 + EuclideanGeometry.oangle p3 p1 p2 = ↑π
-- EuclideanGeometry.dist_sq_mul_dist_add_dist_sq_mul_dist
theorem dist_sq_mul_dist_add_dist_sq_mul_dist (a b c p : P) (h : ∠ b p c = π) :
    dist a b ^ 2 * dist c p + dist a c ^ 2 * dist b p =
    dist b c * (dist a p ^ 2 + dist b p * dist c p) 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (a b c p : P) (h : EuclideanGeometry.angle b p c = π)
Goal: dist a b ^ 2 * dist c p + dist a c ^ 2 * dist b p = dist b c * (dist a p ^ 2 + dist b p * dist c p)
-- EuclideanGeometry.dist_sq_add_dist_sq_eq_two_mul_dist_midpoint_sq_add_half_dist_sq
theorem dist_sq_add_dist_sq_eq_two_mul_dist_midpoint_sq_add_half_dist_sq (a b c : P) :
    dist a b ^ 2 + dist a c ^ 2 = 2 * (dist a (midpoint ℝ b c) ^ 2 + (dist b c / 2) ^ 2) 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (a b c : P)
Goal: dist a b ^ 2 + dist a c ^ 2 = 2 * (dist a (midpoint ℝ b c) ^ 2 + (dist b c / 2) ^ 2)
-- EuclideanGeometry.dist_mul_of_eq_angle_of_dist_mul
theorem dist_mul_of_eq_angle_of_dist_mul (a b c a' b' c' : P) (r : ℝ) (h : ∠ a' b' c' = ∠ a b c)
    (hab : dist a' b' = r * dist a b) (hcb : dist c' b' = r * dist c b) :
    dist a' c' = r * dist a c 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (a b c a' b' c' : P) (r : ℝ) (h : EuclideanGeometry.angle a' b' c' = EuclideanGeometry.angle a b c) (hab : dist a' b' = r * dist a b) (hcb : dist c' b' = r * dist c b)
Goal: dist a' c' = r * dist a c
-- Equiv.right_inv
structure Equiv (α : Sort*) (β : Sort _) where
  protected toFun : α → β
  protected invFun : β → α
  protected left_inv : LeftInverse invFun toFun
  protected right_inv : RightInverse invFun toFun
Arguments: {α : Sort u_1} {β : Sort u_2} (self : α ≃ β)
Goal: Function.RightInverse self.invFun self.toFun
-- Equiv.left_inv
structure Equiv (α : Sort*) (β : Sort _) where
  protected toFun : α → β
  protected invFun : β → α
  protected left_inv : LeftInverse invFun toFun
  protected right_inv : RightInverse invFun toFun
Arguments: {α : Sort u_1} {β : Sort u_2} (self : α ≃ β)
Goal: Function.LeftInverse self.invFun self.toFun
-- EquivLike.coe_coe
@[simp, norm_cast]
lemma _root_.EquivLike.coe_coe {F} [EquivLike F α β] (e : F) :
    ((e : α ≃ β) : α → β) = e 
Arguments: {α : Sort u} {β : Sort v} {F : Sort u_1} [EquivLike F α β] (e : F)
Goal: ⇑↑e = ⇑e
-- Equiv.coe_fn_mk
@[simp] theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f 
Arguments: {α : Sort u} {β : Sort v} (f : α → β) (g : β → α) (l : Function.LeftInverse g f) (r : Function.RightInverse g f)
Goal: ⇑{ toFun := f, invFun := g, left_inv := l, right_inv := r } = f
-- Equiv.coe_fn_injective
theorem coe_fn_injective : @Function.Injective (α ≃ β) (α → β) (fun e => e) 
Arguments: {α : Sort u} {β : Sort v}
Goal: Function.Injective fun e => ⇑e
-- Equiv.coe_inj
protected theorem coe_inj {e₁ e₂ : α ≃ β} : (e₁ : α → β) = e₂ ↔ e₁ = e₂ 
Arguments: {α : Sort u} {β : Sort v} {e₁ e₂ : α ≃ β}
Goal: ⇑e₁ = ⇑e₂ ↔ e₁ = e₂
-- Equiv.ext
@[ext] theorem ext {f g : Equiv α β} (H : ∀ x, f x = g x) : f = g 
Arguments: {α : Sort u} {β : Sort v} {f g : α ≃ β} (H : ∀ (x : α), f x = g x)
Goal: f = g
-- Equiv.congr_arg
protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x' 
Arguments: {α : Sort u} {β : Sort v} {f : α ≃ β} {x x' : α}
Goal: x = x' → f x = f x'
-- Equiv.congr_fun
protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x 
Arguments: {α : Sort u} {β : Sort v} {f g : α ≃ β} (h : f = g) (x : α)
Goal: f x = g x
-- Equiv.ext_iff
theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x 
Arguments: {α : Sort u} {β : Sort v} {f g : α ≃ β}
Goal: f = g ↔ ∀ (x : α), f x = g x
-- Equiv.Perm.ext
@[ext] theorem Perm.ext {σ τ : Equiv.Perm α} (H : ∀ x, σ x = τ x) : σ = τ 
Arguments: {α : Sort u} {σ τ : Equiv.Perm α} (H : ∀ (x : α), σ x = τ x)
Goal: σ = τ
-- Equiv.Perm.congr_arg
protected theorem Perm.congr_arg {f : Equiv.Perm α} {x x' : α} : x = x' → f x = f x' 
Arguments: {α : Sort u} {f : Equiv.Perm α} {x x' : α}
Goal: x = x' → f x = f x'
-- Equiv.Perm.congr_fun
protected theorem Perm.congr_fun {f g : Equiv.Perm α} (h : f = g) (x : α) : f x = g x 
Arguments: {α : Sort u} {f g : Equiv.Perm α} (h : f = g) (x : α)
Goal: f x = g x