ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Sum.LiftRel.exists_of_isRight_right
theorem exists_of_isRight_right (h₁ : LiftRel r s x y) (h₂ : y.isRight) :
    ∃ b d, s b d ∧ x = inr b ∧ y = inr d 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h₁ : Sum.LiftRel r s x y) (h₂ : y.isRight = true)
Goal: ∃ b d, s b d ∧ x = Sum.inr b ∧ y = Sum.inr d
-- Function.Injective.sum_elim
theorem Injective.sum_elim {f : α → γ} {g : β → γ} (hf : Injective f) (hg : Injective g)
    (hfg : ∀ a b, f a ≠ g b) : Injective (Sum.elim f g)
  
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {f : α → γ} {g : β → γ} (hf : Function.Injective f) (hg : Function.Injective g) (hfg : ∀ (a : α) (b : β), f a ≠ g b)
Goal: Function.Injective (Sum.elim f g)
-- Function.Injective.sum_map
theorem Injective.sum_map {f : α → β} {g : α' → β'} (hf : Injective f) (hg : Injective g) :
    Injective (Sum.map f g)
  
Arguments: {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'} (hf : Function.Injective f) (hg : Function.Injective g)
Goal: Function.Injective (Sum.map f g)
-- Function.Surjective.sum_map
theorem Surjective.sum_map {f : α → β} {g : α' → β'} (hf : Surjective f) (hg : Surjective g) :
    Surjective (Sum.map f g)
  
Arguments: {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'} (hf : Function.Surjective f) (hg : Function.Surjective g)
Goal: Function.Surjective (Sum.map f g)
-- Function.Bijective.sum_map
theorem Bijective.sum_map {f : α → β} {g : α' → β'} (hf : Bijective f) (hg : Bijective g) :
    Bijective (Sum.map f g) 
Arguments: {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'} (hf : Function.Bijective f) (hg : Function.Bijective g)
Goal: Function.Bijective (Sum.map f g)
-- Sum.map_injective
@[simp]
theorem map_injective {f : α → γ} {g : β → δ} :
    Injective (Sum.map f g) ↔ Injective f ∧ Injective g 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ}
Goal: Function.Injective (Sum.map f g) ↔ Function.Injective f ∧ Function.Injective g
-- Sum.map_surjective
@[simp]
theorem map_surjective {f : α → γ} {g : β → δ} :
    Surjective (Sum.map f g) ↔ Surjective f ∧ Surjective g 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ}
Goal: Function.Surjective (Sum.map f g) ↔ Function.Surjective f ∧ Function.Surjective g
-- Sum.map_bijective
@[simp]
theorem map_bijective {f : α → γ} {g : β → δ} :
    Bijective (Sum.map f g) ↔ Bijective f ∧ Bijective g 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ}
Goal: Function.Bijective (Sum.map f g) ↔ Function.Bijective f ∧ Function.Bijective g
-- Sum.elim_update_left
theorem elim_update_left [DecidableEq α] [DecidableEq β] (f : α → γ) (g : β → γ) (i : α) (c : γ) :
    Sum.elim (Function.update f i c) g = Function.update (Sum.elim f g) (inl i) c 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq α] [DecidableEq β] (f : α → γ) (g : β → γ) (i : α) (c : γ)
Goal: Sum.elim (Function.update f i c) g = Function.update (Sum.elim f g) (Sum.inl i) c
-- Sum.elim_update_right
theorem elim_update_right [DecidableEq α] [DecidableEq β] (f : α → γ) (g : β → γ) (i : β) (c : γ) :
    Sum.elim f (Function.update g i c) = Function.update (Sum.elim f g) (inr i) c 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq α] [DecidableEq β] (f : α → γ) (g : β → γ) (i : β) (c : γ)
