ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Logic/Godel/GodelBetaFunction.lean

full_name: Nat.coprime_mul_succ
code: lemma coprime_mul_succ {n m a} (h : n ≤ m) (ha : m - n ∣ a) : Coprime (n * a + 1) (m * a + 1) 
goal: (n * a + 1).Coprime (m * a + 1)

full_name: _private.Mathlib.Logic.Godel.GodelBetaFunction.0.Nat.supOfSeq
code: private def supOfSeq (a : Fin m → ℕ) : ℕ 
goal: ℕ

full_name: _private.Mathlib.Logic.Godel.GodelBetaFunction.0.Nat.coprimes
code: private def coprimes (a : Fin m → ℕ) : Fin m → ℕ 
goal: Fin m → ℕ

full_name: Nat.coprimes_lt
code: lemma coprimes_lt (a : Fin m → ℕ) (i) : a i < coprimes a i 
goal: a i < Nat.coprimes a i

full_name: _private.Mathlib.Logic.Godel.GodelBetaFunction.0.Nat.pairwise_coprime_coprimes
code: private lemma pairwise_coprime_coprimes (a : Fin m → ℕ) : Pairwise (Coprime on coprimes a) 
goal: Pairwise (Nat.Coprime on Nat.coprimes a)

full_name: Nat.beta
code: /-- Gödel's Beta Function. This is similar to `(Encodable.decodeList).get i`, but it is easier to
prove that it is arithmetically definable. -/
def beta (n i : ℕ) : ℕ 
goal: ℕ

full_name: Nat.unbeta
code: /-- Inverse of Gödel's Beta Function. This is similar to `Encodable.encodeList`, but it is easier
to prove that it is arithmetically definable. -/
def unbeta (l : List ℕ) : ℕ 
goal: ℕ

full_name: Nat.beta_unbeta_coe
code: /-- **Gödel's Beta Function Lemma** -/
lemma beta_unbeta_coe (l : List ℕ) (i : Fin l.length) : beta (unbeta l) i = l.get i 
goal: (Nat.unbeta l).beta ↑i = l.get i
File: Mathlib/Logic/Equiv/Embedding.lean

