name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Array.any_flatten' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {stop : ℕ} {f : α → Bool} {xss : Array (Array α)},
stop = xss.flatten.size → xss.flatten.any f 0 stop = xss.any fun x => x.any f | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform.0.CategoryTheory.Limits.CatCospanTransform.instIsIsoWhiskerRight._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | false |
CategoryTheory.MonoOver.imageMonoOver | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasImage f] → CategoryTheory.MonoOver Y | The `MonoOver Y` for the image inclusion for a morphism `f : X ⟶ Y`.
| true |
Mathlib.Tactic.BicategoryLike.IsoLift.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Mathlib.Tactic.BicategoryLike.IsoLift | null | false |
Representation.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice.match_1 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (motive : ↥ρ.invtSubmodule → Prop) (x : ↥ρ.invtSubmodule),
(∀ (p : Submodule k V) (hp : p ∈ ρ.invtSubmodule), motive ⟨p, hp⟩) → motive x | null | false |
OrderDual.instDistribMulAction._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Action.Synonym | ∀ {G₀ : Type u_1} {M₀ : Type u_2} [inst : Monoid G₀] [inst_1 : AddMonoid M₀] [inst_2 : DistribMulAction G₀ M₀]
(a : G₀ᵒᵈ), a • 0 = 0 | null | false |
Equiv.Perm.IsCycle.zpowersEquivSupport.congr_simp | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle),
hσ.zpowersEquivSupport = hσ.zpowersEquivSupport | null | true |
fintypeAffineCoords.eq_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ (ι : Type u_1) (k : Type u_2) [inst : Ring k] [inst_1 : Fintype ι],
fintypeAffineCoords ι k = AffineSubspace.comap (Fintype.linearCombination k 1).toAffineMap (affineSpan k {1}) | null | true |
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap α Unit cmp} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
k ∉ t → List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (t.insertManyIfNewUnit l).getKey? k' = some k | null | true |
ModelWithCorners.continuous_invFun | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (self : ModelWithCorners 𝕜 E H),
Continuous self.invFun | null | true |
Lean.PrettyPrinter.Delaborator.delabNeg | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | Delaborates the negative of an `OfNat.ofNat` literal.
`-@OfNat.ofNat _ n _` ~> `-n`
| true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.nomatch._regBuiltin.Lean.Parser.Term.nomatch.formatter_9 | Lean.Parser.Term | IO Unit | null | false |
AlgEquiv.autCongr_trans | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₃ : Type uA₃} [inst : CommSemiring R] [inst_1 : Semiring A₁]
[inst_2 : Semiring A₂] [inst_3 : Semiring A₃] [inst_4 : Algebra R A₁] [inst_5 : Algebra R A₂] [inst_6 : Algebra R A₃]
(ϕ : A₁ ≃ₐ[R] A₂) (ψ : A₂ ≃ₐ[R] A₃), ϕ.autCongr.trans ψ.autCongr = (ϕ.trans ψ).autCongr | null | true |
CategoryTheory.SimplicialObject.Splitting.πSummand_comp_cofan_inj_id_comp_PInfty_eq_PInfty | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] (n : ℕ),
CategoryTheory.CategoryStruct.comp
(s.πSummand (CategoryTheory.SimplicialObject.Splitting.IndexSet.id (Opposite.op { len := n })))
(Ca... | null | true |
Filter.Tendsto.inseparable_iff_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] {β : Type u_1} {l : Filter β} [l.NeBot] {f g : β → α} {a b : α},
Filter.Tendsto f l (nhds a) →
Filter.Tendsto g l (nhds b) → (Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (uniformity α)) | null | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.zero_mem_asymptoticCone._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
Set.image_subset_iff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, f '' s ⊆ t ↔ s ⊆ f ⁻¹' t | image and preimage are a Galois connection | true |
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem_toSpecΓ_assoc | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : ↥X) (hxU : x ∈ U) {Z : AlgebraicGeometry.Scheme}
(h : AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (U.fromSpecStalkOfMem x hxU) (CategoryTheory.CategoryStruct.comp U.toSpecΓ h) =
CategoryTheory.CategoryStruct... | null | true |
ISize | Init.Data.SInt.Basic | Type | Signed integers that are the size of a word on the platform's architecture.
On a 32-bit architecture, `ISize` is equivalent to `Int32`. On a 64-bit machine, it is equivalent to
`Int64`. This type has special support in the compiler so it can be represented by an unboxed value.
| true |
CategoryTheory.Functor.structuredArrowMapCone._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (G : CategoryTheory.Functor D H) (α : L.comp G ⟶ F)
(Y : D)... | null | false |
MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint | Mathlib.MeasureTheory.Measure.Basic | ∀ {α : Type u_1} {ι : Type u_3} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
(∀ (i : ι), MeasurableSet (As i)) → Pairwise (Function.onFun Disjoint As) → ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i) | The measure of a disjoint union (even uncountable) of measurable sets is at least the sum of
the measures of the sets. | true |
ContinuousMap.Homotopy.affine_apply | Mathlib.Topology.Homotopy.Affine | ∀ {X : Type u_1} {E : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : IsTopologicalAddGroup E] [inst_4 : Module ℝ E] [inst_5 : ContinuousSMul ℝ E] (f g : C(X, E))
(x : ↑unitInterval × X), (ContinuousMap.Homotopy.affine f g) x = (AffineMap.lineMap (f x.2) (g x.... | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.constrToProp.match_3 | Lean.Meta.MkIffOfInductiveProp | (motive : Option ℕ × Lean.Expr → Sort u_1) →
(x : Option ℕ × Lean.Expr) → ((n : Option ℕ) → (r : Lean.Expr) → motive (n, r)) → motive x | null | false |
SubMulAction.ofStabilizer.conjMap._proof_4 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_2} [inst : Group G] {α : Type u_1} [inst_1 : MulAction G α] {g : G} {a b : α},
b = g • a → ∀ (x : ↥(MulAction.stabilizer G a)) (x_1 : ↥(SubMulAction.ofStabilizer G a)), g • ↑(x • x_1) ∈ {b} → False | null | false |
RegularExpression.matches'.eq_def | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (x : RegularExpression α),
x.matches' =
match x with
| RegularExpression.zero => 0
| RegularExpression.epsilon => 1
| RegularExpression.char a => {[a]}
| P.plus Q => P.matches' + Q.matches'
| P.comp Q => P.matches' * Q.matches'
| P.star => KStar.kstar P.matches' | null | true |
TensorProduct.Neg.aux | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
{M : Type u_2} →
{N : Type u_3} →
[inst_1 : AddCommGroup M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → TensorProduct R M N →ₗ[R] TensorProduct R M N | Auxiliary function to defining negation multiplication on tensor product. | true |
_private.Init.Data.Array.Lemmas.0.Array.all_toList._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a | null | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticStop__1 | Init.Tactics | Lean.Macro | `stop` is a helper tactic for "discarding" the rest of a proof:
it is defined as `repeat sorry`.
It is useful when working on the middle of a complex proofs,
and less messy than commenting the remainder of the proof.
| false |
CategoryTheory.eqToIso | Mathlib.CategoryTheory.EqToHom | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → X = Y → (X ≅ Y) | An equality `X = Y` gives us an isomorphism `X ≅ Y`.
It is typically better to use this, rather than rewriting by the equality then using `Iso.refl _`
which usually leads to dependent type theory hell.
| true |
Finset.eventually_cocardinal_notMem | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u} {c : Cardinal.{u}} {hreg : c.IsRegular} (s : Finset α), ∀ᶠ (x : α) in Filter.cocardinal α hreg, x ∉ s | null | true |
HomologicalComplex.cyclesMap_inv._simp_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} (φ : K ⟶ L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i] [inst_4 : CategoryTheory.IsIso φ],
HomologicalComplex.cycl... | null | false |
Lean.Elab.instInhabitedDefView | Lean.Elab.DefView | Inhabited Lean.Elab.DefView | null | true |
SSet.prodStdSimplex.objEquiv._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ {p q n : ℕ}
(x :
CategoryTheory.MonoidalCategoryStruct.tensorObj ((SSet.stdSimplex.obj { len := p }).obj (Opposite.op { len := n }))
((SSet.stdSimplex.obj { len := q }).obj (Opposite.op { len := n }))),
(SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.fst.comp
... | null | false |
ZMod.charZero | Mathlib.Data.ZMod.Basic | CharZero (ZMod 0) | null | true |
Std.TreeMap.Raw.toArray_filterMap | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {f : α → β → Option γ},
t.WF →
(Std.TreeMap.Raw.filterMap f t).toArray =
Array.filterMap (fun p => Option.map (fun x => (p.1, x)) (f p.1 p.2)) t.toArray | null | true |
star_mul_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ star r * r) = True | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_11 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), r₀ + -1 * r ≤ 0 → r₀ ≤ r | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz.0.SimpleGraph.zarankiewicz_le_iff.match_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz | ∀ {V : Type u_1} {W : Type u_2} {α : Type u_3} {β : Type u_4} (x : SimpleGraph (V ⊕ W))
(motive : x ≤ completeBipartiteGraph V W ∧ (completeBipartiteGraph α β).Free x → Prop)
(x_1 : x ≤ completeBipartiteGraph V W ∧ (completeBipartiteGraph α β).Free x),
(∀ (h_le : x ≤ completeBipartiteGraph V W) (h_free : (complet... | null | false |
Multiset.dedup_cons_of_mem | Mathlib.Data.Multiset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s → (a ::ₘ s).dedup = s.dedup | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence_eq_prefixFunction._simp_1_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
(String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ k) =
∀ (k' : ℕ),
k < k' → k' ≤ stackPos → ¬String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1) | null | false |
String.Pos.find? | Init.Data.String.Search | {ρ : Type} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[(s : String.Slice) → Std.IteratorLoop (σ s) Id Id] →
{s : String} → s.Pos → (pattern : ρ) → [String.Slice.Pattern.ToForwardSearcher pattern σ] → Option s.Pos | Finds the position of the first match of the pattern `pattern` in after the position
`pos`. If there is no match `none` is returned.
This function is generic over all currently supported patterns.
Examples:
* `("coffee tea water".startPos.find? Char.isWhitespace).map (·.get!) == some ' '`
* `("tea".pos ⟨1⟩ (by deci... | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.privateDecl._regBuiltin.Lean.Parser.Term.privateDecl.parenthesizer_11 | Lean.Parser.Term | IO Unit | null | false |
Besicovitch.SatelliteConfig.mk.inj | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {inst : MetricSpace α} {N : ℕ} {τ : ℝ} {c : Fin N.succ → α} {r : Fin N.succ → ℝ}
{rpos : ∀ (i : Fin N.succ), 0 < r i}
{h : Pairwise fun i j => r i ≤ dist (c i) (c j) ∧ r j ≤ τ * r i ∨ r j ≤ dist (c j) (c i) ∧ r i ≤ τ * r j}
{hlast : ∀ i < Fin.last N, r i ≤ dist (c i) (c (Fin.last N)) ∧ r (Fin.las... | null | true |
ProbabilityTheory.Kernel.withDensity_rnDeriv_of_subset_mutuallySingularSetSlice | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[inst : ProbabilityTheory.IsFiniteKernel η] {a : α} {s : Set γ},
s ⊆ κ.mutuallySingularSetSlice η a ... | null | true |
Hindman.FS.brecOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
{a : Stream' M} {a_1 : M} (t : Hindman.FS a a_1),
(∀ (a : Stream' M) (a_2 : M) (t : Hindman.FS a a_2), Hindman.FS.below t → motive a a_2 t) → motive a a_1 t | null | true |
CategoryTheory.yonedaCommRing._proof_8 | Mathlib.CategoryTheory.Monoidal.Cartesian.Ring | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y Z : CategoryTheory.CommRingObjCat C} (f : X ⟶ Y) (g : Y ⟶ Z),
{
app := fun X_1 =>
CommRingCat.ofHom
{ toFun := fun x => Catego... | null | false |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ | 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] →
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} →
(c : CategoryTheory.Limits.... | If a cone with values in `ShortComplex C` is such that it becomes limit
when we apply the three projections `ShortComplex C ⥤ C`, then it is limit. | true |
Lean.PersistentHashMap.Entry.ctorElimType | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
ℕ → Sort (max 1 u_1 (imax (u + 1) (v + 1) u_1) (imax (w + 1) u_1)) | null | false |
Set.biInter_finsetSigma_univ' | Mathlib.Data.Fintype.Sigma | ∀ {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_3} [inst : (i : ι) → Fintype (κ i)] (s : Finset ι)
(f : (i : ι) → κ i → Set α), ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd | null | true |
SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff._simp_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {b : β} {c : γ},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₂ c) (Sum3.in₁ b) = ∃ a, (a, b, c) ∈ t | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBSet.upperBoundP?_least.match_1_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {y : α} {t : RBTree.RBSet α cmp}
(motive : (∃ y_1 ∈ t.toList, cmp y y_1 = Ordering.eq) → Prop) (x : ∃ y_1 ∈ t.toList, cmp y y_1 = Ordering.eq),
(∀ (w : α) (h1 : w ∈ t.toList) (h2 : cmp y w = Ordering.eq), motive ⋯) → motive x | null | false |
Multiset.map_swap_antidiagonal | Mathlib.Data.Multiset.Antidiagonal | ∀ {α : Type u_1} (s : Multiset α), Multiset.map Prod.swap s.antidiagonal = s.antidiagonal | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodeExprWithEta.go._unsafe_rec | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array (Array Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry) →
Array (Array Lean.Meta.RefinedDiscrTree.Key) → Lean.MetaM (Array (Array Lean.Meta.RefinedDiscrTree.Key)) | null | false |
GradeMinOrder.recOn | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
[inst : Preorder 𝕆] →
[inst_1 : Preorder α] →
{motive : GradeMinOrder 𝕆 α → Sort u} →
(t : GradeMinOrder 𝕆 α) →
([toGradeOrder : GradeOrder 𝕆 α] →
(isMin_grade : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)) →
... | null | false |
QuadraticModuleCat.instMonoidalCategoryStruct._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
LinearPMap.sSup | 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 ... | For a family of (semi)linear maps with a directed domains such that the one defined on a larger
domain restricts to the one defined on the smaller domain, this defines the (semi)linear map defined
on the union of the domains extending all the (semi)linear maps in the family. | true |
Aesop.RulePatternIndex.recOn | Aesop.Index.RulePattern | {motive : Aesop.RulePatternIndex → Sort u} →
(t : Aesop.RulePatternIndex) →
((tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry) →
(isEmpty : Bool) → motive { tree := tree, isEmpty := isEmpty }) →
motive t | null | false |
AddOpposite.one_le_op._simp_1 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] {a : α}, (1 ≤ AddOpposite.op a) = (1 ≤ a) | null | false |
CategoryTheory.GrothendieckTopology.instIsGeneratedByOneHypercovers | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.IsGeneratedByOneHypercovers | null | true |
_private.Mathlib.Order.OrderIsoNat.0.RelEmbedding.wellFounded_iff_isEmpty.match_1_1 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} (motive : WellFounded r → Prop) (x : WellFounded r),
(∀ (h : ∀ (a : α), Acc r a), motive ⋯) → motive x | null | false |
CategoryTheory.linearYoneda_map_app | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : Cᵒᵖ),
((CategoryTheory.linearYoneda R C).map f).app Y =
ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite... | null | true |
CommSemiRingCat.instConcreteCategoryRingHomCarrier | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.ConcreteCategory CommSemiRingCat fun R S => ↑R →+* ↑S | null | true |
Std.DTreeMap.Internal.Impl.getKeyLT._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(x : Std.DTreeMap.Internal.Impl α β) →
Std.DTreeMap.Internal.Impl.below (motive := fun x => x.Ordered → (∃ a ∈ x, compare a k = Ordering.lt) → α)
x →
x.Ordered → (∃ a ∈... | null | false |
Polynomial.Chebyshev.S_two_mul_complex_cosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Basic | ∀ (θ : ℂ) (n : ℤ),
Polynomial.eval (2 * Complex.cosh θ) (Polynomial.Chebyshev.S ℂ n) * Complex.sinh θ = Complex.sinh ((↑n + 1) * θ) | The `n`-th rescaled Chebyshev polynomial of the second kind (Vieta–Fibonacci polynomial)
evaluates on `2 * cosh θ` to the value `sinh ((n + 1) * θ) / sinh θ`. | true |
Pi.instPNatPowAssoc | Mathlib.Algebra.Group.PNatPowAssoc | ∀ {ι : Type u_2} {α : ι → Type u_3} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → Pow (α i) ℕ+]
[∀ (i : ι), PNatPowAssoc (α i)], PNatPowAssoc ((i : ι) → α i) | null | true |
ProbabilityTheory.HasLaw.memLp | Mathlib.Probability.HasLaw | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {X : Ω → 𝓧}
{μ : MeasureTheory.Measure 𝓧} {P : MeasureTheory.Measure Ω} [inst : TopologicalSpace 𝓧] [inst_1 : ContinuousENorm 𝓧],
ProbabilityTheory.HasLaw X μ P → ∀ {p : ENNReal}, MeasureTheory.MemLp id p μ → MeasureTheory.MemL... | null | true |
NumberField.InfinitePlace.embedding_of_isReal_apply | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {w : NumberField.InfinitePlace K} (hw : w.IsReal) (x : K),
↑((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x | null | true |
Std.HashMap.contains_keysArray | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, m.keysArray.contains k = m.contains k | null | true |
AddGrpCat.addGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) → (j : J) → Zero ((F.comp (CategoryTheory.forget AddGrpCat)).obj j) | null | false |
Lean.KeyedDeclsAttribute.noConfusionType | Lean.KeyedDeclsAttribute | Sort u → {γ : Type} → Lean.KeyedDeclsAttribute γ → {γ' : Type} → Lean.KeyedDeclsAttribute γ' → Sort u | null | false |
Lean.Elab.Do.elabNestedAction | Lean.Elab.Do.Basic | Lean.Elab.Term.TermElab | null | true |
ContinuousInv.measurableInv | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [BorelSpace γ] [inst_3 : Inv γ]
[ContinuousInv γ], MeasurableInv γ | null | true |
WType.Listα.cons | Mathlib.Data.W.Constructions | {γ : Type u} → γ → WType.Listα γ | null | true |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.SplitIf.3526097586._hygCtx._hyg.2 | Lean.Meta.Tactic.SplitIf | IO Unit | null | false |
Homotopy.compLeftId | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f : D ⟶ D} →
Homotopy f (CategoryTheory.CategoryStruct.id D) →
(g : C ⟶ D... | a variant of `Homotopy.compLeft` useful for dealing with homotopy equivalences. | true |
CategoryTheory.Join.mapWhiskerRight_rightUnitor_hom | Mathlib.CategoryTheory.Join.Pseudofunctor | ∀ {A : Type u_1} {B : Type u_2} (C : Type u_3) [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(F : CategoryTheory.Functor A B),
CategoryTheory.Join.mapWhiskerRight F.rightUnitor.hom (CategoryTheory.Functor.id C) =
C... | null | true |
Preorder.OfStdArgs._sizeOf_1 | Mathlib.Order.Std | {α : Type u_1} → [SizeOf α] → Preorder.OfStdArgs α → ℕ | null | false |
Std.TreeMap.Raw._sizeOf_inst | Std.Data.TreeMap.Raw.Basic | (α : Type u) →
(β : Type v) →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw._auto_1) →
[SizeOf α] → [SizeOf β] → SizeOf (Std.TreeMap.Raw α β cmp) | null | false |
Turing.ToPartrec.Code.zero_eval | Mathlib.Computability.TuringMachine.Config | ∀ (v : List ℕ), Turing.ToPartrec.Code.zero.eval v = pure [0] | null | true |
Mathlib.Tactic.BicategoryLike.State.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.PersistentExprMap Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.State | null | false |
Subgroup.zpow._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (a : ↥H) (n : ℤ), ↑a ^ n ∈ H | null | false |
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : AddCommMonoid β]
[inst_3 : Preorder β] [inst_4 : IsOrderedAddMonoid β],
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid =
{
add := fun f g =>
let __src := ↑f + ↑g;
{ toAddMonoidHom := __src, monotone' :=... | null | true |
CategoryTheory.Limits.opProdIsoCoprod_inv_inl | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProdIsoCoprod A B).inv.unop
CategoryTheory.Limits.coprod.inl.unop =
CategoryTheory.Limits.prod.fst | null | true |
TopologicalSpace.IsTopologicalBasis.isOpen_iff | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α} {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → (IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s) | null | true |
instBooleanAlgebraAsBoolAlg._proof_9 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : AsBoolAlg α), Mul.mul a b ≤ b | null | false |
AddCon.addMonoid._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] (c : AddCon M) (a b c_1 : c.Quotient), a + b + c_1 = a + (b + c_1) | null | false |
SimpleGraph.bot_adj | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (v w : V), ⊥.Adj v w ↔ False | null | true |
Subring.mem_pointwise_smul_iff_inv_smul_mem | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Subring R} {x : R}, x ∈ a • S ↔ a⁻¹ • x ∈ S | null | true |
CategoryTheory.Grp.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (H : CategoryTheory.Grp C) [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.MonObj.one.hom.hom = CategoryTheory.MonObj.one | null | true |
_private.Mathlib.AlgebraicGeometry.Sites.EtalePoint.0.AlgebraicGeometry.Scheme.isConservativeFamilyOfPoints_pointSmallEtale'._simp_1_2 | Mathlib.AlgebraicGeometry.Sites.EtalePoint | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Aesop.Hyp.mk | Aesop.Forward.State | Option Lean.FVarId → Aesop.Substitution → Aesop.Hyp | null | true |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k'... | null | true |
TypeVec.splitFun | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u_1} (n + 1)} → {α' : TypeVec.{u_2} (n + 1)} → α.drop.Arrow α'.drop → (α.last → α'.last) → α.Arrow α' | append an arrow and a function for arbitrary source and target type vectors | true |
WithTop.coe_covBy_top._simp_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (↑a ⋖ ⊤) = IsMax a | null | false |
Lean.Elab.CommandContextInfo.mk.injEq | Lean.Elab.InfoTree.Types | ∀ (env : Lean.Environment) (cmdEnv? : Option Lean.Environment) (fileMap : Lean.FileMap) (mctx : Lean.MetavarContext)
(options : Lean.Options) (currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (ngen : Lean.NameGenerator)
(env_1 : Lean.Environment) (cmdEnv?_1 : Option Lean.Environment) (fileMap_1 : Lean.Fi... | null | true |
PowerSeries.coeff_pow | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] (k n : ℕ) (φ : PowerSeries R),
(PowerSeries.coeff n) (φ ^ k) =
∑ l ∈ (Finset.range k).finsuppAntidiag n, ∏ i ∈ Finset.range k, (PowerSeries.coeff (l i)) φ | The `n`-th coefficient of the `k`-th power of a power series. | true |
Array.PrefixTable.step._proof_12 | Batteries.Data.Array.Match | ∀ {α : Type u_1} (t : Array.PrefixTable α) (k : ℕ),
k + 1 < t.size + 1 → ∀ (h2 : k < t.size), t.toArray[k].2 < k + 1 → t.toArray[k].2 < t.size + 1 | null | false |
Matrix.PosSemidef.kronecker | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [Finite n] {m : Type u_3} [Finite m] {x : Matrix n n 𝕜}
{y : Matrix m m 𝕜}, x.PosSemidef → y.PosSemidef → (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) x y).PosSemidef | The kronecker product of two positive semi-definite matrices is positive semi-definite. | true |
_private.Mathlib.Data.Nat.Factorial.DoubleFactorial.0.Nat.doubleFactorial.match_1.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (k : ℕ) → motive k.succ.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| k.succ.succ => h_3 k) =
h_2 () | null | true |
fderivWithin_inter | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
t ∈ nhds x → fderivWithin 𝕜 f (s ∩ t... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.