name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.sub_subset_sub | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ - s₂ ⊆ t₁ - t₂ | true |
Order.Icc_pred_right | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc b (Order.pred a) = Set.Ico b a | true |
Lean.Elab.Tactic.Location.ctorIdx | Lean.Elab.Tactic.Location | Lean.Elab.Tactic.Location → ℕ | false |
MvPolynomial.pUnitAlgEquiv | Mathlib.Algebra.MvPolynomial.Equiv | (R : Type u) → [inst : CommSemiring R] → MvPolynomial PUnit.{u_2 + 1} R ≃ₐ[R] Polynomial R | true |
Std.ExtHashMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a fallback : α}, m.contains a = true → m.getKey? a = some (m.getKeyD a fallback) | true |
CondensedSet.toTopCat | Mathlib.Condensed.TopCatAdjunction | CondensedSet → TopCat | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_326 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a,
g
(g
a)])[List.idxOfNth w_1 [g a, g (g a)]
(List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1))] <
[g a, g (g a)].length | false |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.isStablyFiniteRing_iff_injective_of_surjective.match_1_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {A : Type u_1} [inst : Semiring A] (n : ℕ) (f : Module.End A (Fin n → A))
(motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : (Fin n → A) →ₗ[A] Fin n → A) (eq : f ∘ₗ g = LinearMap.id), motive ⋯) → motive x | false |
Std.Time.Internal.Bounded.LE.truncate._proof_2 | Std.Time.Internal.Bounded | ∀ {n m : ℤ} (bounded : Std.Time.Internal.Bounded.LE n m),
n ≤ ↑bounded → ↑bounded ≤ m → 0 ≤ ↑bounded - n ∧ ↑bounded - n ≤ m - n | false |
CategoryTheory.NatIso.cancel_natIso_hom_right_assoc | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F ≅ G) {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y) (f' : W ⟶ X')
(g' : X' ⟶ F.obj Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g (α.hom.app Y)) =
CategoryTheory.CategoryStruct.comp f' (CategoryTheory.CategoryStruct.comp g' (α.hom.app Y)) ↔
CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f' g' | true |
_private.Mathlib.Analysis.Normed.Operator.NormedSpace.0.LinearMap.antilipschitz_of_comap_nhds_le._simp_1_3 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {F : Type u_8} {G₀ : Type u_9} {G₀' : Type u_10} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ), f x ^ n = f (x ^ n) | false |
Std.DHashMap.Raw.Const.get_filter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k : α} {h' : k ∈ Std.DHashMap.Raw.filter f m}
(h : m.WF), Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.filter f m) k h' = Std.DHashMap.Raw.Const.get m k ⋯ | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_eq._simp_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (w : ℕ), (0 < 2 ^ w) = True | false |
Std.DTreeMap.Raw.getD_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {fallback : β k'} {f : Option (β k) → Option (β k)},
(t.alter k f).getD k' fallback =
if heq : cmp k k' = Ordering.eq then (Option.map (cast ⋯) (f (t.get? k))).getD fallback else t.getD k' fallback | true |
_private.Init.Data.Int.LemmasAux.0.Int.mul_le_mul_of_natAbs_le._proof_1_7 | Init.Data.Int.LemmasAux | ∀ {x : ℤ} {y : ℤ} {s t : ℕ}, 0 < x → ¬0 ≤ x → False | false |
CategoryTheory.monadicOfReflective._proof_1 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {R : CategoryTheory.Functor D C}
[inst_2 : CategoryTheory.Reflective R],
(CategoryTheory.Monad.comparison (CategoryTheory.reflectorAdjunction R)).Faithful | false |
CoeOut.casesOn | Init.Coe | {α : Sort u} →
{β : Sort v} →
{motive : CoeOut α β → Sort u_1} → (t : CoeOut α β) → ((coe : α → β) → motive { coe := coe }) → motive t | false |
compactlyGeneratedSpace_of_isOpen_of_t2 | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [T2Space X],
(∀ (s : Set X), (∀ (K : Set X), IsCompact K → IsOpen (Subtype.val ⁻¹' s)) → IsOpen s) → CompactlyGeneratedSpace X | true |
CategoryTheory.Classifier.mkOfTerminalΩ₀ | Mathlib.CategoryTheory.Topos.Classifier | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Ω₀ : C) →
(t : CategoryTheory.Limits.IsTerminal Ω₀) →
(Ω : C) →
(truth : Ω₀ ⟶ Ω) →
(χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω) →
(∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m],
CategoryTheory.IsPullback m (t.from U) (χ m) truth) →
(∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m] (χ' : X ⟶ Ω),
CategoryTheory.IsPullback m (t.from U) χ' truth → χ' = χ m) →
CategoryTheory.Classifier C | true |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.mkResultPos._sparseCasesOn_4 | Lean.Meta.Sym.Apply | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
DirectSum.GNonUnitalNonAssocSemiring.noConfusionType | Mathlib.Algebra.DirectSum.Ring | Sort u →
{ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
DirectSum.GNonUnitalNonAssocSemiring A →
{ι' : Type u_1} →
{A' : ι' → Type u_2} →
[inst' : Add ι'] →
[inst'_1 : (i : ι') → AddCommMonoid (A' i)] → DirectSum.GNonUnitalNonAssocSemiring A' → Sort u | false |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_5 | Init.Data.String.Extra | ∀ {s : String} (it : s.Pos) (r : String) (h : ¬it.IsAtEnd),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inr ⟨it.next h, r.push (it.get h)⟩) (PSum.inr ⟨it, r⟩) | false |
Nat.count_one | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p], Nat.count p 1 = if p 0 then 1 else 0 | true |
AddAction.BlockMem.instNontrivial | Mathlib.GroupTheory.GroupAction.Blocks | ∀ (G : Type u_1) [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] [Nontrivial X] (a : X),
Nontrivial (AddAction.BlockMem G a) | true |
CategoryTheory.Limits.preservesBiproduct_of_epi_biproductComparison' | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[inst_6 : CategoryTheory.Limits.HasBiproduct f] [inst_7 : CategoryTheory.Limits.HasBiproduct (F.obj ∘ f)]
[CategoryTheory.Epi (F.biproductComparison' f)], CategoryTheory.Limits.PreservesBiproduct f F | true |
himp_compl | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), a ⇨ aᶜ = aᶜ | true |
_private.Lean.ResolveName.0.Lean.resolveLocalName.go | Lean.ResolveName | Lean.LocalDecl → Lean.MacroScopesView → Lean.Name → Lean.Name → Option Lean.LocalDecl | true |
IsCoprime.of_isCoprime_of_dvd_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime z y → x ∣ y → IsCoprime z x | true |
CategoryTheory.evaluationAdjunctionRight._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {X : D}
{Y Y' : CategoryTheory.Functor C D} (f : (CategoryTheory.evaluationLeftAdjoint D c).obj X ⟶ Y) (g : Y ⟶ Y'),
{
toFun := fun f =>
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.ι (fun x => X) (CategoryTheory.CategoryStruct.id c)) (f.app c),
invFun := fun f =>
{ app := fun x => CategoryTheory.Limits.Sigma.desc fun h => CategoryTheory.CategoryStruct.comp f (Y'.map h),
naturality := ⋯ },
left_inv := ⋯, right_inv := ⋯ }
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
({
toFun := fun f =>
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.ι (fun x => X) (CategoryTheory.CategoryStruct.id c)) (f.app c),
invFun := fun f =>
{ app := fun x => CategoryTheory.Limits.Sigma.desc fun h => CategoryTheory.CategoryStruct.comp f (Y.map h),
naturality := ⋯ },
left_inv := ⋯, right_inv := ⋯ }
f)
(((CategoryTheory.evaluation C D).obj c).map g) | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_oneMore_iff | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.oneMore ↔ b &&& 224 = 192 | true |
CategoryTheory.instNonemptyFreeGroupoid | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [Nonempty C], Nonempty (CategoryTheory.FreeGroupoid C) | true |
NormedAddGroup.ofSeparation | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [inst : SeminormedAddGroup E] → (∀ (x : E), ‖x‖ = 0 → x = 0) → NormedAddGroup E | true |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian_p | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
(CategoryTheory.ShortComplex.RightHomologyData.ofAbelian S).p = CategoryTheory.Limits.cokernel.π S.f | true |
Std.Time.OffsetX.hourMinuteColon.sizeOf_spec | Std.Time.Format.Basic | sizeOf Std.Time.OffsetX.hourMinuteColon = 1 | true |
Vector.insertIdx_eraseIdx._proof_5 | Init.Data.Vector.InsertIdx | ∀ {n i j : ℕ}, i < n → j ≤ n - 1 → ¬i ≤ j → n + 1 - 1 = n - 1 + 1 | false |
TensorProduct.gradedMul_one | Mathlib.LinearAlgebra.TensorProduct.Graded.External | ∀ {R : Type u_1} {ι : Type u_2} [inst : CommSemiring ι] [inst_1 : Module ι (Additive ℤˣ)] [inst_2 : DecidableEq ι]
(𝒜 : ι → Type u_3) (ℬ : ι → Type u_4) [inst_3 : CommRing R] [inst_4 : (i : ι) → AddCommGroup (𝒜 i)]
[inst_5 : (i : ι) → AddCommGroup (ℬ i)] [inst_6 : (i : ι) → Module R (𝒜 i)] [inst_7 : (i : ι) → Module R (ℬ i)]
[inst_8 : DirectSum.GRing 𝒜] [inst_9 : DirectSum.GRing ℬ] [inst_10 : DirectSum.GAlgebra R 𝒜]
[inst_11 : DirectSum.GAlgebra R ℬ] (x : TensorProduct R (DirectSum ι fun i => 𝒜 i) (DirectSum ι fun i => ℬ i)),
((TensorProduct.gradedMul R 𝒜 ℬ) x) 1 = x | true |
CategoryTheory.Functor.relativelyRepresentable.lift_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : D} {f : X ⟶ Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a ⟶ Y}
{c : C} (i : F.obj c ⟶ X) (h : c ⟶ a)
(hi : CategoryTheory.CategoryStruct.comp i f = CategoryTheory.CategoryStruct.comp (F.map h) g) [inst_2 : F.Full]
{Z : D} (h_1 : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (hf.lift i h hi)) (CategoryTheory.CategoryStruct.comp (hf.fst g) h_1) =
CategoryTheory.CategoryStruct.comp i h_1 | true |
Submodule.instOrderTop | Mathlib.Algebra.Module.Submodule.Lattice | {R : Type u_1} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → OrderTop (Submodule R M) | true |
Std.DHashMap.Raw.Equiv.union_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ m₃ m₄ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₄.WF → m₁.Equiv m₃ → m₂.Equiv m₄ → (m₁ ∪ m₂).Equiv (m₃ ∪ m₄) | true |
List.take_succ_eq_append_getElem | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α} (h : i < l.length), List.take (i + 1) l = List.take i l ++ [l[i]] | true |
DFinsupp.filter_single_neg | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] {p : ι → Prop}
[inst_2 : DecidablePred p] (i : ι) (x : β i), ¬p i → (DFinsupp.filter p fun₀ | i => x) = 0 | true |
_private.Mathlib.NumberTheory.RamificationInertia.Unramified.0.IsUnramifiedAt.of_liesOver_of_ne_bot.match_1_1 | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ (R : Type u_1) {S : Type u_3} {T : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (p : Ideal S) (P : Ideal T) [inst_5 : p.IsPrime] [inst_6 : P.IsPrime]
(this : P.LiesOver (Ideal.under R p)),
let p₀ := Ideal.under R p;
∀
(motive :
Algebra.IsSeparable p₀.ResidueField P.ResidueField ∧
Ideal.map (algebraMap R (Localization.AtPrime P)) p₀ = IsLocalRing.maximalIdeal (Localization.AtPrime P) →
Prop)
(x :
Algebra.IsSeparable p₀.ResidueField P.ResidueField ∧
Ideal.map (algebraMap R (Localization.AtPrime P)) p₀ = IsLocalRing.maximalIdeal (Localization.AtPrime P)),
(∀ (h₁ : Algebra.IsSeparable p₀.ResidueField P.ResidueField)
(h₂ : Ideal.map (algebraMap R (Localization.AtPrime P)) p₀ = IsLocalRing.maximalIdeal (Localization.AtPrime P)),
motive ⋯) →
motive x | false |
Aesop.ScopeName.noConfusionType | Aesop.Rule.Name | Sort v✝ → Aesop.ScopeName → Aesop.ScopeName → Sort v✝ | true |
CategoryTheory.Limits.binaryFanZeroLeftIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan 0 X),
CategoryTheory.CategoryStruct.comp ((fun s => s.snd) s) (CategoryTheory.CategoryStruct.id X) = s.snd | false |
Lean.OptionDecl._sizeOf_inst | Lean.Data.Options | SizeOf Lean.OptionDecl | false |
BooleanAlgebra.mk | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} →
[toDistribLattice : DistribLattice α] →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
[toTop : Top α] →
[toBot : Bot α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
(∀ (a : α), a ≤ ⊤) →
(∀ (a : α), ⊥ ≤ a) →
autoParam (∀ (x y : α), x \ y = x ⊓ yᶜ) BooleanAlgebra.sdiff_eq._autoParam →
autoParam (∀ (x y : α), x ⇨ y = y ⊔ xᶜ) BooleanAlgebra.himp_eq._autoParam → BooleanAlgebra α | true |
_private.Mathlib.Tactic.Widget.StringDiagram.0.Mathlib.Tactic.Widget.StringDiagram.mkKind.match_5 | Mathlib.Tactic.Widget.StringDiagram | (motive : Option Mathlib.Tactic.Bicategory.Context → Sort u_1) →
(ctx? : Option Mathlib.Tactic.Bicategory.Context) →
((val : Mathlib.Tactic.Bicategory.Context) → motive (some val)) → (Unit → motive none) → motive ctx? | false |
Std.Time.instReprOffsetX | Std.Time.Format.Basic | Repr Std.Time.OffsetX | true |
GroupSeminorm.instMin._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : CommGroup E] (p q : GroupSeminorm E) (r : ℝ), 0 < r → p 1 + q (1 / 1) < r | false |
OrderIso.divRight₀_apply | Mathlib.Algebra.Order.GroupWithZero.Unbundled.OrderIso | ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [inst_2 : MulPosReflectLT G₀] (a : G₀)
(ha : 0 < a) (x : G₀), (OrderIso.divRight₀ a ha) x = x / a | true |
Module.compHom.toLinearEquiv._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (g : R ≃+* S) (x y : R),
g.toFun (x + y) = g.toFun x + g.toFun y | false |
MvPFunctor.M.Path.root | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} →
{P : MvPFunctor.{u} (n + 1)} →
(x : P.last.M) →
(a : P.A) → (f : P.last.B a → P.last.M) → x.dest = ⟨a, f⟩ → (i : Fin2 n) → P.drop.B a i → MvPFunctor.M.Path P x i | true |
HNNExtension.toSubgroup.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] (A B : Subgroup G) (u : ℤˣ), HNNExtension.toSubgroup A B u = if u = 1 then A else B | true |
String.Slice.Pos.le_ofSliceFrom._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ : s.Pos} {pos : (s.sliceFrom p₀).Pos}, (p₀ ≤ String.Slice.Pos.ofSliceFrom pos) = True | false |
HNNExtension.NormalWord.instMulAction_1._proof_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) {d : HNNExtension.NormalWord.TransversalPair G A B}
(a : ↥A),
HNNExtension.NormalWord.unitsSMulEquiv φ * (MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑a =
(MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑(φ a) * HNNExtension.NormalWord.unitsSMulEquiv φ | false |
OrderIso.sumCongr | Mathlib.Data.Sum.Order | {α₁ : Type u_4} →
{α₂ : Type u_5} →
{β₁ : Type u_6} →
{β₂ : Type u_7} →
[inst : LE α₁] →
[inst_1 : LE α₂] → [inst_2 : LE β₁] → [inst_3 : LE β₂] → α₁ ≃o α₂ → β₁ ≃o β₂ → α₁ ⊕ β₁ ≃o α₂ ⊕ β₂ | true |
Lean.Lsp.FileSystemWatcher.globPattern | Lean.Data.Lsp.Workspace | Lean.Lsp.FileSystemWatcher → String | true |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.schroeder_bernstein_of_rel._proof_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
g '' (f '' OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ })ᶜ =
(OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ })ᶜ →
∀ a ∉ OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ },
a ∈ g '' (f '' OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ })ᶜ | false |
_private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piRightInv._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Pi | ∀ (R : Type u_5) [inst : CommSemiring R] (S : Type u_1) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (N : Type u_4)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module S N] [inst_6 : IsScalarTower R S N] {ι : Type u_2}
(M : ι → Type u_3) [inst_7 : (i : ι) → AddCommMonoid (M i)] [inst_8 : (i : ι) → Module R (M i)],
SMulCommClass S S (TensorProduct R N ((i : ι) → M i)) | false |
_private.Mathlib.RingTheory.LocalProperties.Basic.0.Ideal.iInf_ker_le._simp_1_1 | Mathlib.RingTheory.LocalProperties.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | false |
Lean.PersistentHashMap.EntriesNode | Lean.Data.PersistentHashMap | Type u_1 → Type u_2 → Type (max 0 u_2 u_1) | true |
Std.Tactic.BVDecide.BVPred._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred | false |
wellApproximable.eq_1 | Mathlib.NumberTheory.WellApproximable | ∀ (A : Type u_1) [inst : SeminormedGroup A] (δ : ℕ → ℝ),
wellApproximable A δ = Filter.blimsup (fun n => approxOrderOf A n (δ n)) Filter.atTop fun n => 0 < n | true |
_private.Mathlib.Data.Set.Basic.0.Set.nonempty_of_not_subset.match_1_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} {s t : Set α} (motive : (∃ a ∈ s, a ∉ t) → Prop) (x : ∃ a ∈ s, a ∉ t),
(∀ (x : α) (xs : x ∈ s) (xt : x ∉ t), motive ⋯) → motive x | false |
UInt64.natCast | Init.GrindInstances.Ring.UInt | NatCast UInt64 | true |
_private.Mathlib.Order.Disjointed.0.preimage_find_eq_disjointed._simp_1_1 | Mathlib.Order.Disjointed | ∀ {m : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (Nat.find h = m) = (p m ∧ ∀ n < m, ¬p n) | false |
Zsqrtd.addGroupWithOne._proof_2 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (n : ℕ), Zsqrtd.ofInt ↑(n + 1) = Zsqrtd.ofInt ↑n + 1 | false |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.«_aux_Mathlib_AlgebraicGeometry_Gluing___delab_app__private_Mathlib_AlgebraicGeometry_Gluing_0_AlgebraicGeometry_Scheme_IsLocallyDirected_term↓__1» | Mathlib.AlgebraicGeometry.Gluing | Lean.PrettyPrinter.Delaborator.Delab | false |
AlternatingMap.domCoprod' | Mathlib.LinearAlgebra.Alternating.DomCoprod | {ιa : Type u_1} →
{ιb : Type u_2} →
[Fintype ιa] →
[Fintype ιb] →
{R' : Type u_3} →
{Mᵢ : Type u_4} →
{N₁ : Type u_5} →
{N₂ : Type u_6} →
[inst : CommSemiring R'] →
[inst_1 : AddCommGroup N₁] →
[inst_2 : Module R' N₁] →
[inst_3 : AddCommGroup N₂] →
[inst_4 : Module R' N₂] →
[inst_5 : AddCommMonoid Mᵢ] →
[inst_6 : Module R' Mᵢ] →
[DecidableEq ιa] →
[DecidableEq ιb] →
TensorProduct R' (Mᵢ [⋀^ιa]→ₗ[R'] N₁) (Mᵢ [⋀^ιb]→ₗ[R'] N₂) →ₗ[R']
Mᵢ [⋀^ιa ⊕ ιb]→ₗ[R'] TensorProduct R' N₁ N₂ | true |
AffineMap.restrict._proof_2 | Mathlib.LinearAlgebra.AffineSpace.Restrict | ∀ {k : Type u_2} {V₁ : Type u_1} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁}
{F : AffineSubspace k P₂}, AffineSubspace.map φ E ≤ F → E.direction ≤ Submodule.comap φ.linear F.direction | false |
ConnectedComponents.isQuotientMap_coe | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α], Topology.IsQuotientMap ConnectedComponents.mk | true |
CentroidHomClass.mk | Mathlib.Algebra.Ring.CentroidHom | ∀ {F : Type u_6} {α : outParam (Type u_7)} [inst : NonUnitalNonAssocSemiring α] [inst_1 : FunLike F α α]
[toAddMonoidHomClass : AddMonoidHomClass F α α],
(∀ (f : F) (a b : α), f (a * b) = a * f b) → (∀ (f : F) (a b : α), f (a * b) = f a * b) → CentroidHomClass F α | true |
Real.toNNReal_le_toNNReal | Mathlib.Data.NNReal.Defs | ∀ {r p : ℝ}, r ≤ p → r.toNNReal ≤ p.toNNReal | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing.match_3 | Mathlib.RingTheory.Regular.RegularSequence | (motive :
(x : Type u_1) →
(x_1 : CommRing x) →
(x_2 : Type u_2) →
(x_3 : AddCommGroup x_2) →
(x_4 : Module x x_2) → (x_5 : List x) → RingTheory.Sequence.IsWeaklyRegular x_2 x_5 → Sort u_3) →
(x : Type u_1) →
(x_1 : CommRing x) →
(x_2 : Type u_2) →
(x_3 : AddCommGroup x_2) →
(x_4 : Module x x_2) →
(x_5 : List x) →
(x_6 : RingTheory.Sequence.IsWeaklyRegular x_2 x_5) →
((R : Type u_1) →
(x : CommRing R) →
(M : Type u_2) →
(x_7 : AddCommGroup M) →
(x_8 : Module R M) →
(x_9 : RingTheory.Sequence.IsWeaklyRegular M []) → motive R x M x_7 x_8 [] x_9) →
((α : Type u_1) →
(x : CommRing α) →
(M : Type u_2) →
(x_7 : AddCommGroup M) →
(x_8 : Module α M) →
(r : α) →
(rs : List α) →
(h : RingTheory.Sequence.IsWeaklyRegular M (r :: rs)) →
motive α x M x_7 x_8 (r :: rs) h) →
motive x x_1 x_2 x_3 x_4 x_5 x_6 | false |
Mathlib.Meta.NormNum.inferLinearOrderedSemifield | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
(α : Q(Type u)) → Lean.MetaM ((x : Q(Semifield «$α»)) × (x_1 : Q(LinearOrder «$α»)) × Q(IsStrictOrderedRing «$α»)) | true |
Field.nnratCast._inherited_default | Mathlib.Algebra.Field.Defs | {K : Type u} → (ℕ → K) → (K → K → K) → ℚ≥0 → K | false |
instNonemptyOfMonad | Init.Prelude | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [Nonempty α], Nonempty (m α) | true |
IsAdjoinRoot.adjoin_root_eq_top | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRoot S f), Algebra.adjoin R {h.root} = ⊤ | true |
CompletelyNormalSpace.recOn | Mathlib.Topology.Separation.Regular | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : CompletelyNormalSpace X → Sort u_1} →
(t : CompletelyNormalSpace X) →
((completely_normal :
∀ ⦃s t : Set X⦄, Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (nhdsSet s) (nhdsSet t)) →
motive ⋯) →
motive t | false |
HahnSeries.instMul._proof_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] [IsOrderedCancelAddMonoid Γ],
IsOrderedCancelVAdd Γ Γ | false |
Finset.piecewise_le_of_le_of_le | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {π : ι → Type u_3} {f g h : (i : ι) → π i}
[inst_1 : (i : ι) → Preorder (π i)], f ≤ h → g ≤ h → s.piecewise f g ≤ h | true |
LocalizedModule.instRing._proof_6 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R},
autoParam
(∀ (n : ℕ) (a : LocalizedModule S A), SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a)
SubNegMonoid.zsmul_neg'._autoParam | false |
LinearMap.BilinForm.isOrtho_zero_right | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{B : LinearMap.BilinForm R M} (x : M), B.IsOrtho x 0 | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.instIsLieAbelianSubtypeMatrixSumMemFinsetSupportLieSubalgebraLieAlgebraCartanSubalgebra'._simp_3 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
LocallyConstant.instRing._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Ring Y], ⇑1 = ⇑1 | false |
LinearMap.map_sub₂ | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {N : Type u_6} {M' : Type u_12} {P' : Type u_13} [inst_4 : AddCommMonoid N]
[inst_5 : AddCommGroup M'] [inst_6 : AddCommGroup P'] [inst_7 : Module S N] [inst_8 : Module R M']
[inst_9 : Module R₂ P'] [inst_10 : Module S₂ P'] [inst_11 : SMulCommClass S₂ R₂ P'] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
(f : M' →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P') (x y : M') (z : N), (f (x - y)) z = (f x) z - (f y) z | true |
FreeMonoid.instUniqueOfIsEmpty.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} [inst : IsEmpty α],
FreeMonoid.instUniqueOfIsEmpty = { toInhabited := FreeMonoid.instInhabited, uniq := ⋯ } | true |
CategoryTheory.instIsSplitEpiOppositeOpOfIsSplitMono | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsSplitMono f],
CategoryTheory.IsSplitEpi f.op | true |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.coeff_hsum_mul._simp_1_2 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | false |
CategoryTheory.Adjunction.compUliftCoyonedaIso._proof_4 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((F.op.comp CategoryTheory.uliftCoyoneda.{max u_5 u_2, u_4, u_3}).map f)
((fun X =>
CategoryTheory.NatIso.ofComponents
(fun Y => (Equiv.ulift.trans ((adj.homEquiv (Opposite.unop X) Y).trans Equiv.ulift.symm)).toIso) ⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
CategoryTheory.NatIso.ofComponents
(fun Y => (Equiv.ulift.trans ((adj.homEquiv (Opposite.unop X) Y).trans Equiv.ulift.symm)).toIso) ⋯)
X).hom
((CategoryTheory.uliftCoyoneda.{max u_5 u_4, u_2, u_1}.comp
((CategoryTheory.Functor.whiskeringLeft D C (Type (max (max u_5 u_4) u_2))).obj G)).map
f) | false |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_I._simp_1_2 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α},
(∀ᶠ (x : α) in f ⊓ Filter.principal s, p x) = ∀ᶠ (x : α) in f, x ∈ s → p x | false |
Lean.Elab.Term.BinderView.mk.inj | Lean.Elab.Binders | ∀ {ref id type : Lean.Syntax} {bi : Lean.BinderInfo} {ref_1 id_1 type_1 : Lean.Syntax} {bi_1 : Lean.BinderInfo},
{ ref := ref, id := id, type := type, bi := bi } = { ref := ref_1, id := id_1, type := type_1, bi := bi_1 } →
ref = ref_1 ∧ id = id_1 ∧ type = type_1 ∧ bi = bi_1 | true |
CategoryTheory.ShortComplex.ShortExact.extClass._proof_7 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C},
HomologicalComplex.HasHomotopyCofiber (S.map (HomologicalComplex.single C (ComplexShape.up ℤ) 0)).f | false |
CategoryTheory.Comma.mapRightId_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.mapRightId L R).hom.app X).right = CategoryTheory.CategoryStruct.id X.right | true |
Set.subtypeInsertEquivOption.congr_simp | Mathlib.RingTheory.Algebraic.MvPolynomial | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Set α} {x : α} (h : x ∉ t),
Set.subtypeInsertEquivOption h = Set.subtypeInsertEquivOption h | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind | Lean.Server.ProtocolOverview | Type | true |
CategoryTheory.Idempotents.Karoubi.rec | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Idempotents.Karoubi C → Sort u} →
((X : C) →
(p : X ⟶ X) → (idem : CategoryTheory.CategoryStruct.comp p p = p) → motive { X := X, p := p, idem := idem }) →
(t : CategoryTheory.Idempotents.Karoubi C) → motive t | false |
LieSubalgebra.instPartialOrder_1._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(a : LieSubalgebra R L), a ≤ a | false |
Matrix.TransvectionStruct.toMatrix.eq_1 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] (t : Matrix.TransvectionStruct n R),
t.toMatrix = Matrix.transvection t.i t.j t.c | true |
ClassGroup.fintypeOfAdmissibleOfFinite._proof_12 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_1} {S : Type u_2} (L : Type u_3) [inst : EuclideanDomain R] [inst_1 : CommRing S] [inst_2 : Field L]
[algRL : Algebra R L] [inst_3 : Algebra R S] [inst_4 : Algebra S L] [ist : IsScalarTower R S L]
[IsIntegralClosure S R L], Algebra.IsIntegral R S | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.