full_name: Equiv.sumEmbeddingEquivProdEmbeddingDisjoint
code: /-- Embeddings from a sum type are equivalent to two separate embeddings with disjoint ranges. -/
def sumEmbeddingEquivProdEmbeddingDisjoint {α β γ : Type*} :
    (α ⊕ β ↪ γ) ≃ { f : (α ↪ γ) × (β ↪ γ) // Disjoint (Set.range f.1) (Set.range f.2) } 
goal: (α ⊕ β ↪ γ) ≃ { f // Disjoint (Set.range ⇑f.1) (Set.range ⇑f.2) }

full_name: Equiv.codRestrict
code: /-- Embeddings whose range lies within a set are equivalent to embeddings to that set.
This is `Function.Embedding.codRestrict` as an equiv. -/
def codRestrict (α : Type*) {β : Type*} (bs : Set β) :
    { f : α ↪ β // ∀ a, f a ∈ bs } ≃
      (α ↪ bs) 
goal: { f // ∀ (a : α), f a ∈ bs } ≃ (α ↪ ↑bs)

full_name: Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted
code: /-- Pairs of embeddings with disjoint ranges are equivalent to a dependent sum of embeddings,
in which the second embedding cannot take values in the range of the first. -/
def prodEmbeddingDisjointEquivSigmaEmbeddingRestricted {α β γ : Type*} :
    { f : (α ↪ γ) × (β ↪ γ) // Disjoint (Set.range f.1) (Set.range f.2) } ≃
      Σf : α ↪ γ, β ↪ ↥(Set.range f)ᶜ 
goal: { f // Disjoint (Set.range ⇑f.1) (Set.range ⇑f.2) } ≃ (f : α ↪ γ) × (β ↪ ↑(Set.range ⇑f)ᶜ)

full_name: Equiv.sumEmbeddingEquivSigmaEmbeddingRestricted
code: /-- A combination of the above results, allowing us to turn one embedding over a sum type
into two dependent embeddings, the second of which avoids any members of the range
of the first. This is helpful for constructing larger embeddings out of smaller ones. -/
def sumEmbeddingEquivSigmaEmbeddingRestricted {α β γ : Type*} :
    (α ⊕ β ↪ γ) ≃ Σf : α ↪ γ, β ↪ ↥(Set.range f)ᶜ 
goal: (α ⊕ β ↪ γ) ≃ (f : α ↪ γ) × (β ↪ ↑(Set.range ⇑f)ᶜ)

full_name: Equiv.uniqueEmbeddingEquivResult
code: /-- Embeddings from a single-member type are equivalent to members of the target type. -/
def uniqueEmbeddingEquivResult {α β : Type*} [Unique α] :
    (α ↪ β) ≃ β 
goal: (α ↪ β) ≃ β
File: Mathlib/Logic/Equiv/Nat.lean

full_name: Equiv.boolProdNatEquivNat_apply
code: /-- An equivalence between `Bool × ℕ` and `ℕ`, by mapping `(true, x)` to `2 * x + 1` and
`(false, x)` to `2 * x`. -/
@[simps]
def boolProdNatEquivNat : Bool × ℕ ≃ ℕ 
goal: ∀ (a : Bool × ℕ), Equiv.boolProdNatEquivNat a = Function.uncurry Nat.bit a

full_name: Equiv.boolProdNatEquivNat
code: /-- An equivalence between `Bool × ℕ` and `ℕ`, by mapping `(true, x)` to `2 * x + 1` and
`(false, x)` to `2 * x`. -/
@[simps]
def boolProdNatEquivNat : Bool × ℕ ≃ ℕ 
goal: Bool × ℕ ≃ ℕ

full_name: Equiv.boolProdNatEquivNat_symm_apply
code: /-- An equivalence between `Bool × ℕ` and `ℕ`, by mapping `(true, x)` to `2 * x + 1` and
`(false, x)` to `2 * x`. -/
@[simps]
def boolProdNatEquivNat : Bool × ℕ ≃ ℕ 
goal: ∀ (a : ℕ), Equiv.boolProdNatEquivNat.symm a = a.boddDiv2

full_name: Equiv.natSumNatEquivNat
code: /-- An equivalence between `ℕ ⊕ ℕ` and `ℕ`, by mapping `(Sum.inl x)` to `2 * x` and `(Sum.inr x)` to
`2 * x + 1`.
-/
@[simps! symm_apply]
def natSumNatEquivNat : ℕ ⊕ ℕ ≃ ℕ 
goal: ℕ ⊕ ℕ ≃ ℕ

full_name: Equiv.natSumNatEquivNat_symm_apply
code: /-- An equivalence between `ℕ ⊕ ℕ` and `ℕ`, by mapping `(Sum.inl x)` to `2 * x` and `(Sum.inr x)` to
`2 * x + 1`.
-/
@[simps! symm_apply]
def natSumNatEquivNat : ℕ ⊕ ℕ ≃ ℕ 
goal: ∀ (a : ℕ), Equiv.natSumNatEquivNat.symm a = Bool.rec (Sum.inl a.div2) (Sum.inr a.div2) a.bodd

full_name: Equiv.natSumNatEquivNat_apply
code: @[simp]
theorem natSumNatEquivNat_apply : ⇑natSumNatEquivNat = Sum.elim (2 * ·) (2 * · + 1) 
goal: ⇑Equiv.natSumNatEquivNat = Sum.elim (fun x => 2 * x) fun x => 2 * x + 1

full_name: Equiv.intEquivNat
code: /-- An equivalence between `ℤ` and `ℕ`, through `ℤ ≃ ℕ ⊕ ℕ` and `ℕ ⊕ ℕ ≃ ℕ`.
-/
def intEquivNat : ℤ ≃ ℕ 
goal: ℤ ≃ ℕ

full_name: Equiv.prodEquivOfEquivNat
code: /-- An equivalence between `α × α` and `α`, given that there is an equivalence between `α` and `ℕ`.
-/
def prodEquivOfEquivNat (e : α ≃ ℕ) : α × α ≃ α 
goal: α × α ≃ α
File: Mathlib/Logic/Equiv/Array.lean

full_name: Equiv.arrayEquivList
code: /-- The natural equivalence between arrays and lists. -/
def arrayEquivList (α : Type*) : Array α ≃ List α 
goal: Array α ≃ List α

full_name: Array.encodable
code: /-- If `α` is encodable, then so is `Array α`. -/
instance Array.encodable {α} [Encodable α] : Encodable (Array α) 
goal: Encodable (Array α)

full_name: Array.countable
code: /-- If `α` is countable, then so is `Array α`. -/
instance Array.countable {α} [Countable α] : Countable (Array α) 
goal: Countable (Array α)
File: Mathlib/Logic/Equiv/Functor.lean

full_name: Functor.mapEquiv
code: /-- Apply a functor to an `Equiv`. -/
def mapEquiv (h : α ≃ β) : f α ≃ f β 
goal: f α ≃ f β

full_name: Functor.mapEquiv_apply
code: @[simp]
theorem mapEquiv_apply (h : α ≃ β) (x : f α) : (mapEquiv f h : f α ≃ f β) x = map h x 
goal: (Functor.mapEquiv f h) x = ⇑h <$> x

full_name: Functor.mapEquiv_symm_apply
code: @[simp]
theorem mapEquiv_symm_apply (h : α ≃ β) (y : f β) :
    (mapEquiv f h : f α ≃ f β).symm y = map h.symm y 
goal: (Functor.mapEquiv f h).symm y = ⇑h.symm <$> y

full_name: Functor.mapEquiv_refl
code: @[simp]
theorem mapEquiv_refl : mapEquiv f (Equiv.refl α) = Equiv.refl (f α) 
goal: Functor.mapEquiv f (Equiv.refl α) = Equiv.refl (f α)

full_name: Bifunctor.mapEquiv
code: /-- Apply a bifunctor to a pair of `Equiv`s. -/
def mapEquiv (h : α ≃ β) (h' : α' ≃ β') : F α α' ≃ F β β' 
goal: F α α' ≃ F β β'

full_name: Bifunctor.mapEquiv_apply
code: @[simp]
theorem mapEquiv_apply (h : α ≃ β) (h' : α' ≃ β') (x : F α α') :
    (mapEquiv F h h' : F α α' ≃ F β β') x = bimap h h' x 
goal: (Bifunctor.mapEquiv F h h') x = bimap (⇑h) (⇑h') x

full_name: Bifunctor.mapEquiv_symm_apply
code: @[simp]
theorem mapEquiv_symm_apply (h : α ≃ β) (h' : α' ≃ β') (y : F β β') :
    (mapEquiv F h h' : F α α' ≃ F β β').symm y = bimap h.symm h'.symm y 
goal: (Bifunctor.mapEquiv F h h').symm y = bimap (⇑h.symm) (⇑h'.symm) y

full_name: Bifunctor.mapEquiv_refl_refl
code: @[simp]
theorem mapEquiv_refl_refl : mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α') 
goal: Bifunctor.mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α')
File: Mathlib/Logic/Equiv/Pairwise.lean

full_name: EmbeddingLike.pairwise_comp
code: lemma EmbeddingLike.pairwise_comp {X : Type*} {Y : Type*} {F} [FunLike F Y X] [EmbeddingLike F Y X]
    (f : F) {p : X → X → Prop} (h : Pairwise p) : Pairwise (p on f) 
goal: Pairwise (p on ⇑f)

full_name: EquivLike.pairwise_comp_iff
code: lemma EquivLike.pairwise_comp_iff {X : Type*} {Y : Type*} {F} [EquivLike F Y X]
    (f : F) (p : X → X → Prop) : Pairwise (p on f) ↔ Pairwise p 
goal: Pairwise (p on ⇑f) ↔ Pairwise p
File: Mathlib/Logic/Function/OfArity.lean

full_name: Function.OfArity
code: /-- The type of `n`-ary functions `α → α → ... → β`.

Note that this is not universe polymorphic, as this would require that when `n=0` we produce either
`Unit → β` or `ULift β`. -/
abbrev OfArity (α β : Type u) (n : ℕ) : Type u 
goal: Type u

full_name: Function.ofArity_zero
code: @[simp]
theorem ofArity_zero (α β : Type u) : OfArity α β 0 = β 
goal: Function.OfArity α β 0 = β

full_name: Function.ofArity_succ
code: @[simp]
theorem ofArity_succ (α β : Type u) (n : ℕ) :
    OfArity α β n.succ = (α → OfArity α β n) 
goal: Function.OfArity α β n.succ = (α → Function.OfArity α β n)

full_name: Function.OfArity.const
code: /-- Constant `n`-ary function with value `b`. -/
def const (α : Type u) {β : Type u} (b : β) (n : ℕ) : OfArity α β n 
goal: Function.OfArity α β n

full_name: Function.OfArity.const_zero
code: @[simp]
theorem const_zero (α : Type u) {β : Type u} (b : β) : const α b 0 = b 
goal: Function.OfArity.const α b 0 = b

full_name: Function.OfArity.const_succ
code: @[simp]
theorem const_succ (α : Type u) {β : Type u} (b : β) (n : ℕ) :
    const α b n.succ = fun _ => const _ b n 
goal: Function.OfArity.const α b n.succ = fun x => Function.OfArity.const α b n

full_name: Function.OfArity.const_succ_apply
code: theorem const_succ_apply (α : Type u) {β : Type u} (b : β) (n : ℕ) (x : α) :
    const α b n.succ x = const _ b n 
goal: Function.OfArity.const α b n.succ x = Function.OfArity.const α b n

full_name: Function.OfArity.inhabited
code: instance inhabited {α β n} [Inhabited β] : Inhabited (OfArity α β n) 
goal: Inhabited (Function.OfArity α β n)

full_name: Function.FromTypes.fromTypes_fin_const
code: lemma fromTypes_fin_const (α β : Type u) (n : ℕ) :
    FromTypes (fun (_ : Fin n) => α) β = OfArity α β n 
goal: Function.FromTypes (fun x => α) β = Function.OfArity α β n

full_name: Function.FromTypes.fromTypes_fin_const_equiv
code: /-- The definitional equality between heterogeneous functions with constant
domain and `n`-ary functions with that domain. -/
def fromTypes_fin_const_equiv (α β : Type u) (n : ℕ) :
    FromTypes (fun (_ : Fin n) => α) β ≃ OfArity α β n 
goal: Function.FromTypes (fun x => α) β ≃ Function.OfArity α β n
File: Mathlib/Logic/Function/CompTypeclasses.lean

full_name: CompTriple
code: /-- Class of composing triples -/
class CompTriple  {M N P : Type*} (φ : M → N) (ψ : N → P) (χ : outParam (M → P)) : Prop where
  /-- The maps form a commuting triangle -/
  comp_eq : ψ.comp φ = χ
goal: Prop

full_name: CompTriple.comp_eq
code: /-- Class of composing triples -/
class CompTriple  {M N P : Type*} (φ : M → N) (ψ : N → P) (χ : outParam (M → P)) : Prop where
  /-- The maps form a commuting triangle -/
  comp_eq : ψ.comp φ = χ
goal: ψ ∘ φ = χ

full_name: CompTriple.IsId
code: /-- Class of Id maps -/
class IsId {M : Type*} (σ : M → M) : Prop where
  eq_id : σ = id
goal: Prop

full_name: CompTriple.IsId.eq_id
code: /-- Class of Id maps -/
class IsId {M : Type*} (σ : M → M) : Prop where
  eq_id : σ = id
goal: σ = id

full_name: CompTriple.instIsIdId
code: instance {M : Type*} : IsId (@id M) 
goal: CompTriple.IsId id

full_name: CompTriple.instComp_id
code: instance instComp_id {N P : Type*} {φ : N → N} [IsId φ] {ψ : N → P} :
    CompTriple φ ψ ψ 
goal: CompTriple φ ψ ψ

full_name: CompTriple.instId_comp
code: instance instId_comp {M N : Type*} {φ : M → N} {ψ : N → N} [IsId ψ] :
    CompTriple φ ψ φ 
goal: CompTriple φ ψ φ

full_name: CompTriple.comp
code: /-- `φ`, `ψ` and `ψ ∘ φ` for` a `CompTriple` -/
theorem comp {M N P : Type*}
    {φ : M → N} {ψ : N → P} :
    CompTriple φ ψ  (ψ.comp φ) 
goal: CompTriple φ ψ (ψ ∘ φ)

full_name: CompTriple.comp_inv
code: lemma comp_inv {M N : Type*} {φ : M → N} {ψ : N → M}
    (h : Function.RightInverse φ ψ) {χ : M → M} [IsId χ] :
    CompTriple φ ψ χ 
goal: CompTriple φ ψ χ

full_name: CompTriple.comp_apply
code: lemma comp_apply {M N P : Type*}
    {φ : M → N} {ψ : N → P} {χ : M → P} (h : CompTriple φ ψ χ) (x : M) :
    ψ (φ x) = χ x 
goal: ψ (φ x) = χ x
File: Mathlib/Logic/Function/ULift.lean

full_name: ULift.down_injective
code: theorem ULift.down_injective {α : Sort _} : Function.Injective (@ULift.down α)
  
goal: Function.Injective ULift.down

full_name: ULift.down_inj
code: @[simp] theorem ULift.down_inj {α : Sort _} {a b : ULift α} : a.down = b.down ↔ a = b 
goal: a.down = b.down ↔ a = b

full_name: PLift.down_injective
code: theorem PLift.down_injective : Function.Injective (@PLift.down α)
  
goal: Function.Injective PLift.down

full_name: PLift.down_inj
code: @[simp] theorem PLift.down_inj {a b : PLift α} : a.down = b.down ↔ a = b 
goal: a.down = b.down ↔ a = b
File: Mathlib/Logic/Small/Basic.lean

full_name: small_subtype
code: instance small_subtype (α : Type v) [Small.{w} α] (P : α → Prop) : Small.{w} { x // P x } 
goal: Small.{w, v} { x // P x }

full_name: small_of_injective
code: theorem small_of_injective {α : Type v} {β : Type w} [Small.{u} β] {f : α → β}
    (hf : Function.Injective f) : Small.{u} α 
goal: Small.{u, v} α

full_name: small_of_surjective
code: theorem small_of_surjective {α : Type v} {β : Type w} [Small.{u} α] {f : α → β}
    (hf : Function.Surjective f) : Small.{u} β 
goal: Small.{u, w} β

full_name: small_subsingleton
code: instance (priority := 100) small_subsingleton (α : Type v) [Subsingleton α] : Small.{w} α 
goal: Small.{w, v} α

full_name: small_of_injective_of_exists
code: /-- This can be seen as a version of `small_of_surjective` in which the function `f` doesn't
    actually land in `β` but in some larger type `γ` related to `β` via an injective function `g`.
    -/
theorem small_of_injective_of_exists {α : Type v} {β : Type w} {γ : Type v'} [Small.{u} α]
    (f : α → γ) {g : β → γ} (hg : Function.Injective g) (h : ∀ b : β, ∃ a : α, f a = g b) :
    Small.{u} β 
goal: Small.{u, w} β

full_name: small_Pi
code: instance small_Pi {α} (β : α → Type*) [Small.{w} α] [∀ a, Small.{w} (β a)] :
    Small.{w} (∀ a, β a) 
goal: Small.{w, max u_1 u_2} ((a : α) → β a)

full_name: small_prod
code: instance small_prod {α β} [Small.{w} α] [Small.{w} β] : Small.{w} (α × β) 
goal: Small.{w, max u_2 u_1} (α × β)

full_name: small_sum
code: instance small_sum {α β} [Small.{w} α] [Small.{w} β] : Small.{w} (α ⊕ β) 
goal: Small.{w, max u_2 u_1} (α ⊕ β)

full_name: small_set
code: instance small_set {α} [Small.{w} α] : Small.{w} (Set α) 
goal: Small.{w, u_1} (Set α)
File: Mathlib/Logic/Small/List.lean

full_name: smallVector
code: instance smallVector {α : Type v} {n : ℕ} [Small.{u} α] : Small.{u} (Vector α n) 
goal: Small.{u, v} (Mathlib.Vector α n)

full_name: smallList
code: instance smallList {α : Type v} [Small.{u} α] : Small.{u} (List α) 
goal: Small.{u, v} (List α)
File: Mathlib/Logic/Small/Set.lean

full_name: small_subset
code: theorem small_subset {α : Type v} {s t : Set α} (hts : t ⊆ s) [Small.{u} s] : Small.{u} t 
goal: Small.{u, v} ↑t

full_name: small_range
code: instance small_range {α : Type v} {β : Type w} (f : α → β) [Small.{u} α] :
    Small.{u} (Set.range f) 
goal: Small.{u, w} ↑(Set.range f)

full_name: small_image
code: instance small_image {α : Type v} {β : Type w} (f : α → β) (S : Set α) [Small.{u} S] :
    Small.{u} (f '' S) 
goal: Small.{u, w} ↑(f '' S)

full_name: small_union
code: instance small_union {α : Type v} (s t : Set α) [Small.{u} s] [Small.{u} t] :
    Small.{u} (s ∪ t : Set α) 
goal: Small.{u, v} ↑(s ∪ t)

full_name: small_iUnion
code: instance small_iUnion {α : Type v} {ι : Type w} [Small.{u} ι] (s : ι → Set α)
    [∀ i, Small.{u} (s i)] : Small.{u} (⋃ i, s i) 
goal: Small.{u, v} ↑(⋃ i, s i)

full_name: small_sUnion
code: instance small_sUnion {α : Type v} (s : Set (Set α)) [Small.{u} s] [∀ t : s, Small.{u} t] :
    Small.{u} (⋃₀ s) 
goal: Small.{u, v} ↑(⋃₀ s)
File: Mathlib/Logic/UnivLE.lean

full_name: UnivLE
code: /--
A class expressing a universe inequality. `UnivLE.{u, v}` expresses that `u ≤ v`.

There used to be a stronger definition `∀ α : Type max u v, Small.{v} α` that immediately implies
`Small.{v} ((α : Type u) → (β : Type v))` which is essential for proving that `Type v` has
`Type u`-indexed limits when `u ≤ v`. However the current weaker condition
`∀ α : Type u, Small.{v} α` also implies the same, so we switched to use it for
its simplicity and transitivity.

The strong definition easily implies the weaker definition (see below),
but we can not prove the reverse implication.
This is because in Lean's type theory, while `max u v` is at least at big as `u` and `v`,
it could be bigger than both!
See also `Mathlib.CategoryTheory.UnivLE` for the statement that the stronger definition is
equivalent to `EssSurj (uliftFunctor : Type v ⥤ Type max u v)`.
-/
@[pp_with_univ]
abbrev UnivLE.{u, v} : Prop 
goal: Prop

full_name: univLE_max
code: theorem univLE_max : UnivLE.{u, max u v} 
goal: UnivLE.{u, max u v}

full_name: Small.trans_univLE
code: theorem Small.trans_univLE.{u, v} (α : Type w) [hα : Small.{u} α] [h : UnivLE.{u, v}] :
    Small.{v} α 
goal: Small.{v, w} α

full_name: UnivLE.trans
code: theorem UnivLE.trans [UnivLE.{u, v}] [UnivLE.{v, w}] : UnivLE.{u, w} 
goal: UnivLE.{u, w}

full_name: univLE_of_max
code: instance univLE_of_max [UnivLE.{max u v, v}] : UnivLE.{u, v} 
goal: UnivLE.{u, v}
File: Mathlib/Logic/Small/Module.lean

full_name: instModuleShrink
code: instance [Semiring α] [AddCommMonoid β] [Module α β] [Small β] : Module α (Shrink β) 
goal: Module α (Shrink.{u_3, u_2} β)

full_name: linearEquivShrink
code: /-- A small module is linearly equivalent to its small model. -/
def linearEquivShrink (α β) [Semiring α] [AddCommMonoid β] [Module α β] [Small β] :
    β ≃ₗ[α] Shrink β 
goal: β ≃ₗ[α] Shrink.{u_5, u_4} β

full_name: instAlgebraShrink
code: instance [CommSemiring α] [Semiring β] [Algebra α β] [Small β] : Algebra α (Shrink β) 
goal: Algebra α (Shrink.{u_3, u_2} β)

full_name: algEquivShrink
code: /-- A small algebra is algebra equivalent to its small model. -/
def algEquivShrink (α β) [CommSemiring α] [Semiring β] [Algebra α β] [Small β] :
    β ≃ₐ[α] Shrink β 
goal: β ≃ₐ[α] Shrink.{u_5, u_4} β
File: Mathlib/Logic/Small/Ring.lean

full_name: instNonUnitalNonAssocSemiringShrink
code: instance [NonUnitalNonAssocSemiring α] [Small α] : NonUnitalNonAssocSemiring (Shrink α) 
goal: NonUnitalNonAssocSemiring (Shrink.{u_2, u_1} α)

full_name: instNonUnitalSemiringShrink
code: instance [NonUnitalSemiring α] [Small α] : NonUnitalSemiring (Shrink α) 
goal: NonUnitalSemiring (Shrink.{u_2, u_1} α)

full_name: instAddMonoidWithOneShrink
code: instance [AddMonoidWithOne α] [Small α] : AddMonoidWithOne (Shrink α) 
goal: AddMonoidWithOne (Shrink.{u_2, u_1} α)

full_name: instAddGroupWithOneShrink
code: instance [AddGroupWithOne α] [Small α] : AddGroupWithOne (Shrink α) 
goal: AddGroupWithOne (Shrink.{u_2, u_1} α)

full_name: instNonAssocSemiringShrink
code: instance [NonAssocSemiring α] [Small α] : NonAssocSemiring (Shrink α) 
goal: NonAssocSemiring (Shrink.{u_2, u_1} α)

full_name: instSemiringShrink
code: instance [Semiring α] [Small α] : Semiring (Shrink α) 
goal: Semiring (Shrink.{u_2, u_1} α)

full_name: instNonUnitalCommSemiringShrink
code: instance [NonUnitalCommSemiring α] [Small α] : NonUnitalCommSemiring (Shrink α) 
goal: NonUnitalCommSemiring (Shrink.{u_2, u_1} α)

full_name: instCommSemiringShrink
code: instance [CommSemiring α] [Small α] : CommSemiring (Shrink α) 
goal: CommSemiring (Shrink.{u_2, u_1} α)

full_name: instNonUnitalNonAssocRingShrink
code: instance [NonUnitalNonAssocRing α] [Small α] : NonUnitalNonAssocRing (Shrink α) 
goal: NonUnitalNonAssocRing (Shrink.{u_2, u_1} α)

full_name: instNonUnitalRingShrink
code: instance [NonUnitalRing α] [Small α] : NonUnitalRing (Shrink α) 
goal: NonUnitalRing (Shrink.{u_2, u_1} α)

full_name: instRingShrink
code: instance [Ring α] [Small α] : Ring (Shrink α) 
goal: Ring (Shrink.{u_2, u_1} α)

full_name: instNonUnitalCommRingShrink
code: instance [NonUnitalCommRing α] [Small α] : NonUnitalCommRing (Shrink α) 
goal: NonUnitalCommRing (Shrink.{u_2, u_1} α)

full_name: instCommRingShrink
code: instance [CommRing α] [Small α] : CommRing (Shrink α) 
goal: CommRing (Shrink.{u_2, u_1} α)

full_name: instNontrivialShrink
code: instance [Nontrivial α] [Small α] : Nontrivial (Shrink α) 
goal: Nontrivial (Shrink.{u_2, u_1} α)

full_name: instDivisionRingShrink
code: instance [DivisionRing α] [Small α] : DivisionRing (Shrink α) 
goal: DivisionRing (Shrink.{u_2, u_1} α)

full_name: instFieldShrink
code: instance [Field α] [Small α] : Field (Shrink α) 
goal: Field (Shrink.{u_2, u_1} α)
File: Mathlib/Logic/Nontrivial/Basic.lean

full_name: nontrivial_of_lt
code: theorem nontrivial_of_lt [Preorder α] (x y : α) (h : x < y) : Nontrivial α 
goal: Nontrivial α

full_name: exists_pair_lt
code: theorem exists_pair_lt (α : Type*) [Nontrivial α] [LinearOrder α] : ∃ x y : α, x < y 
goal: ∃ x y, x < y

full_name: nontrivial_iff_lt
code: theorem nontrivial_iff_lt [LinearOrder α] : Nontrivial α ↔ ∃ x y : α, x < y 
goal: Nontrivial α ↔ ∃ x y, x < y

full_name: Subtype.nontrivial_iff_exists_ne
code: theorem Subtype.nontrivial_iff_exists_ne (p : α → Prop) (x : Subtype p) :
    Nontrivial (Subtype p) ↔ ∃ (y : α) (_ : p y), y ≠ x 
goal: Nontrivial (Subtype p) ↔ ∃ y x_1, y ≠ ↑x

full_name: nontrivialPSumUnique
code: /-- An inhabited type is either nontrivial, or has a unique element. -/
noncomputable def nontrivialPSumUnique (α : Type*) [Inhabited α] :
    Nontrivial α ⊕' Unique α 
goal: Nontrivial α ⊕' Unique α

full_name: Option.nontrivial
code: instance Option.nontrivial [Nonempty α] : Nontrivial (Option α) 
goal: Nontrivial (Option α)

full_name: Function.Injective.nontrivial
code: /-- Pushforward a `Nontrivial` instance along an injective function. -/
protected theorem Function.Injective.nontrivial [Nontrivial α] {f : α → β}
    (hf : Function.Injective f) : Nontrivial β 
goal: Nontrivial β

full_name: Function.Injective.exists_ne
code: /-- An injective function from a nontrivial type has an argument at
which it does not take a given value. -/
protected theorem Function.Injective.exists_ne [Nontrivial α] {f : α → β}
    (hf : Function.Injective f) (y : β) : ∃ x, f x ≠ y 
goal: ∃ x, f x ≠ y

full_name: nontrivial_prod_right
code: instance nontrivial_prod_right [Nonempty α] [Nontrivial β] : Nontrivial (α × β) 
goal: Nontrivial (α × β)

full_name: nontrivial_prod_left
code: instance nontrivial_prod_left [Nontrivial α] [Nonempty β] : Nontrivial (α × β) 
goal: Nontrivial (α × β)

full_name: Pi.nontrivial_at
code: /-- A pi type is nontrivial if it's nonempty everywhere and nontrivial somewhere. -/
theorem nontrivial_at (i' : I) [inst : ∀ i, Nonempty (f i)] [Nontrivial (f i')] :
    Nontrivial (∀ i : I, f i) 
goal: Nontrivial ((i : I) → f i)

full_name: Pi.nontrivial
code: /-- As a convenience, provide an instance automatically if `(f default)` is nontrivial.

If a different index has the non-trivial type, then use `haveI := nontrivial_at that_index`.
-/
instance nontrivial [Inhabited I] [∀ i, Nonempty (f i)] [Nontrivial (f default)] :
    Nontrivial (∀ i : I, f i) 
goal: Nontrivial ((i : I) → f i)

full_name: Function.nontrivial
code: instance Function.nontrivial [h : Nonempty α] [Nontrivial β] : Nontrivial (α → β) 
goal: Nontrivial (α → β)

full_name: Subsingleton.le
code: @[nontriviality]
protected theorem Subsingleton.le [Preorder α] [Subsingleton α] (x y : α) : x ≤ y 
goal: x ≤ y

full_name: Subsingleton.eq_zero
code: @[to_additive]
theorem Subsingleton.eq_one [One α] [Subsingleton α] (a : α) : a = 1 
goal: a = 0

full_name: Subsingleton.eq_one
code: @[to_additive]
theorem Subsingleton.eq_one [One α] [Subsingleton α] (a : α) : a = 1 
goal: a = 1