name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousAlgHom.coe_id' | Mathlib.Topology.Algebra.Algebra | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
[inst_3 : Algebra R A], ⇑(ContinuousAlgHom.id R A) = id | null | true |
_private.Mathlib.Logic.Relation.0.Acc.of_downward_closed.match_1_1 | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : β) (motive : (∃ c, f c = x) → Prop) (x_1 : ∃ c, f c = x),
(∀ (a' : α) (he : f a' = x), motive ⋯) → motive x_1 | null | false |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.maxEntry?.match_1._arg_pusher | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (α_1 : Sort u✝)
(β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x) (rel : Std.DTreeMap.Internal.Impl α β → α_1 → Prop)
(x : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → ((y : α_1) → rel Std.DTreeMap.Internal.Impl.leaf y → β_1 y) ... | null | false |
Turing.Tape.mk₂ | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → List Γ → List Γ → Turing.Tape Γ | Construct a tape from a left side and an inclusive right side. | true |
CategoryTheory.Equivalence.inverseFunctorObj'_hom_app | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (e : C ≌ D) (X : D),
e.inverseFunctorObj'.hom.app X = CategoryTheory.CategoryStruct.id (e.inverse.obj X) | null | true |
_private.Mathlib.Geometry.Manifold.Bordism.0.SingularManifold.instIsEmptyMEmpty._proof_1 | Mathlib.Geometry.Manifold.Bordism | ∀ {X : Type u_2} [inst : TopologicalSpace X] {k : WithTop ℕ∞} {E : Type u_3} {H : Type u_4} {M : Type u_1}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : FiniteDimensional ℝ E]
[inst_4 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} [inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M]
... | null | false |
Lake.instCheckExistsFilePath | Lake.Build.Trace | Lake.CheckExists System.FilePath | null | true |
CategoryTheory.monoidalUnopUnop._proof_16 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y Z : Cᵒᵖᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.... | null | false |
CategoryTheory.MorphismProperty.LeftFractionRel.trans | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
{z₁ z₂ z₃ : W.LeftFraction X Y} [W.HasLeftCalculusOfFractions],
CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₂ →
CategoryTheory.MorphismProperty.LeftFractionRel z₂ z₃ → CategoryTheory.Morphism... | null | true |
Matrix.diagonal_injective | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α], Function.Injective Matrix.diagonal | null | true |
CategoryTheory.ShortComplex.Exact.isLimitImage._proof_6 | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C}, CategoryTheory.Limits.HasCokernel S.f | null | false |
ProjectiveSpectrum.subset_zeroLocus_iff_le_vanishingIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (t : Set (ProjectiveSpectrum 𝒜)) (I : Ideal A),
t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 ↑I ↔ I ≤ (ProjectiveSpectrum.vanishingIdeal t).toIdeal | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.exists_fixed_point_of_prime._simp_1_2 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, (∀ (x : α), x ∈ s) = (s = Finset.univ) | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertMin._proof_16 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' l'' : Std.DTreeMap.Internal.Impl α β),
l''.size = 1 + l'.size → ¬l''.size + 1 + r'.size = 1 + (l'.size + 1 + r'.size) → False | null | false |
ContDiff.fun_comp | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {g : F → G} {f : E →... | null | true |
_private.Mathlib.Probability.Kernel.Proper.0.ProbabilityTheory.Kernel.IsProper.lintegral_indicator_mul_indicator._simp_1_1 | Mathlib.Probability.Kernel.Proper | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MulZeroClass M₀] {s t : Set ι} (f g : ι → M₀) (i : ι),
s.indicator f i * t.indicator g i = (s ∩ t).indicator (fun j => f j * g j) i | null | false |
Set.Definable.singleton | Mathlib.ModelTheory.Definability | ∀ {M : Type w} (L : FirstOrder.Language) [inst : L.Structure M] (a : M), {a}.Definable₁ L {a} | A singleton is definable by parameter as itself. | true |
RingAut.instGroup._proof_2 | Mathlib.Algebra.Ring.Aut | ∀ (R : Type u_1) [inst : Mul R] [inst_1 : Add R] (n : ℕ) (x : RingAut R), x ^ (n + 1) = x ^ n * x | null | false |
Nat.modEq_iff_exists_eq_add | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, a ≤ b → (a ≡ b [MOD n] ↔ ∃ t, b = a + n * t) | null | true |
Orthonormal.tsum_inner_products_le | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} (x : E) {v : ι → E}, Orthonormal 𝕜 v → ∑' (i : ι), ‖inner 𝕜 (v i) x‖ ^ 2 ≤ ‖x‖ ^ 2 | Bessel's inequality. | true |
_private.Init.Data.Iterators.Combinators.Monadic.Take.0.Std.Iterators.Types.Take.instFinitenessRelation._proof_1 | Init.Data.Iterators.Combinators.Monadic.Take | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [inst_1 : Std.Iterator α m β]
[inst_2 : Std.Iterators.Productive α m], WellFounded (Std.Iterators.Types.Take.Rel m) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.neg_one_ediv_toInt_eq._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {y : BitVec (w + 1 + 1)},
0 < y.toInt → (¬-1 = if y.toInt = 0 then 0 else if 0 < y.toInt then -1 else 1) → False | null | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.supports_union._simp_1_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
Nat.odd_sub' | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → (Odd (m - n) ↔ (Odd n ↔ Even m)) | null | true |
Lean.Grind.instCommRingUInt8._proof_3 | Init.GrindInstances.Ring.UInt | ∀ (i : ℤ) (a : UInt8), -i • a = -(i • a) | null | false |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore.match_1.splitter | Init.Data.Nat.ToString | (motive : ℕ → ℕ → List Char → Sort u_1) →
(x x_1 : ℕ) →
(x_2 : List Char) →
((x : ℕ) → (ds : List Char) → motive 0 x ds) →
((fuel n : ℕ) → (ds : List Char) → motive fuel.succ n ds) → motive x x_1 x_2 | null | true |
MonoidAlgebra.mapRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | {R : Type u_3} →
{S : Type u_4} →
(M : Type u_6) →
[inst : Semiring R] →
[inst_1 : Semiring S] → [inst_2 : Monoid M] → R ≃+* S → MonoidAlgebra R M ≃+* MonoidAlgebra S M | Isomorphic rings have isomorphic monoid algebras. | true |
_private.Mathlib.Data.PFun.0.PFun.preimage_inter._proof_1_1 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s t : Set β), f.preimage (s ∩ t) = f.preimage s ∩ f.preimage t | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.domCongr._simp_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (g : β ≃ γ) (l : α →₀ M),
Finsupp.equivMapDomain g (Finsupp.equivMapDomain f l) = Finsupp.equivMapDomain (f.trans g) l | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.FirstPage.0.CategoryTheory.Abelian.SpectralObject.spectralSequenceFirstPageXIso_hom._proof_7 | Mathlib.Algebra.Homology.SpectralObject.FirstPage | ∀ (n₁ n₂ : ℤ),
autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.spectralSequenceFirstPageXIso_hom._auto_3 → n₁ + 1 = n₂ | null | false |
Representation.IntertwiningMap.smul_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (a : A) (f : ρ.IntertwiningMap σ) (v : V), (a • f) v = a •... | null | true |
Pi.instIsDedekindFiniteAddMonoidForall | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → AddZeroClass (f i)] [∀ (i : I), IsDedekindFiniteAddMonoid (f i)],
IsDedekindFiniteAddMonoid ((i : I) → f i) | null | true |
Mathlib.Tactic.BicategoryLike.Normalize.Result.mk.injEq | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | ∀ (normalizedHom : Mathlib.Tactic.BicategoryLike.NormalizedHom) (toNormalize : Mathlib.Tactic.BicategoryLike.Mor₂Iso)
(normalizedHom_1 : Mathlib.Tactic.BicategoryLike.NormalizedHom)
(toNormalize_1 : Mathlib.Tactic.BicategoryLike.Mor₂Iso),
({ normalizedHom := normalizedHom, toNormalize := toNormalize } =
{ n... | null | true |
PrimeSpectrum.isClosedEmbedding_comap_snd | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S],
Topology.IsClosedEmbedding (PrimeSpectrum.comap (RingHom.snd R S)) | null | true |
FreeGroup.instGroup._proof_5 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (n : ℕ) (x : FreeGroup α), x ^ (n + 1) = x ^ n * x | null | false |
Algebra.GrothendieckAddGroup.instAddCommGroup._proof_6 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} [inst : AddCommMonoid M] (a b : Algebra.GrothendieckAddGroup M), a + b = b + a | null | false |
Std.Http.Protocol.H1.TakeResult.incomplete.elim | Std.Http.Protocol.H1.Parser | {motive : Std.Http.Protocol.H1.TakeResult → Sort u} →
(t : Std.Http.Protocol.H1.TakeResult) →
t.ctorIdx = 1 →
((data : ByteSlice) → (remaining : ℕ) → motive (Std.Http.Protocol.H1.TakeResult.incomplete data remaining)) →
motive t | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Append.0.Std.Iter.step_append.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Append | {α₁ β : Type u_1} →
[inst : Std.Iterator α₁ Id β] →
{it₁ : Std.Iter β} →
(motive : it₁.Step → Sort u_2) →
(x : it₁.Step) →
((it₁' : Std.Iter β) →
(out : β) →
(h : it₁.IsPlausibleStep (Std.IterStep.yield it₁' out)) → motive ⟨Std.IterStep.yield it₁' out, h⟩) →
... | null | true |
Int16.xor | Init.Data.SInt.Basic | Int16 → Int16 → Int16 | Bitwise exclusive or for 16-bit signed integers. Usually accessed via the `^^^` operator.
Each bit of the resulting integer is set if exactly one of the corresponding bits of the input
integers is set, according to the two's complement representation.
This function is overridden at runtime with an efficient implement... | true |
TopologicalSpace.isTopologicalBasis_singleton_empty | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α], TopologicalSpace.IsTopologicalBasis {∅} ↔ IsEmpty α | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.not_matchesAt_of_prefixFunction_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
NonUnitalStarSubalgebra.instNonUnitalCommRing._proof_9 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : NonUnitalRing A] [inst_2 : StarRing A]
[inst_3 : Module R A] [inst_4 : IsScalarTower R A A] [inst_5 : SMulCommClass R A A]
(a : ↥(NonUnitalStarSubalgebra.center R A)), 0 * a = 0 | null | false |
OpenPartialHomeomorph.univUnitBall._proof_3 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E], IsOpen (Metric.ball 0 1) | null | false |
Finset.Ioo_add_one_right_eq_Ioc | Mathlib.Algebra.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : LocallyFiniteOrder α] [inst_3 : Add α]
[SuccAddOrder α] [NoMaxOrder α] (a b : α), Finset.Ioo a (b + 1) = Finset.Ioc a b | null | true |
UniformSpace.Completion.instMulActionOfUniformContinuousConstSMul._proof_2 | Mathlib.Topology.Algebra.UniformMulAction | ∀ (M : Type u_2) (X : Type u_1) [inst : UniformSpace X] [inst_1 : Monoid M] [inst_2 : MulAction M X]
[UniformContinuousConstSMul M X] (a : X), 1 • ↑a = ↑a | null | false |
Aesop.Frontend.Parser.phaseNorm | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
Std.ExtDTreeMap.contains_iff_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, t.contains k = true ↔ k ∈ t | null | true |
rTensor.inverse_of_rightInverse_comp_rTensor | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
CategoryTheory.GradedObject.mapBifunctorLeftUnitor_hasMap | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_1} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) (X : C)
(... | null | true |
Lean.Meta.Grind.Params.anchorRefs? | Lean.Meta.Tactic.Grind.Main | Lean.Meta.Grind.Params → Option (Array Lean.Meta.Grind.AnchorRef) | null | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.srcM._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.WhiskerLeft → m Mathlib.Tactic.BicategoryLike.Mor₁ | null | false |
SubAddAction.instMin.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : VAdd R M],
SubAddAction.instMin = { min := fun s t => { carrier := ↑s ∩ ↑t, vadd_mem' := ⋯ } } | null | true |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Option.isSome.match_1.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (val : α) (h_1 : (val : α) → motive (some val))
(h_2 : Unit → motive none),
(match some val with
| some val => h_1 val
| none => h_2 ()) =
h_1 val | null | true |
Std.DTreeMap.Internal.Impl.filter.congr_simp | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (f f_1 : (a : α) → β a → Bool),
f = f_1 →
∀ (t t_1 : Std.DTreeMap.Internal.Impl α β) (e_t : t = t_1) (hl : t.Balanced),
Std.DTreeMap.Internal.Impl.filter f t hl = Std.DTreeMap.Internal.Impl.filter f_1 t_1 ⋯ | null | true |
FunLike.nonUnitalNonAssocSemiring._proof_3 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Mul F]
[inst_2 : NonUnitalNonAssocSemiring β] [IsMulApply F α β] (f g : F), ⇑(f * g) = ⇑f * ⇑g | null | false |
CategoryTheory.Limits.pasteHorizIsPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₃ Y₁ Y₂ Y₃ : C} →
{g₁ : Y₁ ⟶ Y₂} →
{g₂ : Y₂ ⟶ Y₃} →
{i₃ : X₃ ⟶ Y₃} →
{t₂ : CategoryTheory.Limits.PullbackCone g₂ i₃} →
{i₂ : t₂.pt ⟶ Y₂} →
{t₁ : CategoryTheory.Limits.PullbackCone g₁ i₂} ... | Given
```
X₁ - f₁ -> X₂ - f₂ -> X₃
| | |
i₁ i₂ i₃
↓ ↓ ↓
Y₁ - g₁ -> Y₂ - g₂ -> Y₃
```
Then the big square is a pullback if both the small squares are.
| true |
_private.Mathlib.Data.Seq.Computation.0.Computation.Corec.f.match_1.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} {β : Type u_2} (motive : α ⊕ β → Sort u_3) (a : α) (h_1 : (a : α) → motive (Sum.inl a))
(h_2 : (val : β) → motive (Sum.inr val)),
(match Sum.inl a with
| Sum.inl a => h_1 a
| Sum.inr val => h_2 val) =
h_1 a | null | true |
CategoryTheory.Functor.Elements.isoMk_inv | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} {x y : F.Elements}
(e : x.obj ≅ y.obj)
(he :
autoParam ((CategoryTheory.ConcreteCategory.hom (F.map e.hom)) x.val = y.val)
CategoryTheory.Functor.Elements.isoMk._auto_1),
(CategoryTheory.Functor.Elements.iso... | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.map_parallel._proof_1_7 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_2} {β : Type u_1} (f : α → β),
List.foldr
(fun c o =>
match o with
| Sum.inl a => Sum.inl a
| Sum.inr ls =>
match c.destruct with
| Sum.inl a => Sum.inl a
| Sum.inr b => Sum.inr (b :: ls))
(Sum.inr []) (List.map (Computation.map f) []) =
... | null | false |
BoxIntegral.TaggedPrepartition.isSubordinate_biUnionTagged | Mathlib.Analysis.BoxIntegral.Partition.Tagged | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {r : (ι → ℝ) → ↑(Set.Ioi 0)} [inst : Fintype ι]
{π : BoxIntegral.Prepartition I} {πi : (J : BoxIntegral.Box ι) → BoxIntegral.TaggedPrepartition J},
(π.biUnionTagged πi).IsSubordinate r ↔ ∀ J ∈ π, (πi J).IsSubordinate r | null | true |
Lean.Grind.Linarith.Expr.natMul.noConfusion | Init.Grind.Ordered.Linarith | {P : Sort u} →
{k : ℕ} →
{a : Lean.Grind.Linarith.Expr} →
{k' : ℕ} →
{a' : Lean.Grind.Linarith.Expr} →
Lean.Grind.Linarith.Expr.natMul k a = Lean.Grind.Linarith.Expr.natMul k' a' → (k = k' → a = a' → P) → P | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso._proof_8 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Comon (CategoryTheory.Functor C D)),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Comon.Hom.mk'
{
... | null | false |
Lean.Meta.CustomEliminator.elimName | Lean.Meta.Tactic.ElimInfo | Lean.Meta.CustomEliminator → Lean.Name | null | true |
_private.Mathlib.CategoryTheory.Sites.Sheaf.0.CategoryTheory.Presheaf.isLimit_iff_isSheafFor._simp_1_1 | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {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 | false |
CategoryTheory.ShortComplex.HasLeftHomology.of_hasKernel_of_hasCokernel | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Limits.HasKernel S.g]
[CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.lift S.g S.f ⋯)], S.HasLeftHomology | null | true |
Finset.Nat.instHasAntidiagonal._proof_1 | Mathlib.Data.Finset.NatAntidiagonal | ∀ {n : ℕ} {xy : ℕ × ℕ}, xy ∈ { val := Multiset.Nat.antidiagonal n, nodup := ⋯ } ↔ xy.1 + xy.2 = n | null | false |
Filter.mem_comk._simp_1 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {p : Set α → Prop} {he : p ∅} {hmono : ∀ (t : Set α), p t → ∀ s ⊆ t, p s}
{hunion : ∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)} {s : Set α}, (s ∈ Filter.comk p he hmono hunion) = p sᶜ | null | false |
exists_dist_le_lt | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] {x z : E} {δ ε : ℝ},
0 ≤ δ → 0 < ε → dist x z < ε + δ → ∃ y, dist x y ≤ δ ∧ dist y z < ε | null | true |
Std.Do.SPred.bientails.eq_2 | Std.Do.SPred.Laws | ∀ (σ : Type u) (tail : List (Type u)) (P_2 Q_2 : Std.Do.SPred (σ :: tail)), (P_2 ⊣⊢ₛ Q_2) = ∀ (s : σ), P_2 s ⊣⊢ₛ Q_2 s | null | true |
List.swapAt_eq_swapAtTR | Batteries.Data.List.Basic | @List.swapAt = @List.swapAtTR | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.FriendlyOperation.cons_tail | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : Tactic.ComputeAsymptotics.Basis}
{op :
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl}
{exp : ℝ} {coef : Tactic.ComputeAsymptotics.MultiseriesExpansion basis_tl},
... | null | true |
Lean.Meta.SimpTheorems.mk.injEq | Lean.Meta.Tactic.Simp.SimpTheorems | ∀ (pre post : Lean.Meta.SimpTheoremTree) (lemmaNames : Lean.PHashSet Lean.Meta.Origin)
(toUnfold : Lean.PHashSet Lean.Name) (erased : Lean.PHashSet Lean.Meta.Origin)
(toUnfoldThms : Lean.PHashMap Lean.Name (Array Lean.Name)) (pre_1 post_1 : Lean.Meta.SimpTheoremTree)
(lemmaNames_1 : Lean.PHashSet Lean.Meta.Origin... | null | true |
MvQPF.Fix.rec_unique | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : F (α ::: β) → β)
(h : MvQPF.Fix F α → β),
(∀ (x : F (α ::: MvQPF.Fix F α)), h (MvQPF.Fix.mk x) = g (MvFunctor.map (TypeVec.id ::: h) x)) → MvQPF.Fix.rec g = h | null | true |
_private.Aesop.Tree.ExtractProof.0.Aesop.SafePrefixState.recOn | Aesop.Tree.ExtractProof | {motive : Aesop.SafePrefixState✝ → Sort u} →
(t : Aesop.SafePrefixState✝) → ((goals : Array Lean.MVarId) → motive { goals := goals }) → motive t | null | false |
_private.Mathlib.Tactic.Attr.Register.0.initFn._@.Mathlib.Tactic.Attr.Register.2016062075._hygCtx._hyg.28 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.Simp.SimprocExtension | null | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Access.0.Std.Iter.atIdxSlow?_eq_match.match_1.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Access | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
Rat.lt_sub_right_iff_add_lt | Init.Data.Rat.Lemmas | ∀ {a b c : ℚ}, a < c - b ↔ a + b < c | null | true |
Pi.rightCancelSemigroup._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → RightCancelSemigroup (f i)], IsRightCancelMul ((i : I) → f i) | null | false |
_private.Mathlib.NumberTheory.NumberField.DirichletDensity.0.NumberField.Set.primeIdealZetaSum_le_card_of_finite._simp_1_4 | Mathlib.NumberTheory.NumberField.DirichletDensity | ∀ {R : Type u_1} [inst : CommRing R] (self : IsDedekindDomain.HeightOneSpectrum R), (self.asIdeal = ⊥) = False | null | false |
_private.Batteries.Data.Array.Scan.0.Array.getElem_scanr._proof_1_4 | Batteries.Data.Array.Scan | ∀ {α : Type u_2} {β : Type u_1} {i : ℕ} {b : β} {l : Array α} {f : α → β → β} (h : i < (Array.scanr f b l).size),
{ toList := List.scanr f b l.toList }[i] = List.foldr f b (l.extract i).toList | null | false |
omegaLimit_inter | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β)
(s₁ s₂ : Set α), omegaLimit f ϕ (s₁ ∩ s₂) ⊆ omegaLimit f ϕ s₁ ∩ omegaLimit f ϕ s₂ | null | true |
Valuation.HasExtension.instIsLocalHomSubtypeMemValuationSubringValuationSubringRingHomAlgebraMap | Mathlib.RingTheory.Valuation.Extension | ∀ {K : outParam (Type u_5)} {L : outParam (Type u_6)} {Γ₀ : outParam (Type u_7)} {Γ₁ : outParam (Type u_8)}
[inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [inst_3 : LinearOrderedCommGroupWithZero Γ₀]
[inst_4 : LinearOrderedCommGroupWithZero Γ₁] (vK : Valuation K Γ₀) (vL : Valuation L Γ₁)
[inst_5 : vK.... | null | true |
CategoryTheory.StructuredArrow.map₂Congr_inv_app_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Fun... | null | true |
Complex.cos_int_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℤ), Complex.cos (↑n * (2 * ↑Real.pi)) = 1 | null | true |
CategoryTheory.typesCartesianMonoidalCategory._proof_4 | Mathlib.CategoryTheory.Monoidal.Types.Basic | ∀ (X Y : Type u_1),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | false |
_private.Mathlib.Algebra.Polynomial.Roots.0.Polynomial.eq_zero_of_forall_eval_zero_of_natDegree_lt_card._simp_1_1 | Mathlib.Algebra.Polynomial.Roots | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) | null | false |
Std.Time.instHAddOffsetOffset_6 | Std.Time.Date.Basic | HAdd Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset | null | true |
AlgebraicGeometry.Scheme.Hom.appIso_inv_app_apply | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
(x : ↑(X.presheaf.obj (Opposite.op U))),
(CategoryTheory.ConcreteCategory.hom
(AlgebraicGeometry.Scheme.Hom.app f ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U)))
((CategoryTheory.ConcreteCate... | null | true |
CategoryTheory.functorCategoryPreadditive._proof_13 | Mathlib.CategoryTheory.Preadditive.FunctorCategory | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.Preadditive D]
(F G : CategoryTheory.Functor C D) (x : F ⟶ G), -x + x = 0 | null | false |
Std.IterM.mapWithPostcondition.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Monad n] [inst_1 : MonadLiftT m n]
[inst_2 : Std.Iterator α m β] (f : β → Std.Iterators.PostconditionT n γ) (it : Std.IterM m β),
Std.IterM.mapWithPostcondition f it = Std.IterM.InternalCombinators.map (fun {x} => monadLift) f it | null | true |
equivShrink_symm_bot | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Bot α], (equivShrink α).symm ⊥ = ⊥ | null | true |
Std.DTreeMap.Internal.Unit.RcoSliceData.noConfusionType | Std.Data.DTreeMap.Internal.Zipper | Sort u_1 →
{α : Type u} →
[inst : Ord α] →
Std.DTreeMap.Internal.Unit.RcoSliceData α →
{α' : Type u} → [inst' : Ord α'] → Std.DTreeMap.Internal.Unit.RcoSliceData α' → Sort u_1 | null | false |
MeasureTheory.Measure.ae_measure_lt_top | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [hν : MeasureTheory.SFinite ν] {s : Set (α × β)},
MeasurableSet s → (μ.prod ν) s ≠ ⊤ → ∀ᵐ (x : α) ∂μ, ν (Prod.mk x ⁻¹' s) < ⊤ | null | true |
Function.isPeriodicPt_prodMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β} {n : ℕ} (x : α × β),
Function.IsPeriodicPt (Prod.map f g) n x ↔ Function.IsPeriodicPt f n x.1 ∧ Function.IsPeriodicPt g n x.2 | null | true |
Algebra.traceForm_apply | Mathlib.RingTheory.Trace.Defs | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x y : S),
((Algebra.traceForm R S) x) y = (Algebra.trace R S) (x * y) | null | true |
Lean.Server.moduleFromDocumentUri | Lean.Server.Utils | Lean.Lsp.DocumentUri → IO Lean.Name | Finds the module name corresponding to `uri` in `srcSearchPath`. | true |
Std.DTreeMap.Internal.Impl.mem_alter!_self._simp_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(k ∈ Std.DTreeMap.Internal.Impl.alter! k f t) = ((f (t.get? k)).isSome = true) | null | false |
Lean.Elab.Term.SyntheticMVarDecl.mk | Lean.Elab.Term.TermElabM | Lean.Syntax → Lean.Elab.Term.SyntheticMVarKind → Lean.Elab.Term.SyntheticMVarDecl | null | true |
CategoryTheory.Monad.Algebra.Hom.recOn | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
{A B : T.Algebra} →
{motive : A.Hom B → Sort u} →
(t : A.Hom B) →
((f : A.A ⟶ B.A) →
(h : CategoryTheory.CategoryStruct.comp (T.map f) B.a = CategoryTheory.CategoryStruc... | null | false |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.evalCLM._simp_2 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.