name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.Option.NAry.0.Option.map₂_assoc._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_3} {δ : Type u_2} {a : Option α} {b : Option β} {c : Option γ}
{ε : Type u_1} {ε' : Type u_6} {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'},
(∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)) →
Option.map₂ f (Option.map₂ g a b) c = Option.m... | null | false |
Lean.Meta.Grind.instInhabitedEMatchDiagNode.default | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatchDiagNode | null | true |
String.apply_skipSuffixWhile_bool_eq_false | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {h : s.skipSuffixWhile p ≠ s.startPos},
p (((s.skipSuffixWhile p).prev h).get ⋯) = false | null | true |
CategoryTheory.Limits.sigmaConst_obj_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C] (X : C)
{X_1 Y : Type w} (f : X_1 ⟶ Y),
(CategoryTheory.Limits.sigmaConst.obj X).map f =
CategoryTheory.Limits.Sigma.map' ⇑(CategoryTheory.ConcreteCategory.hom f) fun x =>
CategoryTheory.CategoryStruc... | null | true |
Std.ExtDTreeMap.Const.get_insertMany_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l →
∀ {h' : k' ∈ Std.ExtDTreeMap.C... | null | true |
_private.Mathlib.Topology.Algebra.Constructions.0.Units.isOpenMap_map.match_1_9 | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] {f : M →* N} (U : Set (M × Mᵐᵒᵖ)) (y : Nˣ)
(motive : (∃ x, (↑x, MulOpposite.op ↑x⁻¹) ∈ U ∧ (Units.map f) x = y) → Prop)
(x : ∃ x, (↑x, MulOpposite.op ↑x⁻¹) ∈ U ∧ (Units.map f) x = y),
(∀ (x : Mˣ) (hxV : (↑x, MulOpposite.op ↑x⁻¹) ∈ U) (hx : (Uni... | null | false |
KaehlerDifferential.linearCombination_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(Finsupp.linearCombination S ⇑(KaehlerDifferential.D R S)) | null | true |
UniformEquiv.refl_symm | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} [inst : UniformSpace α], (UniformEquiv.refl α).symm = UniformEquiv.refl α | null | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.mem_drop_iff_getElem._proof_1_2 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α} (i_1 : ℕ), i_1 + i < l.length → ¬i_1 < l.length - i → False | null | false |
Lean.Widget.RpcEncodablePacket._sizeOf_1._@.Lean.Widget.InteractiveDiagnostic.1765450820._hygCtx._hyg.1 | Lean.Widget.InteractiveDiagnostic | Lean.Widget.RpcEncodablePacket✝ → ℕ | null | false |
Turing.TM0.Stmt.move.elim | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{motive : Turing.TM0.Stmt Γ → Sort u} →
(t : Turing.TM0.Stmt Γ) → t.ctorIdx = 0 → ((a : Turing.Dir) → motive (Turing.TM0.Stmt.move a)) → motive t | null | false |
MulOneClass.mk._flat_ctor | Mathlib.Algebra.Group.Monoid | {M : Type u_2} → (one : M) → (mul : M → M → M) → (∀ (a : M), 1 * a = a) → (∀ (a : M), a * 1 = a) → MulOneClass M | null | false |
List.Nodup.count | Init.Data.List.Pairwise | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α},
l.Nodup → List.count a l = if a ∈ l then 1 else 0 | null | true |
Fin.coe_castPred | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 1)) (h : i ≠ Fin.last n), ↑(i.castPred h) = ↑i | null | true |
Std.TreeMap.alter | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → (Option β → Option β) → Std.TreeMap α β cmp | Modifies in place the value associated with a given key,
allowing creating new values and deleting values via an `Option` valued replacement function.
This function ensures that the value is used linearly.
| true |
Nat.Internal.Linear.Poly.insert._sunfold | Init.Data.Nat.Internal.Linear | ℕ → Nat.Internal.Linear.Var → Nat.Internal.Linear.Poly → Nat.Internal.Linear.Poly | null | false |
CategoryTheory.Oplax.StrongTrans.isoMk_inv_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.B... | null | true |
Bornology.IsBounded.disjoint_cobounded | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} [inst : Bornology α] {l : Filter α} {s : Set α},
Bornology.IsBounded s → s ∈ l → Disjoint l (Bornology.cobounded α) | null | true |
UniformSpace.hausdorff.isClosed_setOf_totallyBounded | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], IsClosed {s | TotallyBounded s} | **Alias** of `UniformSpace.hausdorff.isClosed_setOfPred_totallyBounded`. | true |
Bornology.IsVonNBounded.image_multilinear | Mathlib.Topology.Algebra.Module.Multilinear.Bounded | ∀ {ι : Type u_1} {𝕜 : Type u_2} {F : Type u_3} {E : ι → Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → AddCommGroup (E i)] [inst_2 : (i : ι) → Module 𝕜 (E i)]
[inst_3 : (i : ι) → TopologicalSpace (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [ContinuousSMul 𝕜 F] {... | The image of a von Neumann bounded set under a continuous multilinear map
is von Neumann bounded.
This version assumes that the codomain is a topological vector space.
| true |
RingEquiv.toAlgHom_toIntAlgEquiv | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R ≃+* S), ↑f.toIntAlgEquiv = (↑f).toIntAlgHom | null | true |
UInt64.toUInt16_lt._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a.toUInt16 < b.toUInt16) = (a % 65536 < b % 65536) | null | false |
CategoryTheory.Functor.leftOpRightOpEquiv._proof_1 | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_1)
[inst_1 : CategoryTheory.Category.{u_3, u_1} D] (X : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ),
CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.id X).unop =
CategoryTheory.CategoryStruct.id (Opposite.unop X).rightOp | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.Internal.List.insertEntry.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (k : α) (v : β k) (l : List ((a : α) × β a)),
Std.Internal.List.insertEntry k v l =
if Std.Internal.List.containsKey k l = true then Std.Internal.List.replaceEntry k v l else ⟨k, v⟩ :: l | null | true |
curveIntegral_symm | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} (ω : E → E →L[𝕜] F)
(γ : Path a b), ∫ᶜ (x : E) in γ.symm, ω x = -∫ᶜ (x : E) in γ, ω x | null | true |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.addContent_iUnion_eq_tsum_of_disjoint_of_addContent_iUnion_le._simp_1_5 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
smul_mem_asymptoticCone_iff | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : ... | null | true |
ImportGraph.WorkspaceModel.Error.noLibOfModule.elim | ImportGraph.WorkspaceModel.Model | {motive : ImportGraph.WorkspaceModel.Error → Sort u} →
(t : ImportGraph.WorkspaceModel.Error) →
t.ctorIdx = 1 → ((mod : Lean.Name) → motive (ImportGraph.WorkspaceModel.Error.noLibOfModule mod)) → motive t | null | false |
Matrix.transposeInvertibleEquivInvertible._proof_1 | Mathlib.LinearAlgebra.Matrix.Invertible | ∀ {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring α] (A : Matrix n n α)
(x : Invertible A.transpose), A.invertibleTranspose = x | null | false |
Std.Tactic.BVDecide.BVUnOp.eval_not | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ}, Std.Tactic.BVDecide.BVUnOp.not.eval = fun x => ~~~x | null | true |
CategoryTheory.PreGaloisCategory.autMapHom_apply | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C] {A B : C}
[inst_2 : CategoryTheory.PreGaloisCategory.IsConnected A] [inst_3 : CategoryTheory.PreGaloisCategory.IsGalois B]
(f : A ⟶ B) (σ : CategoryTheory.Aut A),
(CategoryTheory.PreGaloisCategory.autMapHom f) σ... | null | true |
List.consecutivePairs | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List (α × α) | `consecutivePairs [a, b, c, d]` is `[(a, b), (b, c), (c, d)]`. | true |
Std.DHashMap.Raw.Equiv.mem_iff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α}, m₁.WF → m₂.WF → m₁.Equiv m₂ → (k ∈ m₁ ↔ k ∈ m₂) | null | true |
Set.BijOn.union | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
Set.BijOn f s₁ t₁ → Set.BijOn f s₂ t₂ → Set.InjOn f (s₁ ∪ s₂) → Set.BijOn f (s₁ ∪ s₂) (t₁ ∪ t₂) | null | true |
LieSubmodule.lowerCentralSeries_eq_lcs_comap | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ) (N : LieSubmodule R L M)
[LieModule R L M], LieModule.lowerCentralSeries R L (↥N) k = LieSubmodule.comap N.incl (LieSubmodu... | null | true |
HopfAlgCat.noConfusionType | Mathlib.Algebra.Category.HopfAlgCat.Basic | Sort u_1 →
{R : Type u} → [inst : CommRing R] → HopfAlgCat R → {R' : Type u} → [inst' : CommRing R'] → HopfAlgCat R' → Sort u_1 | null | false |
FreeAddGroupBasis.ofRepr.inj | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {ι : Type u_1} {G : Type u_2} {inst : AddGroup G} {repr repr_1 : G ≃+ FreeAddGroup ι},
{ repr := repr } = { repr := repr_1 } → repr = repr_1 | null | true |
CategoryTheory.ShortComplex.instPreservesLimitsOfShapeπ₂ | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.PreservesLimitsOfShape J CategoryTheory.ShortComplex.π₂ | null | true |
CategoryTheory.Idempotents.functorExtension₁._proof_1 | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ (C : Type u_1) (D : Type u_4) [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C (CategoryTheory.Idempotents.Karoubi D)),
CategoryTheory.Idempotents.FunctorExtension₁.map (CategoryTheory.CategoryStruct.id F) =
CategoryTheory.CategoryStru... | null | false |
ContinuousLinearMap.instSMul._proof_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_4} {R₂ : Type u_5} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_1}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {S₂ : Type u_3}
[ins... | null | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_23 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, (a ∈ s.toFinset) = (a ∈ s) | null | false |
Matrix.diagonal_mulVec_single | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_3} {R : Type u_5} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : NonUnitalNonAssocSemiring R]
(v : n → R) (j : n) (x : R), (Matrix.diagonal v).mulVec (Pi.single j x) = Pi.single j (v j * x) | null | true |
_private.Mathlib.Analysis.Asymptotics.Theta.0.Asymptotics.isTheta_const_const_iff._simp_1_2 | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{c : E''} {c' : F''} (l : Filter α) [l.NeBot], ((fun _x => c) =O[l] fun _x => c') = (c' = 0 → c = 0) | null | false |
Lean.Doc.instBEqListItem.beq | Lean.DocString.Types | {α : Type u_1} → [BEq α] → Lean.Doc.ListItem α → Lean.Doc.ListItem α → Bool | null | true |
Finset.prod_Iic_add_one_comm | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : LocallyFiniteOrderBot α]
[inst_3 : Add α] [inst_4 : One α] [SuccAddOrder α] [NoMaxOrder α] (a : α) (f : α → M),
∏ i ≤ a + 1, f i = f (a + 1) * ∏ i ≤ a, f i | null | true |
Std.DTreeMap.isSome_maxKey?_iff_isEmpty_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.maxKey?.isSome = true ↔ t.isEmpty = false | null | true |
Mathlib.Tactic.Monoidal.instMonadNormalizeNaturalityMonoidalM.match_1 | Mathlib.Tactic.CategoryTheory.Monoidal.PureCoherence | (ctx : Mathlib.Tactic.Monoidal.Context) →
(motive : Option Q(CategoryTheory.MonoidalCategory unknown_1) → Sort u_1) →
(x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) →
((_monoidal : Q(CategoryTheory.MonoidalCategory unknown_1)) → motive (some _monoidal)) →
((x : Option Q(CategoryTheory.Mon... | null | false |
ProbabilityTheory.preCDF_le_one | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ],
∀ᵐ (a : α) ∂ρ.fst, ∀ (r : ℚ), ProbabilityTheory.preCDF ρ r a ≤ 1 | null | true |
Finset.min_union | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s t : Finset α}, (s ∪ t).min = min s.min t.min | null | true |
Lean.Compiler.LCNF.Code.collectUsed | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → optParam Lean.FVarIdHashSet ∅ → Lean.FVarIdHashSet | null | true |
Std.Http.URI.EncodedString.decode | Std.Http.Data.URI.Encoding | {r : UInt8 → Bool} → Std.Http.URI.EncodedString r → Option String | Decodes an `EncodedString` back to a regular `String`. Converts percent-encoded sequences (e.g., "%20")
back to their original characters. Returns `none` if the decoded bytes are not valid UTF-8.
| true |
CategoryTheory.Subgroupoid.instSetLikeSigmaHom | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} → [inst : CategoryTheory.Groupoid C] → SetLike (CategoryTheory.Subgroupoid C) ((c : C) × (d : C) × (c ⟶ d)) | null | true |
ENat.one_lt_card._simp_1 | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} [Nontrivial α], (1 < ENat.card α) = True | null | false |
Lean.Expr.isDIte | Lean.Util.Recognizers | Lean.Expr → Bool | null | true |
edist_lt_top | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_3} [inst : PseudoMetricSpace α] (x y : α), edist x y < ⊤ | In a pseudometric space, the extended distance is always finite | true |
Lean.Meta.Sym.DSimp.Result.rfl | Lean.Meta.Sym.DSimp.DSimpM | optParam Bool false → Lean.Meta.Sym.DSimp.Result | No change. If `done = true`, skip remaining simplification steps for this term. | true |
CategoryTheory.Functor.PullbackObjObj.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {inst : CategoryTheory.Category.{v₁, u₁} C₁}
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} {inst_2 : CategoryTheory.Category.{v₃, u₃} C₃}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₃ Y₃ : C₃}
{f₃ : X₃ ⟶ Y₃} {pt : C... | null | true |
FirstOrder.Language.DefinableSet.coe_bot | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {A : Set M} {α : Type u₁}, ↑⊥ = ∅ | null | true |
ArchimedeanClass.orderHom | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
{N : Type u_2} →
[inst_3 : AddCommGroup N] →
[inst_4 : LinearOrder N] →
[inst_5 : IsOrderedAddMonoid N] → (M →+o N) → ArchimedeanClass M →o ArchimedeanClass N | An `OrderAddMonoidHom` can be lifted to an `OrderHom` over archimedean classes. | true |
_private.Mathlib.CategoryTheory.Shift.Localization.0.CategoryTheory.Functor.commShiftOfLocalization._simp_1 | Mathlib.CategoryTheory.Shift.Localization | ∀ {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} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y) {Z : D}
(h : G.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.app X) (CategoryTheory.CategoryS... | null | false |
ExteriorAlgebra.ιInv | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | {R : Type u1} →
[inst : CommRing R] → {M : Type u2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → ExteriorAlgebra R M →ₗ[R] M | The left-inverse of `ι`.
As an implementation detail, we implement this using `TrivSqZeroExt` which has a suitable
algebra structure. | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferMVarType | Lean.Meta.InferType | Lean.MVarId → Lean.MetaM Lean.Expr | null | true |
AddOpposite.instCommMonoid._proof_2 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] (x x_1 : αᵃᵒᵖ), AddOpposite.unop (x * x_1) = AddOpposite.unop (x * x_1) | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Charpoly.Eigs.0.Matrix.mem_spectrum_iff_not_isUnit_eval_charpoly._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Charpoly.Eigs | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
(r ∈ spectrum R a) = ¬IsUnit ((algebraMap R A) r - a) | null | false |
ENormedCommMonoid.toESeminormedCommMonoid | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → {inst : TopologicalSpace E} → [self : ENormedCommMonoid E] → ESeminormedCommMonoid E | null | true |
_private.Init.Data.Nat.Lcm.0.Nat.lcm_pos._simp_1_1 | Init.Data.Nat.Lcm | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) | null | false |
Equiv.algebra | Mathlib.Algebra.Algebra.TransferInstance | (R : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : CommSemiring R] →
(e : α ≃ β) →
[inst_1 : Semiring β] →
have x := e.semiring;
[Algebra R β] → Algebra R α | Transfer `Algebra` across an `Equiv` | true |
ZMod.intCast_cast_mul | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (x y : ZMod n), (x * y).cast = x.cast * y.cast % ↑n | null | true |
Lean.Elab.InlayHintLinkLocation._sizeOf_inst | Lean.Elab.InfoTree.InlayHints | SizeOf Lean.Elab.InlayHintLinkLocation | null | false |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.ker_zero._simp_1_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {f : E →ₛₗ.[σ] F} {x : E},
(x ∈ f.ker) = ∃ y, x = ↑y ∧ ↑f y = 0 | null | false |
Lean.Meta.Grind.EMatch.State.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.EMatch.State → Sort u} →
(t : Lean.Meta.Grind.EMatch.State) →
((thmMap : Lean.Meta.Grind.EMatchTheoremsArray) →
(gmt : ℕ) →
(thms newThms : Lean.PArray Lean.Meta.Grind.EMatchTheorem) →
(numInstances numDelayedInstances num : ℕ) →
(preInstances ... | null | false |
Vector.append_assoc_symm | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m k : ℕ} {xs : Vector α n} {ys : Vector α m} {zs : Vector α k},
xs ++ (ys ++ zs) = Vector.cast ⋯ (xs ++ ys ++ zs) | null | true |
countableInfClosure_singleton | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} [inst : PartialOrder α] {x : α}, countableInfClosure {x} = {x} | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.BisimO.match_1.splitter._sparseCasesOn_3 | Mathlib.Data.Seq.Parallel | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
List.anyM_pure | Init.Data.List.Monadic | ∀ {m : Type → Type u_1} {α : Type u_2} [inst : Monad m] [LawfulMonad m] {p : α → Bool} {as : List α},
List.anyM (fun x => pure (p x)) as = pure (as.any p) | null | true |
Option.forIn_toList | Init.Data.Option.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (o : Option α) (b : β)
(f : α → β → m (ForInStep β)), forIn o.toList b f = forIn o b f | null | true |
Filter.le_limsup_of_frequently_le' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_6} {β : Type u_7} [inst : CompleteLattice β] {f : Filter α} {u : α → β} {x : β},
(∃ᶠ (a : α) in f, x ≤ u a) → x ≤ Filter.limsup u f | null | true |
MeasureTheory.posConvolution._proof_1 | Mathlib.Analysis.Convolution | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], SMulCommClass ℝ ℝ F | null | false |
Shrink.instNonUnitalCommRing | Mathlib.Algebra.Ring.Shrink | {α : Type u_1} → [inst : Small.{v, u_1} α] → [NonUnitalCommRing α] → NonUnitalCommRing (Shrink.{v, u_1} α) | null | true |
injective_frobenius._simp_1 | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [PerfectRing R p],
Function.Injective ⇑(frobenius R p) = True | null | false |
ULift.distribMulAction'._proof_2 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_3} {M : Type u_2} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M] (a : R)
(x y : ULift.{u_1, u_2} M), a • (x + y) = a • x + a • y | null | false |
CategoryTheory.Limits.colimitLimitToLimitColimitCone._proof_4 | Mathlib.CategoryTheory.Limits.ColimitLimit | ∀ {J : Type u_2} {K : Type u_5} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_6, u_5} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
[CategoryTheory.Limits.HasLimitsOfShape J C] [inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
(G : CategoryTheory.Func... | null | false |
RelHom.instFintype | Mathlib.Data.Fintype.Pi | {α : Type u_3} →
{β : Type u_4} →
[Fintype α] →
[Fintype β] →
[DecidableEq α] →
{r : α → α → Prop} → {s : β → β → Prop} → [DecidableRel r] → [DecidableRel s] → Fintype (r →r s) | null | true |
CategoryTheory.Limits.widePushoutShapeOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y Z : CategoryTheory.Limits.WidePushoutShape J} (f : Y ⟶ X) (g : Z ⟶ Y),
CategoryTheory.Limits.widePushoutShapeOpMap J Z X (CategoryTheory.CategoryStruct.comp g f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.widePushoutShapeOpMap J Z Y g)
(CategoryTheory.Limits.widePushou... | null | false |
Lean.Elab.Command.InductiveElabStep2.prefinalize | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep2 →
List Lean.Name →
Array Lean.Expr → (Lean.Expr → Lean.MetaM Lean.Expr) → Lean.Elab.TermElabM Lean.Elab.Command.InductiveElabStep3 | Like `finalize`, but occurs before `afterTypeChecking` attributes. | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.nofun._regBuiltin.Lean.Parser.Term.nofun.formatter_7 | Lean.Parser.Term | IO Unit | null | false |
Std.DTreeMap.containsThenInsert_snd | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{v : β k}, (t.containsThenInsert k v).2 = t.insert k v | null | true |
UInt32.toNat_ofNat_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt32.size → UInt32.toNat (OfNat.ofNat n) = n | null | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.rec | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{motive :
(it : Std.IterM m β) →
(step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.Flatten.IsPlausibleStep it step → Prop},
(∀ {it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : St... | null | false |
Subgroup.map_symm_eq_iff_map_eq | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {N : Type u_4} [inst_1 : Group N] {H : Subgroup N} {e : G ≃* N},
Subgroup.map (↑e.symm) H = K ↔ Subgroup.map (↑e) K = H | null | true |
Lean.Meta.Simp.instInhabitedContext | Lean.Meta.Tactic.Simp.Types | Inhabited Lean.Meta.Simp.Context | null | true |
_private.Mathlib.MeasureTheory.Integral.IntegrableOn.0.MeasureTheory.integrableAtFilter_atBot_iff.match_1_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_2} {mα : MeasurableSpace α} {f : α → ε} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] [inst_2 : Preorder α]
(motive : MeasureTheory.IntegrableAtFilter f Filter.atBot μ → Prop)
(x : MeasureTheory.IntegrableAtFilter f Filter.atBot μ),
(∀ (s : S... | null | false |
Fintype.one_lt_card_iff_nontrivial | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} [inst : Fintype α], 1 < Fintype.card α ↔ Nontrivial α | null | true |
Order.isSuccPrelimit_iff_of_noMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] [NoMaxOrder α],
Order.IsSuccPrelimit a ↔ IsMin a | null | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.macro._regBuiltin.Lean.Parser.Command.macroArg.formatter_7 | Lean.Parser.Syntax | IO Unit | null | false |
Std.Roo.noConfusionType | Init.Data.Range.Polymorphic.PRange | Sort u_1 → {α : Type u} → Std.Roo α → {α' : Type u} → Std.Roo α' → Sort u_1 | null | false |
Set.instCompleteAtomicBooleanAlgebra._proof_5 | Mathlib.Data.Set.BooleanAlgebra | ∀ {α : Type u_1} (a : Set α), ⊥ ⊆ a | null | false |
CategoryTheory.Limits.WalkingMulticospan.Hom.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : (x x_1 : CategoryTheory.Limits.WalkingMulticospan J) → x.Hom x_1 → Sort u} →
{x x_1 : CategoryTheory.Limits.WalkingMulticospan J} →
(t : x.Hom x_1) →
((A : CategoryTheory.Limits.WalkingMulticospan J) →
motive A A (CategoryTheory.Li... | null | false |
Lean.Grind.CommRing.Mon.mult.injEq | Init.Grind.Ring.CommSolver | ∀ (p : Lean.Grind.CommRing.Power) (m : Lean.Grind.CommRing.Mon) (p_1 : Lean.Grind.CommRing.Power)
(m_1 : Lean.Grind.CommRing.Mon),
(Lean.Grind.CommRing.Mon.mult p m = Lean.Grind.CommRing.Mon.mult p_1 m_1) = (p = p_1 ∧ m = m_1) | null | true |
Equiv.Perm.two_le_card_support_cycleOf_iff._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} {f : Equiv.Perm α} {x : α} [inst : DecidableEq α] [inst_1 : Fintype α],
(2 ≤ (f.cycleOf x).support.card) = (f x ≠ x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.