name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_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.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_8} {x : 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 |
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 })
(SSet.stdSimplex.obj { len := q })).obj
(Opposite.op { len := n })),
(SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.fst.comp
(match x with
... | 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 |
ENNReal.tendsto_inv_iff | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G] {l : Filter α}
{m : α → G} {a : G}, Filter.Tendsto (fun x => (m x)⁻¹) l (nhds a⁻¹) ↔ Filter.Tendsto m l (nhds a) | **Alias** of `tendsto_inv_iff`. | true |
_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 |
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.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 |
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) → Add ((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 |
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 : c.Quotient), 0 + a = a | 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 |
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 |
_private.Mathlib.Order.Category.BoolAlg.0.BoolAlg.Hom.mk.injEq | Mathlib.Order.Category.BoolAlg | ∀ {X Y : BoolAlg} (hom' hom'_1 : BoundedLatticeHom ↑X ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | true |
Sym2.coe_map | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (z : Sym2 α), ↑(Sym2.map f z) = f '' ↑z | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero.0.CategoryTheory.Functor.map_isZero._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Multiset.sup_eq_union | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ⊔ t = s ∪ t | null | true |
Aesop.ForwardRuleStateStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardRuleStateStats → ℕ | null | false |
MonoidHom.id._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_1) [inst : MulOne M], 1 = 1 | null | false |
HahnModule.instIsTorsionFree | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {R : Type u_3} {Γ : Type u_6} {V : Type u_7} [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup V]
[inst_3 : AddCommMonoid Γ] [inst_4 : LinearOrder Γ] [inst_5 : IsOrderedCancelAddMonoid Γ] [inst_6 : Module R V]
[Module.IsTorsionFree R V], Module.IsTorsionFree (HahnSeries Γ R) (HahnModule Γ R V) | null | true |
Ideal.comap._proof_3 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) {x y : R}, x ∈ ⇑f ⁻¹' ↑I → y ∈ ⇑f ⁻¹' ↑I → x + y ∈ ⇑f ⁻¹' ↑I | null | false |
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_5} {n : WithTop ℕ∞} {E₁ : B → Type u_6}
{E₂ : B → Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
... | null | false |
Std.ExtHashSet.contains_of_contains_insert' | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α}, (m.insert k).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_insert` that is written to exactly match the proof
obligation in the statement of `get_insert`. | true |
NormedCommRing.toNonUnitalNormedCommRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | null | false |
AddCommGrpCat.epi_iff_range_eq_top | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ (AddCommGrpCat.Hom.hom f).range = ⊤ | null | true |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (∃ n, x ≤ ↑n) → Prop) (x_1 : ∃ n, x ≤ ↑n),
(∀ (n : ℕ) (h : x ≤ ↑n), motive ⋯) → motive x_1 | null | false |
Homotopy.symm._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} (h : Homotopy f g) (i j : ι),
¬c.Rel j i → (-h.hom) i j = 0 | null | false |
Lean.Elab.Visibility.private.elim | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → t.ctorIdx = 1 → motive Lean.Elab.Visibility.private → motive t | null | false |
Finset.Icc_ofDual | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : αᵒᵈ),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a) | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
DoubleCoset.eq_of_not_disjoint | Mathlib.GroupTheory.DoubleCoset | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
¬Disjoint (DoubleCoset.doubleCoset a ↑H ↑K) (DoubleCoset.doubleCoset b ↑H ↑K) →
DoubleCoset.doubleCoset a ↑H ↑K = DoubleCoset.doubleCoset b ↑H ↑K | null | true |
Mathlib.Tactic.Bicategory.naturality_inv | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a ⟶ b} {f g : b ⟶ c} {pf : a ⟶ c} {η : f ≅ g}
(η_f : CategoryTheory.CategoryStruct.comp p f ≅ pf) (η_g : CategoryTheory.CategoryStruct.comp p g ≅ pf),
CategoryTheory.Bicategory.whiskerLeftIso p η ≪≫ η_g = η_f →
CategoryTheory.Bicategory.whiske... | null | true |
IsAddQuotientCoveringMap.homeomorph_comp_iff | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] {Y : Type u_4} [inst_4 : TopologicalSpace Y] (φ : X ≃ₜ Y),
IsAddQuotientCoveringMap (⇑φ ∘ f) G ↔ IsAddQuotientCoveringMap f G | null | true |
Valued.integer.norm_unit | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (u : (↥(Valued.integer K))ˣ),
‖↑u‖ = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.