Goal: Sum.elim f (Function.update g i c) = Function.update (Sum.elim f g) (Sum.inr i) c
-- DFunLike.coe_injective'
@[notation_class * toFun Simps.findCoercionArgs]
class DFunLike (F : Sort*) (α : outParam (Sort*)) (β : outParam <| α → Sort*) where
    coe : F → ∀ a : α, β a
    coe_injective' : Function.Injective coe
Arguments: {F : Sort u_1} {α : outParam (Sort u_2)} {β : outParam (α → Sort u_3)} [self : DFunLike F α β]
Goal: Function.Injective DFunLike.coe
-- DFunLike.coe_eq_coe_fn
theorem coe_eq_coe_fn : (DFunLike.coe (F := F)) = (fun f => ↑f) 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β]
Goal: DFunLike.coe = fun f => ⇑f
-- DFunLike.coe_injective
theorem coe_injective : Function.Injective (fun f : F ↦ (f : ∀ a : α, β a)) 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β]
Goal: Function.Injective fun f => ⇑f
-- DFunLike.coe_fn_eq
@[simp]
theorem coe_fn_eq {f g : F} : (f : ∀ a : α, β a) = (g : ∀ a : α, β a) ↔ f = g 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}
Goal: ⇑f = ⇑g ↔ f = g
-- DFunLike.ext'
theorem ext' {f g : F} (h : (f : ∀ a : α, β a) = (g : ∀ a : α, β a)) : f = g 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F} (h : ⇑f = ⇑g)
Goal: f = g
-- DFunLike.ext'_iff
theorem ext'_iff {f g : F} : f = g ↔ (f : ∀ a : α, β a) = (g : ∀ a : α, β a) 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}
Goal: f = g ↔ ⇑f = ⇑g
-- DFunLike.ext
theorem ext (f g : F) (h : ∀ x : α, f x = g x) : f = g 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] (f g : F) (h : ∀ (x : α), f x = g x)
Goal: f = g
-- DFunLike.ext_iff
theorem ext_iff {f g : F} : f = g ↔ ∀ x, f x = g x 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}
Goal: f = g ↔ ∀ (x : α), f x = g x
-- DFunLike.congr_fun
protected theorem congr_fun {f g : F} (h₁ : f = g) (x : α) : f x = g x 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F} (h₁ : f = g) (x : α)
Goal: f x = g x
-- DFunLike.ne_iff
theorem ne_iff {f g : F} : f ≠ g ↔ ∃ a, f a ≠ g a 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}
Goal: f ≠ g ↔ ∃ a, f a ≠ g a
-- DFunLike.exists_ne
theorem exists_ne {f g : F} (h : f ≠ g) : ∃ x, f x ≠ g x 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F} (h : f ≠ g)
Goal: ∃ x, f x ≠ g x
-- DFunLike.subsingleton_cod
lemma subsingleton_cod [∀ a, Subsingleton (β a)] : Subsingleton F 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] [∀ (a : α), Subsingleton (β a)]
Goal: Subsingleton F
-- DFunLike.congr
protected theorem congr {f g : F} {x y : α} (h₁ : f = g) (h₂ : x = y) : f x = g y 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [i : FunLike F α β] {f g : F} {x y : α} (h₁ : f = g) (h₂ : x = y)
Goal: f x = g y
-- DFunLike.congr_arg
protected theorem congr_arg (f : F) {x y : α} (h₂ : x = y) : f x = f y 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [i : FunLike F α β] (f : F) {x y : α} (h₂ : x = y)
Goal: f x = f y
-- MvPFunctor.M.dest'_eq_dest'
theorem M.dest'_eq_dest' {α : TypeVec n} {x : P.last.M} {a₁ : P.A}
    {f₁ : P.last.B a₁ → P.last.M} (h₁ : PFunctor.M.dest x = ⟨a₁, f₁⟩) {a₂ : P.A}
    {f₂ : P.last.B a₂ → P.last.M} (h₂ : PFunctor.M.dest x = ⟨a₂, f₂⟩) (f' : M.Path P x ⟹ α) :
    M.dest' P h₁ f' = M.dest' P h₂ f' 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {x : P.last.M} {a₁ : P.A} {f₁ : P.last.B a₁ → P.last.M} (h₁ : x.dest = ⟨a₁, f₁⟩) {a₂ : P.A} {f₂ : P.last.B a₂ → P.last.M} (h₂ : x.dest = ⟨a₂, f₂⟩) (f' : MvPFunctor.M.Path P x ⟹ α)
Goal: MvPFunctor.M.dest' P h₁ f' = MvPFunctor.M.dest' P h₂ f'
-- MvPFunctor.M.dest_eq_dest'
theorem M.dest_eq_dest' {α : TypeVec n} {x : P.last.M} {a : P.A}
    {f : P.last.B a → P.last.M} (h : PFunctor.M.dest x = ⟨a, f⟩) (f' : M.Path P x ⟹ α) :
    M.dest P ⟨x, f'⟩ = M.dest' P h f' 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {x : P.last.M} {a : P.A} {f : P.last.B a → P.last.M} (h : x.dest = ⟨a, f⟩) (f' : MvPFunctor.M.Path P x ⟹ α)
Goal: MvPFunctor.M.dest P ⟨x, f'⟩ = MvPFunctor.M.dest' P h f'
-- MvPFunctor.M.dest_corec'
theorem M.dest_corec' {α : TypeVec.{u} n} {β : Type u} (g₀ : β → P.A)
    (g₁ : ∀ b : β, P.drop.B (g₀ b) ⟹ α) (g₂ : ∀ b : β, P.last.B (g₀ b) → β) (x : β) :
    M.dest P (M.corec' P g₀ g₁ g₂ x) = ⟨g₀ x, splitFun (g₁ x) (M.corec' P g₀ g₁ g₂ ∘ g₂ x)⟩ 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {β : Type u} (g₀ : β → P.A) (g₁ : (b : β) → P.drop.B (g₀ b) ⟹ α) (g₂ : (b : β) → P.last.B (g₀ b) → β) (x : β)
Goal: MvPFunctor.M.dest P (MvPFunctor.M.corec' P g₀ g₁ g₂ x) =
  ⟨g₀ x, TypeVec.splitFun (g₁ x) (MvPFunctor.M.corec' P g₀ g₁ g₂ ∘ g₂ x)⟩
-- MvPFunctor.M.dest_corec
theorem M.dest_corec {α : TypeVec n} {β : Type u} (g : β → P (α.append1 β)) (x : β) :
    M.dest P (M.corec P g x) = appendFun id (M.corec P g) <$$> g x 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {β : Type u} (g : β → ↑P (α ::: β)) (x : β)
Goal: MvPFunctor.M.dest P (MvPFunctor.M.corec P g x) = (TypeVec.id ::: MvPFunctor.M.corec P g) <$$> g x
-- MvPFunctor.M.bisim_lemma
theorem M.bisim_lemma {α : TypeVec n} {a₁ : (mp P).A} {f₁ : (mp P).B a₁ ⟹ α} {a' : P.A}
    {f' : (P.B a').drop ⟹ α} {f₁' : (P.B a').last → M P α}
    (e₁ : M.dest P ⟨a₁, f₁⟩ = ⟨a', splitFun f' f₁'⟩) :
    ∃ (g₁' : _)(e₁' : PFunctor.M.dest a₁ = ⟨a', g₁'⟩),
      f' = M.pathDestLeft P e₁' f₁ ∧
        f₁' = fun x : (last P).B a' => ⟨g₁' x, M.pathDestRight P e₁' f₁ x⟩ 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {a₁ : P.mp.A} {f₁ : P.mp.B a₁ ⟹ α} {a' : P.A} {f' : (P.B a').drop ⟹ α} {f₁' : (P.B a').last → P.M α} (e₁ : MvPFunctor.M.dest P ⟨a₁, f₁⟩ = ⟨a', TypeVec.splitFun f' f₁'⟩)
Goal: ∃ g₁',
  ∃ (e₁' : PFunctor.M.dest a₁ = ⟨a', g₁'⟩),
    f' = MvPFunctor.M.pathDestLeft P e₁' f₁ ∧ f₁' = fun x => ⟨g₁' x, MvPFunctor.M.pathDestRight P e₁' f₁ x⟩
-- MvPFunctor.M.bisim
theorem M.bisim {α : TypeVec n} (R : P.M α → P.M α → Prop)
    (h :
      ∀ x y,
        R x y →
          ∃ a f f₁ f₂,
            M.dest P x = ⟨a, splitFun f f₁⟩ ∧
              M.dest P y = ⟨a, splitFun f f₂⟩ ∧ ∀ i, R (f₁ i) (f₂ i))
    (x y) (r : R x y) : x = y 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} (R : P.M α → P.M α → Prop) (h :
  ∀ (x y : P.M α),
    R x y →
      ∃ a f f₁ f₂,
        MvPFunctor.M.dest P x = ⟨a, TypeVec.splitFun f f₁⟩ ∧
          MvPFunctor.M.dest P y = ⟨a, TypeVec.splitFun f f₂⟩ ∧ ∀ (i : (P.B a).last), R (f₁ i) (f₂ i)) (x y : P.M α) (r : R x y)
Goal: x = y
-- MvPFunctor.M.bisim₀
theorem M.bisim₀ {α : TypeVec n} (R : P.M α → P.M α → Prop) (h₀ : Equivalence R)
    (h : ∀ x y, R x y → (id ::: Quot.mk R) <$$> M.dest _ x = (id ::: Quot.mk R) <$$> M.dest _ y)
    (x y) (r : R x y) : x = y 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} (R : P.M α → P.M α → Prop) (h₀ : Equivalence R) (h :
  ∀ (x y : P.M α),
    R x y →
      (TypeVec.id ::: Quot.mk R) <$$> MvPFunctor.M.dest P x = (TypeVec.id ::: Quot.mk R) <$$> MvPFunctor.M.dest P y) (x y : P.M α) (r : R x y)
Goal: x = y
-- MvPFunctor.M.bisim'
theorem M.bisim' {α : TypeVec n} (R : P.M α → P.M α → Prop)
    (h : ∀ x y, R x y → (id ::: Quot.mk R) <$$> M.dest _ x = (id ::: Quot.mk R) <$$> M.dest _ y)
    (x y) (r : R x y) : x = y 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} (R : P.M α → P.M α → Prop) (h :
  ∀ (x y : P.M α),
    R x y →
      (TypeVec.id ::: Quot.mk R) <$$> MvPFunctor.M.dest P x = (TypeVec.id ::: Quot.mk R) <$$> MvPFunctor.M.dest P y) (x y : P.M α) (r : R x y)
Goal: x = y
-- MvPFunctor.M.dest_map
theorem M.dest_map {α β : TypeVec n} (g : α ⟹ β) (x : P.M α) :
    M.dest P (g <$$> x) = (appendFun g fun x => g <$$> x) <$$> M.dest P x 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α β : TypeVec.{u} n} (g : α ⟹ β) (x : P.M α)
Goal: MvPFunctor.M.dest P (g <$$> x) = (g ::: fun x => g <$$> x) <$$> MvPFunctor.M.dest P x
-- MvPFunctor.M.map_dest
theorem M.map_dest {α β : TypeVec n} (g : (α ::: P.M α) ⟹ (β ::: P.M β)) (x : P.M α)
    (h : ∀ x : P.M α, lastFun g x = (dropFun g <$$> x : P.M β)) :
    g <$$> M.dest P x = M.dest P (dropFun g <$$> x) 
Arguments: {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α β : TypeVec.{u} n} (g : α ::: P.M α ⟹ β ::: P.M β) (x : P.M α) (h : ∀ (x : P.M α), TypeVec.lastFun g x = TypeVec.dropFun g <$$> x)
Goal: g <$$> MvPFunctor.M.dest P x = MvPFunctor.M.dest P (TypeVec.dropFun g <$$> x)
-- Bundle.TotalSpace.mk_cast
theorem TotalSpace.mk_cast {x x' : B} (h : x = x') (b : E x) :
    .mk' F x' (cast (congr_arg E h) b) = TotalSpace.mk x b 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {x x' : B} (h : x = x') (b : E x)
Goal: Bundle.TotalSpace.mk' F x' (cast ⋯ b) = { proj := x, snd := b }
-- Bundle.TotalSpace.mk_inj
@[simp 1001, mfld_simps 1001]
theorem TotalSpace.mk_inj {b : B} {y y' : E b} : mk' F b y = mk' F b y' ↔ y = y' 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {b : B} {y y' : E b}
Goal: Bundle.TotalSpace.mk' F b y = Bundle.TotalSpace.mk' F b y' ↔ y = y'
-- Bundle.TotalSpace.mk_injective
theorem TotalSpace.mk_injective (b : B) : Injective (mk b : E b → TotalSpace F E) 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} (b : B)
Goal: Function.Injective (Bundle.TotalSpace.mk b)
-- Bundle.TotalSpace.eta
theorem TotalSpace.eta (z : TotalSpace F E) : TotalSpace.mk z.proj z.2 = z 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} (z : Bundle.TotalSpace F E)
Goal: { proj := z.proj, snd := z.snd } = z
-- Bundle.TotalSpace.exists
@[simp]
theorem TotalSpace.exists {p : TotalSpace F E → Prop} : (∃ x, p x) ↔ ∃ b y, p ⟨b, y⟩ 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {p : Bundle.TotalSpace F E → Prop}
Goal: (∃ x, p x) ↔ ∃ b y, p { proj := b, snd := y }
-- Bundle.TotalSpace.range_mk
@[simp]
theorem TotalSpace.range_mk (b : B) : range ((↑) : E b → TotalSpace F E) = π F E ⁻¹' {b} 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} (b : B)
Goal: Set.range (Bundle.TotalSpace.mk b) = Bundle.TotalSpace.proj ⁻¹' {b}
-- Bundle.TotalSpace.toProd_symm_apply_snd
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
Arguments: (B : Type u_4) (F : Type u_5) (x : B × F)
Goal: ((Bundle.TotalSpace.toProd B F).symm x).snd = x.2
-- Bundle.TotalSpace.toProd_apply
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
Arguments: (B : Type u_4) (F : Type u_5) (x : Bundle.TotalSpace F fun x => F)
Goal: (Bundle.TotalSpace.toProd B F) x = (x.proj, x.snd)
-- Bundle.TotalSpace.toProd_symm_apply_proj
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
Arguments: (B : Type u_4) (F : Type u_5) (x : B × F)
Goal: ((Bundle.TotalSpace.toProd B F).symm x).proj = x.1
-- Bundle.Pullback.lift_snd
@[simps (config := { attrs := [`mfld_simps] })]
def Pullback.lift (f : B' → B) : TotalSpace F (f *ᵖ E) → TotalSpace F E 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {B' : Type u_4} (f : B' → B)
Goal: ∀ (a : Bundle.TotalSpace F (f *ᵖ E)), (Bundle.Pullback.lift f a).snd = a.snd
-- Bundle.Pullback.lift_proj
@[simps (config := { attrs := [`mfld_simps] })]
def Pullback.lift (f : B' → B) : TotalSpace F (f *ᵖ E) → TotalSpace F E 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {B' : Type u_4} (f : B' → B)
Goal: ∀ (a : Bundle.TotalSpace F (f *ᵖ E)), (Bundle.Pullback.lift f a).proj = f a.proj
-- Bundle.Pullback.lift_mk
@[simp, mfld_simps]
theorem Pullback.lift_mk (f : B' → B) (x : B') (y : E (f x)) :
    Pullback.lift f (.mk' F x y) = ⟨f x, y⟩ 
Arguments: {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {B' : Type u_4} (f : B' → B) (x : B') (y : E (f x))
Goal: Bundle.Pullback.lift f (Bundle.TotalSpace.mk' F x y) = { proj := f x, snd := y }
-- EmbeddingLike.injective'
class EmbeddingLike (F : Sort*) (α β : outParam (Sort*)) [FunLike F α β] : Prop where
    injective' : ∀ f : F, Function.Injective (DFunLike.coe f)
Arguments: {F : Sort u_1} {α : outParam (Sort u_2)} {β : outParam (Sort u_3)} [FunLike F α β] [self : EmbeddingLike F α β] (f : F)
Goal: Function.Injective ⇑f
-- EmbeddingLike.injective
protected theorem injective (f : F) : Function.Injective f 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [FunLike F α β] [i : EmbeddingLike F α β] (f : F)
Goal: Function.Injective ⇑f
-- EmbeddingLike.apply_eq_iff_eq
@[simp]
theorem apply_eq_iff_eq (f : F) {x y : α} : f x = f y ↔ x = y 
Arguments: {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α}
Goal: f x = f y ↔ x = y
-- EmbeddingLike.comp_injective
@[simp]
theorem comp_injective {F : Sort*} [FunLike F β γ] [EmbeddingLike F β γ] (f : α → β) (e : F) :
    Function.Injective (e ∘ f) ↔ Function.Injective f 
Arguments: {α : Sort u_2} {β : Sort u_3} {γ : Sort u_4} {F : Sort u_5} [FunLike F β γ] [EmbeddingLike F β γ] (f : α → β) (e : F)
Goal: Function.Injective (⇑e ∘ f) ↔ Function.Injective f
-- Sum.Lex.inl_sup
@[simp] lemma inl_sup (a₁ a₂ : α) : (inlₗ (a₁ ⊔ a₂) : α ⊕ β) = inlₗ a₁ ⊔ inlₗ a₂ 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeSup α] [SemilatticeSup β] (a₁ a₂ : α)
Goal: Sum.inlₗ (a₁ ⊔ a₂) = Sum.inlₗ a₁ ⊔ Sum.inlₗ a₂
-- Sum.Lex.inr_sup
@[simp] lemma inr_sup (b₁ b₂ : β) : (inrₗ (b₁ ⊔ b₂) : α ⊕ β) = inrₗ b₁ ⊔ inrₗ b₂ 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeSup α] [SemilatticeSup β] (b₁ b₂ : β)
Goal: Sum.inrₗ (b₁ ⊔ b₂) = Sum.inrₗ b₁ ⊔ Sum.inrₗ b₂
-- Sum.Lex.inl_inf
@[simp] lemma inl_inf (a₁ a₂ : α) : (inlₗ (a₁ ⊓ a₂) : α ⊕ β) = inlₗ a₁ ⊓ inlₗ a₂ 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeInf α] [SemilatticeInf β] (a₁ a₂ : α)
Goal: Sum.inlₗ (a₁ ⊓ a₂) = Sum.inlₗ a₁ ⊓ Sum.inlₗ a₂
-- Sum.Lex.inr_inf
@[simp] lemma inr_inf (b₁ b₂ : β) : (inrₗ (b₁ ⊓ b₂) : α ⊕ β) = inrₗ b₁ ⊓ inrₗ b₂ 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeInf α] [SemilatticeInf β] (b₁ b₂ : β)
Goal: Sum.inrₗ (b₁ ⊓ b₂) = Sum.inrₗ b₁ ⊓ Sum.inrₗ b₂
-- DFunLike.finite
theorem DFunLike.finite [Finite α] [∀ i, Finite (β i)] : Finite F 
Arguments: (F : Sort u_1) {α : Sort u_3} {β : α → Sort u_5} [DFunLike F α β] [Finite α] [∀ (i : α), Finite (β i)]
Goal: Finite F
-- FunLike.finite
theorem FunLike.finite [Finite α] [Finite γ] : Finite G 
Arguments: (G : Sort u_2) {α : Sort u_3} {γ : Sort u_4} [FunLike G α γ] [Finite α] [Finite γ]
Goal: Finite G
-- EquivLike.left_inv
class EquivLike (E : Sort*) (α β : outParam (Sort*)) where
    coe : E → α → β
    inv : E → β → α
    left_inv : ∀ e, Function.LeftInverse (inv e) (coe e)
    right_inv : ∀ e, Function.RightInverse (inv e) (coe e)
    coe_injective' : ∀ e g, coe e = coe g → inv e = inv g → e = g
Arguments: {E : Sort u_1} {α : outParam (Sort u_2)} {β : outParam (Sort u_3)} [self : EquivLike E α β] (e : E)
Goal: Function.LeftInverse (EquivLike.inv e) (EquivLike.coe e)
-- EquivLike.coe_injective'
class EquivLike (E : Sort*) (α β : outParam (Sort*)) where
    coe : E → α → β
    inv : E → β → α
    left_inv : ∀ e, Function.LeftInverse (inv e) (coe e)
    right_inv : ∀ e, Function.RightInverse (inv e) (coe e)
    coe_injective' : ∀ e g, coe e = coe g → inv e = inv g → e = g
Arguments: {E : Sort u_1} {α : outParam (Sort u_2)} {β : outParam (Sort u_3)} [self : EquivLike E α β] (e g : E)
Goal: EquivLike.coe e = EquivLike.coe g → EquivLike.inv e = EquivLike.inv g → e = g
-- EquivLike.right_inv
class EquivLike (E : Sort*) (α β : outParam (Sort*)) where
    coe : E → α → β
    inv : E → β → α
    left_inv : ∀ e, Function.LeftInverse (inv e) (coe e)
    right_inv : ∀ e, Function.RightInverse (inv e) (coe e)
    coe_injective' : ∀ e g, coe e = coe g → inv e = inv g → e = g
Arguments: {E : Sort u_1} {α : outParam (Sort u_2)} {β : outParam (Sort u_3)} [self : EquivLike E α β] (e : E)
Goal: Function.RightInverse (EquivLike.inv e) (EquivLike.coe e)
-- EquivLike.inv_injective
theorem inv_injective : Function.Injective (EquivLike.inv : E → β → α) 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β]
Goal: Function.Injective EquivLike.inv
-- EquivLike.injective
protected theorem injective (e : E) : Function.Injective e 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E)
Goal: Function.Injective ⇑e
-- EquivLike.surjective
protected theorem surjective (e : E) : Function.Surjective e 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E)
Goal: Function.Surjective ⇑e
-- EquivLike.bijective
protected theorem bijective (e : E) : Function.Bijective (e : α → β) 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E)
Goal: Function.Bijective ⇑e
-- EquivLike.apply_eq_iff_eq
theorem apply_eq_iff_eq (f : E) {x y : α} : f x = f y ↔ x = y 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (f : E) {x y : α}
Goal: f x = f y ↔ x = y
-- EquivLike.injective_comp
@[simp]
theorem injective_comp (e : E) (f : β → γ) : Function.Injective (f ∘ e) ↔ Function.Injective f 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iE : EquivLike E α β] (e : E) (f : β → γ)
Goal: Function.Injective (f ∘ ⇑e) ↔ Function.Injective f
-- EquivLike.surjective_comp
@[simp]
theorem surjective_comp (e : E) (f : β → γ) : Function.Surjective (f ∘ e) ↔ Function.Surjective f 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iE : EquivLike E α β] (e : E) (f : β → γ)
Goal: Function.Surjective (f ∘ ⇑e) ↔ Function.Surjective f
-- EquivLike.bijective_comp
@[simp]
theorem bijective_comp (e : E) (f : β → γ) : Function.Bijective (f ∘ e) ↔ Function.Bijective f 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iE : EquivLike E α β] (e : E) (f : β → γ)
Goal: Function.Bijective (f ∘ ⇑e) ↔ Function.Bijective f
-- EquivLike.inv_apply_apply
@[simp]
theorem inv_apply_apply (e : E) (a : α) : EquivLike.inv e (e a) = a 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E) (a : α)
Goal: EquivLike.inv e (e a) = a
-- EquivLike.apply_inv_apply
@[simp]
theorem apply_inv_apply (e : E) (b : β) : e (EquivLike.inv e b) = b 
Arguments: {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E) (b : β)
Goal: e (EquivLike.inv e b) = b
-- EquivLike.comp_injective
theorem comp_injective (f : α → β) (e : F) : Function.Injective (e ∘ f) ↔ Function.Injective f 
Arguments: {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iF : EquivLike F β γ] (f : α → β) (e : F)
Goal: Function.Injective (⇑e ∘ f) ↔ Function.Injective f
-- EquivLike.comp_surjective
@[simp]
theorem comp_surjective (f : α → β) (e : F) : Function.Surjective (e ∘ f) ↔ Function.Surjective f 
Arguments: {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iF : EquivLike F β γ] (f : α → β) (e : F)
Goal: Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f
-- EquivLike.comp_bijective
@[simp]
theorem comp_bijective (f : α → β) (e : F) : Function.Bijective (e ∘ f) ↔ Function.Bijective f 
Arguments: {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [iF : EquivLike F β γ] (f : α → β) (e : F)
Goal: Function.Bijective (⇑e ∘ f) ↔ Function.Bijective f
-- EquivLike.subsingleton_dom
lemma subsingleton_dom [Subsingleton β] : Subsingleton F 
Arguments: {F : Sort u_2} {β : Sort u_4} {γ : Sort u_5} [iF : EquivLike F β γ] [Subsingleton β]
Goal: Subsingleton F
-- WeierstrassCurve.C_Ψ₂Sq
lemma C_Ψ₂Sq : C W.Ψ₂Sq = W.ψ₂ ^ 2 - 4 * W.toAffine.polynomial 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: Polynomial.C W.Ψ₂Sq = W.ψ₂ ^ 2 - 4 * W.toAffine.polynomial
-- WeierstrassCurve.ψ₂_sq
lemma ψ₂_sq : W.ψ₂ ^ 2 = C W.Ψ₂Sq + 4 * W.toAffine.polynomial 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: W.ψ₂ ^ 2 = Polynomial.C W.Ψ₂Sq + 4 * W.toAffine.polynomial
-- WeierstrassCurve.Affine.CoordinateRing.mk_ψ₂_sq
lemma Affine.CoordinateRing.mk_ψ₂_sq : mk W W.ψ₂ ^ 2 = mk W (C W.Ψ₂Sq) 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) W.ψ₂ ^ 2 =
  (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C W.Ψ₂Sq)
-- WeierstrassCurve.Ψ₂Sq_eq
lemma Ψ₂Sq_eq : W.Ψ₂Sq = W.twoTorsionPolynomial.toPoly 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: W.Ψ₂Sq = W.twoTorsionPolynomial.toPoly
-- WeierstrassCurve.preΨ'_zero
@[simp]
lemma preΨ'_zero : W.preΨ' 0 = 0 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: W.preΨ' 0 = 0
-- WeierstrassCurve.preΨ'_one
@[simp]
lemma preΨ'_one : W.preΨ' 1 = 1 
Arguments: {R : Type r} [CommRing R] (W : WeierstrassCurve R)
Goal: W.preΨ' 1 = 1