name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.productIsProduct | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(f : β → C) →
[inst_1 : CategoryTheory.Limits.HasProduct f] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fan.mk (∏ᶜ f) (CategoryTheory.Limits.Pi.π f)) | The fan constructed of the projections from the product is limiting. | true |
Lean.Server.mkPublishDiagnosticsNotification | Lean.Server.Utils | Lean.Server.DocumentMeta →
Array Lean.Lsp.Diagnostic → optParam (Option Bool) none → Lean.JsonRpc.Notification Lean.Lsp.PublishDiagnosticsParams | Constructs a `textDocument/publishDiagnostics` notification. | true |
FreeAddMagma.lift_of | Mathlib.Algebra.Free | ∀ {α : Type u} {β : Type v} [inst : Add β] (f : α → β) (x : α), (FreeAddMagma.lift f) (FreeAddMagma.of x) = f x | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_30 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
r'.size ≤ d.size → d.size ≤ r'.size + 1 → ¬l'.size + 1 + d.size ≤ l'.size + 1 + r'.size + 1 → False | null | false |
Lean.Lsp.ApplyWorkspaceEditParams.mk._flat_ctor | Lean.Data.Lsp.Basic | Option String → Lean.Lsp.WorkspaceEdit → Lean.Lsp.ApplyWorkspaceEditParams | null | false |
BitVec.sdiv_eq.match_1 | Init.Data.BitVec.Lemmas | (motive : Bool → Bool → Sort u_1) →
(x x_1 : Bool) →
(Unit → motive false false) →
(Unit → motive false true) → (Unit → motive true false) → (Unit → motive true true) → motive x x_1 | null | false |
Std.Internal.Parsec.String.ws | Std.Internal.Parsec.String | Std.Internal.Parsec.String.Parser Unit | Skip whitespace: tabs, newlines, carriage returns, and spaces.
| true |
Lean.Elab.Term.elabByTactic | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | null | true |
Equiv.partialOrder | Mathlib.Order.Lattice | {α : Type u} → {β : Type v} → α ≃ β → [PartialOrder β] → PartialOrder α | Transfer `PartialOrder` across an `Equiv`. | true |
ContinuousLinearMap.instStarModuleId | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E], StarModule 𝕜 (E →L[𝕜] E) | null | true |
CategoryTheory.WithTerminal.equivComma_inverse_obj_obj | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(c : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X : CategoryTheory.WithTerminal C),
(CategoryTheory.WithTerminal.equivComma.... | null | true |
not_irreducible_expand | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_2) (p : ℕ) [inst : CommSemiring R] [Fact (Nat.Prime p)] [CharP R p] [PerfectRing R p] (f : Polynomial R),
¬Irreducible ((Polynomial.expand R p) f) | null | true |
_private.Init.Data.String.Lemmas.Basic.0.String.Pos.startPos_le._simp_1_2 | Init.Data.String.Lemmas.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
AffineSubspace.toAddTorsor | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] → (s : AffineSubspace k P) → [Nonempty ↥s] → AddTorsor ↥s.direction ↥s | null | true |
Primrec.nat_omega_rec | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
(f : α → β → σ) {m : α → β → ℕ} {l : α → β → List β} {g : α → β × List σ → Option σ},
Primrec₂ m →
Primrec₂ l →
Primrec₂ g →
(∀ (a : α) (b b' : β), b' ∈ l a b → m a b' < m a b) →... | null | true |
Turing.TM2Computable.noConfusion | Mathlib.Computability.TuringMachine.Computable | {P : Sort u} →
{α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{t : Turing.TM2Computable ea eb f} →
{α' β' αΓ' βΓ' : Type} →
{ea' : α' → List αΓ'} →
{eb' : β' → List βΓ'} →
{f' : α' → β'} →
... | null | false |
Algebra.TensorProduct.right_algebraMap_apply | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), (algebraMap B (TensorProduct R A B)) b = 1 ⊗ₜ[R] b | null | true |
_private.Lean.LibrarySuggestions.SymbolFrequency.0.Lean.LibrarySuggestions.SharedCache.getOrCompute | Lean.LibrarySuggestions.SymbolFrequency | {α : Type} → Lean.LibrarySuggestions.SharedCache✝ α → Lean.CoreM α → Lean.CoreM α | The value in `cache`, computed with `x` on first use. Concurrent callers wait for the first
caller's computation instead of repeating it. A computation that fails or is interrupted is not
cached, and the callers that were waiting for it compute the value themselves.
| true |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.OrthonormalBasis.sum_sq_norm_inner_right._simp_1_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
CentroidHom.instInhabited | Mathlib.Algebra.Ring.CentroidHom | (α : Type u_5) → [inst : NonUnitalNonAssocSemiring α] → Inhabited (CentroidHom α) | null | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.handleContinueEvent | Std.Http.Server.Connection | {σ : Type} →
[Std.Http.Server.Handler σ] →
σ →
Std.Http.Protocol.H1.Machine Std.Http.Protocol.H1.Direction.receiving →
Std.Http.Request.Head →
Std.Http.Config →
Std.CancellationContext →
Std.Async.Async (Std.Http.Protocol.H1.Machine Std.Http.Protocol.H1.Direction.... | Handles the `Expect: 100-continue` protocol for a pending request head.
Races between the handler's decision (`Handler.onContinue`), the connection being
cancelled, and a lingering timeout. Returns the updated machine and whether
`pendingHead` should be cleared (i.e. when the request is rejected).
| true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.equivCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_5} {γ : Sort u_2} {δ : Sort u_3} {ε : Sort u_6} {ζ : Sort u_4} (ab : α ≃ β) (de : δ ≃ ε)
(bc : β ≃ γ) (ef : ε ≃ ζ), (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) | null | false |
DifferentiableAt.continuousMultilinearMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousMultilinearMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : ι → Type u_4} {G : ι → Type u_5} {H : Type u_6}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : (i : ι) → NormedAddCommGroup (F i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F i)]
[inst_5 : (i : ι) → NormedAdd... | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex.0.SSet.Subcomplex.Pairing.RankFunction.Cell.subcomplex_not_le_filtration._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
OrthonormalBasis.repr_reindex | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {ι' : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : Fintype ι'] (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι')
(x : E) (i' : ι'), ((b.reindex e).repr x).ofLp i' = (b.repr x).ofLp (e.symm i') | null | true |
CategoryTheory.PreOneHypercover.Hom.w₁₂._autoParam | Mathlib.CategoryTheory.Sites.Hypercover.One | Lean.Syntax | null | false |
Lean.MessageData.Exprs.noConfusionType | Mathlib.Lean.MessageData.ForExprs | Sort u → Lean.MessageData.Exprs → Lean.MessageData.Exprs → Sort u | null | false |
curveIntegrable_neg_iff | 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}, CurveIntegrable (-ω) γ ↔ CurveIntegrable ω γ | null | true |
ENNReal.div_eq_one_iff | Mathlib.Basic.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → (a / b = 1 ↔ a = b) | null | true |
HomotopicalAlgebra.Precylinder.unop._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A : Cᵒᵖ} (P : HomotopicalAlgebra.Precylinder A),
CategoryTheory.CategoryStruct.comp P.π.unop P.i₀.unop = CategoryTheory.CategoryStruct.id (Opposite.unop A) | null | false |
Submonoid.multiset_noncommProd_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (m : Multiset M) (comm : {x | x ∈ m}.Pairwise Commute),
(∀ x ∈ m, x ∈ S) → m.noncommProd comm ∈ S | null | true |
AddAction.coe_quotient_vadd | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {G : Type u} {X : Type v} [inst : AddGroup G] {H : AddSubgroup G} [inst_1 : H.Normal] [inst_2 : VAdd G X]
[inst_3 : AddAction (G ⧸ H) X] [VAddAssocClass G (G ⧸ H) X] (g : G) (x : X), ↑g +ᵥ x = g +ᵥ x | null | true |
Nat.nth_mem_of_ne_zero | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, Nat.nth p n ≠ 0 → p (Nat.nth p n) | null | true |
CategoryTheory.Reflective.mk | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
[toFull : R.Full] →
[toFaithful : R.Faithful] → (L : CategoryTheory.Functor C D) → (L ⊣ R) → CategoryTheory.Reflectiv... | null | true |
_private.Init.Data.Array.Bootstrap.0.Array.isEqvAux.match_1.eq_2 | Init.Data.Array.Bootstrap | ∀ {α : Type u_1} (xs : Array α) (motive : (x : ℕ) → x ≤ xs.size → Sort u_2) (i : ℕ) (h : i + 1 ≤ xs.size)
(h_1 : (x : 0 ≤ xs.size) → motive 0 x) (h_2 : (i : ℕ) → (h : i + 1 ≤ xs.size) → motive i.succ h),
(match i.succ, h with
| 0, x => h_1 x
| i.succ, h => h_2 i h) =
h_2 i h | null | true |
IsCoinitial.eq_1 | Mathlib.Order.Bounds.Defs | ∀ {α : Type u_1} [inst : LE α] (s : Set α), IsCoinitial s = ∀ (x : α), ∃ y ∈ s, y ≤ x | null | true |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.getKeyArgs._sparseCasesOn_3 | Lean.Meta.DiscrTree.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : Lean.MVarId) → motive (Lean.... | null | false |
Set.Ioc_sdiff_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Ioc b a \ {a} = Set.Ioo b a | null | true |
Algebra.rankAtStalk_eq_of_isPushout | Mathlib.RingTheory.Flat.Rank | ∀ (R : Type u_3) (S : Type u_4) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (R' : Type u_5)
(S' : Type u_6) [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' S'] [inst_10 : ... | null | true |
CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (I.cocomplex.d 0 1) = 0 | null | true |
FrameHom | Mathlib.Order.Hom.CompleteLattice | (α : Type u_8) → (β : Type u_9) → [CompleteLattice α] → [CompleteLattice β] → Type (max u_8 u_9) | The type of frame homomorphisms from `α` to `β`. They preserve finite meets and arbitrary joins.
| true |
NormedDivisionRing.ratCast._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_3} → (ℕ → α) → (ℤ → α) → (α → α → α) → ℚ → α | null | false |
Std.DTreeMap.Internal.Impl.balanceₘ.fun_cases_unfolding | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k)
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (l r : Std.DTreeMap.Internal.Impl α β),
l.size + r.size ≤ 1 → motive l r (Std.DTreeMap.Internal.Impl.bin k v l r)) →
(∀ (l : Std.DTreeMap... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.revMatchAt?_eq_revMatchAt?_decide._simp_1_1 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt p pos pos' =
String.Slice.Pattern.Model.IsLongestRevMatchAt (fun x => decide (p x)) pos pos' | null | false |
LieAlgebra.IsExtension.exact | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} {i : N →ₗ⁅R⁆ L} {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], i.range = ↑R L p.ker | null | true |
MonotoneOn._to_dual_cast_4 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
MonotoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → b ≤ a → f b ≤ f a | null | false |
FirstOrder.Language.Ultraproduct.structure._aux_3 | Mathlib.ModelTheory.Ultraproducts | {α : Type u_1} →
{M : α → Type u_2} →
{u : Ultrafilter α} →
{L : FirstOrder.Language} →
[(a : α) → L.Structure (M a)] →
autoParam ({n : ℕ} → L.Relations n → (Fin n → (↑u).Product M) → Prop)
FirstOrder.Language.Structure.RelMap._autoParam | null | false |
CategoryTheory.Lax.LaxTrans.StrongCore.naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.StrongCore η →
{a b : B} →
(f : a ⟶ b) →
... | The underlying 2-isomorphisms of the naturality constraint. | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux | Mathlib.CategoryTheory.Sites.CoverLifting | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{A : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} A] →
{J : CategoryTheory.GrothendieckTop... | Auxiliary definition for `lift`. | true |
_private.Mathlib.Condensed.Discrete.LocallyConstant.0.CompHausLike.LocallyConstant.adjunction._proof_2 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : CompHausLike.HasExplicitFiniteCoproducts P] [inst_1 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
(X : CategoryTheory.Sheaf (CategoryTheory.coher... | null | false |
groupCohomology.cocycles₁IsoOfIsTrivial._proof_6 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_2, u_1, u_1} k G) [hA : A.IsTrivial]
(x x_1 : ↥(groupCohomology.cocycles₁ A)),
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } =
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } | null | false |
Lean.Parser.Term.arrow.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
isOpen_range_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_2} {σ : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpen (Set.range (Sigma.mk i)) | null | true |
definition._@.Mathlib.Topology.FiberBundle.Constructions.1875155857._hygCtx._hyg.8 | Mathlib.Topology.FiberBundle.Constructions | {B : Type u} →
(F : Type v) →
(E : B → Type w₁) →
{B' : Type w₂} →
(f : B' → B) →
[TopologicalSpace B'] →
[TopologicalSpace (Bundle.TotalSpace F E)] → TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E)) | null | false |
Matrix.toBilin'_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁] {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix n n R₁) (x y : n → R₁), ((Matrix.toBilin' M) x) y = ∑ i, ∑ j, x i * M i j * y j | null | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.withNewEqs | Mathlib.Lean.Meta.CongrTheorems | Lean.Meta.FunInfo →
{α : Type} →
Array Lean.Expr →
Array Lean.Expr →
Array Bool →
(Array Lean.Meta.CongrArgKind → Array (Option (Lean.Expr × Lean.Expr × Lean.Expr)) → Lean.MetaM α) →
Lean.MetaM α | Introduce variables for equalities between the arrays of variables. Uses `fixedParams`
to control whether to introduce an equality for each pair. The array of triples passed to `k`
consists of (1) the simple congr lemma HEq arg, (2) the richer HEq arg, and (3) how to
compute 1 in terms of 2. | true |
SimpleGraph.Walk.IsHamiltonianCycle.cycleGraph_cycle | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ (n : ℕ), (SimpleGraph.cycleGraph.cycle n).IsHamiltonianCycle | null | true |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.instInfSet._simp_2 | Mathlib.Algebra.Lie.Submodule | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
KaehlerDifferential.isBaseChange | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTow... | If `B` is the tensor product of `S` and `A` over `R`,
then `Ω[B⁄S]` is the base change of `Ω[A⁄R]` along `R → S`.
| true |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.DoOps.default._sparseCasesOn_4 | Lean.Elab.Do.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
MeasCat.instLargeCategory._proof_5 | Mathlib.MeasureTheory.Category.MeasCat | ∀ {X Y Z : MeasCat} (f : { f // Measurable f }) (g : { f // Measurable f }), Measurable (↑g ∘ ↑f) | null | false |
Filter.tendsto_neg_atTop_iff._simp_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot | null | false |
Int.zmultiples_sup | Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas | ∀ (a b : ℤ), AddSubgroup.zmultiples a ⊔ AddSubgroup.zmultiples b = AddSubgroup.zmultiples ↑(a.gcd b) | null | true |
SimplexCategory.δ_one_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory.δ 1 = { len := 0 }.const { len := 0 + 1 } 0 | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology.0.CochainComplex.HomComplex.CohomologyClass.toHom._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_6} [inst_1 : AddZeroClass M] {f : G →+ M} {x : G},
(x ∈ f.ker) = (f x = 0) | null | false |
Matrix.spectrum_toLpLin | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(p : ENNReal), spectrum 𝕜 ((Matrix.toLpLin p p) A) = spectrum 𝕜 A | The spectrum of a matrix `A` coincides with the spectrum of `toLpLin p p A`. | true |
Lean.Meta.Sym.SymExtension.id | Lean.Meta.Sym.SymM | {σ : Type} → Lean.Meta.Sym.SymExtension σ → ℕ | null | true |
Units.instIsManifoldModelWithCornersSelf | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {n : WithTop ℕ∞} {𝕜 : Type u_2}
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedAlgebra 𝕜 R], IsManifold (modelWithCornersSelf 𝕜 R) n Rˣ | null | true |
Lean.Meta.DiscrTree.Key.star | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key | null | true |
FirstOrder.Language.BoundedFormula.listEncode.eq_def | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (x_1 : L.BoundedFormula α x),
x_1.listEncode =
match x, x_1 with
| n, FirstOrder.Language.BoundedFormula.falsum => [Sum.inr (Sum.inr (n + 2))]
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => [Sum.inl ⟨x, t₁⟩, Sum.inl ⟨x, t₂⟩]
| n, FirstOrder.Lan... | null | true |
MvQPF.WEquiv.below.trans | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} (u v w : (MvQPF.P F).W α) (a : MvQPF.WEquiv u v)
(a_1 : MvQPF.WEquiv v w),
MvQPF.WEquiv.below a → motive u v a → MvQPF.WEquiv.below a_1 → motive v w a_1 → MvQPF.WEquiv.be... | null | true |
Multiset.nodup_zero | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1}, Multiset.Nodup 0 | null | true |
Lean.Server.LoadedILean.refs | Lean.Server.References | Lean.Server.LoadedILean → Lean.Lsp.ModuleRefs | Reference information from this ILean. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceLE._regBuiltin.Int.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2835252116._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
PolynomialModule.ofCoeff_injective | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Function.Injective (PolynomialModule.ofCoeff R) | null | true |
EReal.nhds_top | Mathlib.Topology.Instances.EReal.Lemmas | nhds ⊤ = ⨅ a, ⨅ (_ : a ≠ ⊤), Filter.principal (Set.Ioi a) | null | true |
DirectSum.instNonUnitalNonAssocRingOfNat._proof_8 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddZeroClass ι] (x : ℤ) (x_1 : A 0), (DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 | null | false |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE._unary.eq_def | Init.Data.String.Lemmas.FindPos | ∀ (s : String.Slice) (_x : (offset : String.Pos.Raw) ×' offset ≤ s.rawEndPos),
String.Slice.posGE._unary s _x =
PSigma.casesOn _x fun offset h =>
if h' : String.Pos.Raw.IsValidForSlice s offset then s.pos offset h'
else
have this := ⋯;
String.Slice.posGE._unary s ⟨offset.inc, ⋯⟩ | null | false |
Std.Time.Database.TZdb | Std.Time.Zoned.Database.TZdb | Type | Represents a Time Zone Database (TZdb) configuration with paths to local and general timezone data.
| true |
HomologicalComplex.mkHomFromDouble_f₁ | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} {f : X₀ ⟶ X₁} {ι : Type u_2} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁) (h : i₀ ≠ i₁) {K : HomologicalComplex C c} (φ₀ : X₀ ⟶ K.X... | null | true |
Lean.Parser.ParserInfo.collectTokens | Lean.Parser.Types | Lean.Parser.ParserInfo → List Lean.Parser.Token → List Lean.Parser.Token | null | true |
Lean.Meta.State._sizeOf_inst | Lean.Meta.Basic | SizeOf Lean.Meta.State | null | false |
CategoryTheory.Presieve.FamilyOfElements.Compatible.to_sieveCompatible | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{S : CategoryTheory.Sieve X} {x : CategoryTheory.Presieve.FamilyOfElements P S.arrows},
x.Compatible → x.SieveCompatible | null | true |
isInteger_of_is_root_of_monic | Mathlib.RingTheory.Polynomial.RationalRoot | ∀ {A : Type u_1} {K : Type u_2} [inst : CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [inst_3 : Field K]
[inst_4 : Algebra A K] [IsFractionRing A K] {p : Polynomial A},
p.Monic → ∀ {r : K}, (Polynomial.aeval r) p = 0 → IsLocalization.IsInteger A r | **Integral root theorem**:
if `r : f.codomain` is a root of a monic polynomial over the ufd `A`,
then `r` is an integer | true |
TopCat.Presheaf.toPushforwardOfIso_app._proof_1 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} (H₁ : X ≅ Y) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ),
U =
(TopologicalSpace.Opens.map H₁.hom).op.obj (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U))) | null | false |
AddUnits.instAddCommGroupAddUnits | Mathlib.Algebra.Group.Units.Defs | {α : Type u_1} → [inst : AddCommMonoid α] → AddCommGroup (AddUnits α) | Additive units of an additive commutative monoid form
an additive commutative group. | true |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Even | ∀ {R : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {A : Type u_1} [inst_3 : Ring A] [inst_4 : Algebra R A] (f : CliffordAlgebra.EvenHom Q A)
(x : M) (x_1 x_2 : A × ↥(CliffordAlgebra.even.lift.S✝ f)),
(↑(x_1 + x_2).2 x, ⟨LinearMap.mulRight R ... | null | false |
_private.Std.Http.Protocol.H1.Reader.0.Std.Http.Protocol.H1.Reader.instBEqBodyState.beq._sparseCasesOn_4 | Std.Http.Protocol.H1.Reader | {motive : Std.Http.Protocol.H1.Reader.BodyState → Sort u} →
(t : Std.Http.Protocol.H1.Reader.BodyState) →
motive Std.Http.Protocol.H1.Reader.BodyState.closeDelimited → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Internal.Impl.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] (k : α),
Std.DTreeMap.Internal.Impl.leaf.get? k = none | null | true |
_private.Mathlib.Topology.Algebra.Group.Matrix.0.Matrix.SpecialLinearGroup.range_toGL.match_1_2 | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {A : Type u_2} [inst_2 : CommRing A] (x : GL n A)
(motive : (∃ y, ↑y = ↑x) → Prop) (x_1 : ∃ y, ↑y = ↑x),
(∀ (y : Matrix.SpecialLinearGroup n A) (hy : ↑y = ↑x), motive ⋯) → motive x_1 | null | false |
Group.nilpotent_of_surjective | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] {G' : Type u_2} [inst_1 : Group G'] [h : Group.IsNilpotent G] (f : G →* G'),
Function.Surjective ⇑f → Group.IsNilpotent G' | The range of a surjective homomorphism from a nilpotent group is nilpotent. | true |
Real.exists_seq_rat_strictAnti_tendsto | Mathlib.Topology.Instances.Real.Lemmas | ∀ (x : ℝ), ∃ u, StrictAnti u ∧ (∀ (n : ℕ), x < ↑(u n)) ∧ Filter.Tendsto (fun x => ↑(u x)) Filter.atTop (nhds x) | null | true |
PadicInt.intCast_eq | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (z1 z2 : ℤ), ↑z1 = ↑z2 ↔ z1 = z2 | null | true |
List.le_apply_get_maxOn?_of_mem | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β}
{xs : List α} {x : α} (h : x ∈ xs), f x ≤ f ((List.maxOn? f xs).get ⋯) | null | true |
SetLike.GradeZero.instRing._proof_9 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
OrderIso.sumLexAssoc_apply_inl_inr | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (b : β),
(OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inr b)))) = toLex (Sum.inr (toLex (Sum.inl b))) | null | true |
GrpCat.SurjectiveOfEpiAuxs.g_apply_fromCoset | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B) (x : ↑B) (y : ↑(Set.range fun x => x • ↑(GrpCat.Hom.hom f).range)),
((GrpCat.SurjectiveOfEpiAuxs.g f) x) (GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset y) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨x • ↑y, ⋯⟩ | null | true |
integral_log | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (s : ℝ) in a..b, Real.log s = b * Real.log b - a * Real.log a - b + a | null | true |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_getLast_mem_of_prefix._proof_1_8 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → ∀ {hne : l₂ ≠ []}, l₂.getLast hne ∈ l₁ → l₂.Nodup → l₁ = l₂ | null | false |
CategoryTheory.FreeMonoidalCategory.Hom.ctorElim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
(ctorIdx : ℕ) →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
ctorIdx = t.ctorIdx → CategoryTheory.FreeMonoidalCategory.Hom.ctorElimType ctorIdx → motive a a_1 t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.