name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
Ideal.instIsTwoSided | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : CommSemiring α] (I : Ideal α), I.IsTwoSided | true |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.Fin.succ.match_1.splitter | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | {n : ℕ} → (motive : Fin n → Sort u_1) → (x : Fin n) → ((i : ℕ) → (h : i < n) → motive ⟨i, h⟩) → motive x | true |
CategoryTheory.Quiv.lift_map | Mathlib.CategoryTheory.Category.Quiv | ∀ {V : Type u} [inst : Quiver V] {C : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} C] (F : V ⥤q C)
{X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
(CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f) | true |
_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor.match_9 | Mathlib.Tactic.Use | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) → ((ctor : Lean.Name) → motive [ctor]) → ((x : List Lean.Name) → motive x) → motive x | false |
Lean.Doc.Data.ConvTactic.casesOn | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.Data.ConvTactic → Sort u} →
(t : Lean.Doc.Data.ConvTactic) → ((name : Lean.Name) → motive { name := name }) → motive t | false |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.maxKey! = t₂.maxKey! | true |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (n₁ n₂ n₁₂ : ℤ)
(h : n₁ + n₂ = n₁₂) (K : CochainComplex C ℤ) (x x_1 : ℤ),
CategoryTheory.CategoryStruct.comp ((fun i => K.shiftFunctorObjXIso n₁₂ i (i + n₂ + n₁) ⋯) x).hom
((((CochainComplex.shiftFunctor C n... | false |
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {G : Type u_1} [inst : AddCommGroup G] {n : ℕ} [NeZero n] {ι : Type u_2} (b : Module.Basis ι ℤ G)
(hker :
((LinearMap.lsmul ℤ G) ↑n).range ≤
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr).ker),
Function.Injective
⇑(AddMonoidHom.toZModLinearMap n
(((Linea... | false |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x - x₀)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b < 0 | true |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] (u u_1 : ι → Ω → β),
u = u_1 →
∀ (τ τ_1 : Ω → WithTop ι),
τ = τ_1 → ∀ (a a_1 : Ω), a = a_1 → MeasureTheory.stoppedValue u τ a = MeasureTheory.stoppedValue u_1 τ_1 a_1 | true |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ns : Array (Lean.TSyntax `ident)) → motive (some ns)) → (Unit → motive none) → motive x | false |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Walks.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), (p.takeUntil w hw).takeUntil x hx = p.takeUntil x ⋯ | true |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M], Module.rank R M = ↑(Module.finrank R M) | false |
EIO.adapt_pure | Batteries.Lean.LawfulMonadLift | ∀ {ε₁ ε₂ α : Type} (f : ε₁ → ε₂) (a : α), EIO.adapt f (pure a) = pure a | true |
CategoryTheory.Functor.leibnizPushout_obj_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [inst_3 : CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryThe... | true |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | ∀ (R : Type uR) [inst : Ring R] [Small.{uM, uR} R] (M : Type uM) [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inj : Module.Injective R M] (P : Type uP) [inst_4 : AddCommGroup P] [inst_5 : Module R P] (P' : Type uP')
[inst_6 : AddCommGroup P'] [inst_7 : Module R P'] (f : P →ₗ[R] P'),
Function.Injective ⇑f → ∀ ... | true |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ}, ↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n] | true |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r a b → RingQuot.Rel r (a - c) (b - c) | true |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : List α),
Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l | true |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} {A B : Set α}, A ⊆ B → (g '' (f '' A)ᶜ)ᶜ ⊆ (g '' (f '' B)ᶜ)ᶜ | false |
Ring.ordMonoidWithZeroHom._proof_5 | Mathlib.RingTheory.OrderOfVanishing | ∀ (R : Type u_1) [inst : CommRing R] (x y : R),
(if x * y ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R (x * y))
else 0) =
(if x ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring... | false |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | {motive : DyckWord → Sort u} →
((toList : List DyckStep) →
(count_U_eq_count_D : List.count DyckStep.U toList = List.count DyckStep.D toList) →
(count_D_le_count_U :
∀ (i : ℕ), List.count DyckStep.D (List.take i toList) ≤ List.count DyckStep.U (List.take i toList)) →
motive
... | false |
SetLike.ext_iff | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q | true |
GromovHausdorff.repGHSpaceMetricSpace._aux_6 | Mathlib.Topology.MetricSpace.GromovHausdorff | {p : GromovHausdorff.GHSpace} → p.Rep → p.Rep → ENNReal | false |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | false |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x : ZFSet.{u}), (∅ ⊆ x) = True | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 = ↑lo → ↑lo + 1 ≤ as.size | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) | false |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : 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 | false |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] (F : CategoryTheory.Functor C AddCommGrpCat)
[inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F] (X : C),
CategoryTheory.CategoryStruct.comp CategoryTh... | false |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} →
[inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → AddCommSemigroup (UpperSet α) | true |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | false |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.inter m₂).getD k fallback = if m₂.contains k = true then m₁.getD k fallback else fallback | true |
CategoryTheory.Limits.coneOfIsSplitMono_π_app | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.IsSplitMono f]
(X_1 : CategoryTheory.Limits.WalkingParallelPair),
(CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
X_1 = t →
... | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (Φ : CategoryTheory.SmallObject.SuccStruct C)
(J : Type u_3) [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] (x x_1 : J) (f : x ⟶ x_1),
CategoryT... | false |
CategoryTheory.Limits.IsColimit.ofCoconeUncurry._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | false |
_private.Mathlib.Data.Seq.Computation.0.Computation.BisimO.match_1.splitter._sparseCasesOn_5 | Mathlib.Data.Seq.Computation | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Functor.mapProjectiveResolution._proof_4 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.Limits.HasZeroObject D] [inst_5 : CategoryTheory.Preadditive D]
[inst_6 : ... | false |
Plausible.Random.randBool | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {g : Type} → [RandomGen g] → Plausible.RandGT g m Bool | true |
Finsupp.mapRange.addEquiv_toEquiv | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (e : M ≃+ N),
↑(Finsupp.mapRange.addEquiv e) = Finsupp.mapRange.equiv ↑e ⋯ | true |
Projectivization.Subspace.mem_submodule_iff | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s : Projectivization.Subspace K V) {v : V} (hv : v ≠ 0),
v ∈ Projectivization.Subspace.submodule s ↔ Projectivization.mk K v hv ∈ s | true |
_private.Batteries.Data.Array.Scan.0.Array.take_scanl._proof_1_3 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {f : β → α → β} (init : β) (as : Array α),
-1 * ↑as.size + 1 ≤ 0 →
i + 1 = (Array.scanl f init as).size - 1 →
i = as.size - 1 →
∀ (w : ℕ),
w + 1 ≤ ((Array.scanl f init as).extract 0 (i + 1)).size → w < (Array.scanl f init (as.extract 0 i)).size | false |
CategoryTheory.Functor.lanCompColimIso._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
[CategoryTheory.Limit... | false |
Finset.singletonAddHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : Add α] → α →ₙ+ Finset α | true |
Lean.IR.CollectUsedDecls.State.order._default | Lean.Compiler.IR.EmitUtil | Array Lean.Name | false |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_whiskerLeft_δ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
CategoryTheor... | true |
CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful | true |
PiNat.self_mem_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ), x ∈ PiNat.cylinder x n | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_inter!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
NonarchAddGroupSeminorm.coe_lt_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupSeminorm E}, ⇑p < ⇑q ↔ p < q | true |
Submodule.map | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
... | true |
concaveOn_univ_piecewise_Iic_of_monotoneOn_Iic_antitoneOn_Ici | Mathlib.Analysis.Convex.Piecewise | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : Module 𝕜 E] [PosSMulMono 𝕜 E] [inst_7 : AddCommGroup β]
[inst_8 : PartialOrder β] [IsOrderedAddMonoid β] [inst_10 : Module 𝕜 β] [Pos... | true |
CategoryTheory.Discrete.sumEquiv.match_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} →
(motive : J ⊕ K → Sort u_3) →
(t : J ⊕ K) → ((j : J) → motive (Sum.inl j)) → ((k : K) → motive (Sum.inr k)) → motive t | false |
_private.Mathlib.Data.Set.Accumulate.0.Set.iUnion_accumulate._simp_1_1 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
TopologicalSpace.ext_isClosed | Mathlib.Topology.Basic | ∀ {X : Type u_2} {t₁ t₂ : TopologicalSpace X}, (∀ (s : Set X), IsClosed s ↔ IsClosed s) → t₁ = t₂ | true |
CategoryTheory.Subfunctor.Subpresheaf.equalizer.ι | Mathlib.CategoryTheory.Subfunctor.Equalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F₁ F₂ : CategoryTheory.Functor C (Type w)} →
{A : CategoryTheory.Subfunctor F₁} →
(f g : A.toFunctor ⟶ F₂) → (CategoryTheory.Subfunctor.equalizer f g).toFunctor ⟶ A.toFunctor | true |
unitary.joined | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)), ‖↑v - ↑u‖ < 2 → Joined u v | true |
nonneg_of_mul_nonneg_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [PosMulStrictMono R], 0 ≤ a * b → 0 < a → 0 ≤ b | true |
initFn._@.Mathlib.Tactic.Attr.Register.1131139975._hygCtx._hyg.5 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.SimpExtension | false |
CategoryTheory.Functor.LaxMonoidal.comp._proof_1 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | false |
instAssociativeInt8HAdd | Init.Data.SInt.Lemmas | Std.Associative fun x1 x2 => x1 + x2 | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___macroRules_CategoryTheory_rfl_cat_1 | Mathlib.CategoryTheory.Category.Basic | Lean.Macro | false |
Finsupp.coe_smul._simp_1 | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
b • ⇑v = ⇑(b • v) | false |
SSet.Subcomplex.Pairing.II | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | true |
Mathlib.Tactic.Order.AtomicFact.isTop.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (idx : ℕ), sizeOf (Mathlib.Tactic.Order.AtomicFact.isTop idx) = 1 + sizeOf idx | true |
Std.TreeMap.Raw.instForMProdOfMonad | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} → {m : Type w → Type w₂} → [Monad m] → ForM m (Std.TreeMap.Raw α β cmp) (α × β) | true |
Std.TreeMap.le_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.minKey!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | true |
IsChain.succ | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain r (SuccChain r s) | true |
IsLocalDiffeomorphAt.localInverse_contMDiffOn | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_4}
[inst_5 : TopologicalSpace H] {G : Type u_5} [inst_6 : TopologicalSpace G] {I : ModelWithCorners ... | true |
fderivWithin_continuousAlternatingMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousAlternatingMap | ∀ {𝕜 : 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 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G]
[inst... | true |
Filter.tendsto_principal_principal | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β},
Filter.Tendsto f (Filter.principal s) (Filter.principal t) ↔ ∀ a ∈ s, f a ∈ t | true |
Std.TreeSet.casesOn | Std.Data.TreeSet.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.TreeSet α cmp → Sort u_1} →
(t : Std.TreeSet α cmp) → ((inner : Std.TreeMap α Unit cmp) → motive { inner := inner }) → motive t | false |
PointedCone.coe_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] (K : PointedCone 𝕜 E), ↑K.closure = closure ↑K | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticAdmit_1 | Init.Tactics | Lean.Macro | false |
NonUnitalStarAlgebra.adjoin_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (s : Set A),
(NonUnitalStarAlgebra.adjoin R s).toNonUnitalSubalgebra = NonUni... | true |
Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α], Std.Associative max | true |
CategoryTheory.endofunctorMonoidalCategory_whiskerLeft_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {F H K : CategoryTheory.Functor C C} {β : H ⟶ K} (X : C),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft F β).app X = β.app (F.obj X) | true |
Set.Ico_diff_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a b \ Set.Iio c = Set.Ico (max a c) b | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {i j : ι} [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M], P.IsOrthogonal i j = (P.pairing i j = 0) | false |
FractionalIdeal.coeIdeal | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_1} →
[inst : CommRing R] →
{S : Submonoid R} → {P : Type u_2} → [inst_1 : CommRing P] → [inst_2 : Algebra R P] → Ideal R → FractionalIdeal S P | true |
hasProd_prod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} [ContinuousMul α] {f : γ → β → α} {a : γ → α} {s : Finset γ},
(∀ i ∈ s, HasProd (f i) (a i) L) → HasProd (fun b => ∏ i ∈ s, f i b) (∏ i ∈ s, a i) L | true |
ProbabilityTheory.Kernel.sectR._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_2} {β : Type u_1} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (a : α),
Measurable fun a_1 => (a, a_1) | false |
Nat.Coprime.mul_gcd | Init.Data.Nat.Coprime | ∀ {m n : ℕ}, m.Coprime n → ∀ (k : ℕ), (m * n).gcd k = m.gcd k * n.gcd k | true |
CategoryTheory.MorphismProperty.RespectsLeft.rec | Mathlib.CategoryTheory.MorphismProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.RespectsLeft Q → Sort u_1} →
((precomp : ∀ {X Y Z : C} (i : X ⟶ Y), Q i → ∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
motive ⋯) →
(t :... | false |
Lean.Meta.Grind.CanonArgKey.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (f : Lean.Expr) (i : ℕ) (arg f_1 : Lean.Expr) (i_1 : ℕ) (arg_1 : Lean.Expr),
({ f := f, i := i, arg := arg } = { f := f_1, i := i_1, arg := arg_1 }) = (f = f_1 ∧ i = i_1 ∧ arg = arg_1) | true |
Matrix.isUnit_conjTranspose._simp_1 | Mathlib.Data.Matrix.Invertible | ∀ {n : Type u_2} {α : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring α] [inst_3 : StarRing α]
(A : Matrix n n α), IsUnit A.conjTranspose = IsUnit A | false |
AddMonoidAlgebra.mapAlgEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_3) {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], AlgHomClass (B ≃ₐ[R] A) R B A | false |
Std.DTreeMap.Internal.Impl.minKey!_erase_eq_of_not_compare_minKey!_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α] (h : t.WF) {k : α},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty = false →
¬compare k t.minKey! = Ordering.eq → (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey! = t.minKey! | true |
UInt8.toUInt64_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a ^^^ b).toUInt64 = a.toUInt64 ^^^ b.toUInt64 | true |
_private.Init.Grind.Ordered.Int.0.Lean.Grind.instOrderedRingInt._proof_1 | Init.Grind.Ordered.Int | ¬0 < 1 → False | false |
LinearIndepOn.notMem_span_iff | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{s : Set ι} {a : ι} {f : ι → V},
LinearIndepOn K f s → (f a ∉ Submodule.span K (f '' s) ↔ LinearIndepOn K f (insert a s) ∧ a ∉ s) | true |
AddCon.coe_inf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, ⇑c ⊓ ⇑d = ⇑(c ⊓ d) | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ) (hr : r₀ ≤ r),
(c r).Rel pq pq' → data.i₀ r pq ⋯ = data.i₂ pq' | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRevM.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRevM f init b =
Array.foldrM (fun l acc => Std.DHashMap.Internal.AssocList.foldrM (fun a b d => f d a b) acc l) init b.buckets | true |
CategoryTheory.Triangulated.AbelianSubcategory.isLimitKernelFork._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_4} {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Traversal.0.SimpleGraph.Walk.lastDart_eq_getLast_darts._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, ¬p.Nil → p.darts.length - 1 < p.darts.length | false |
Lean.Meta.Grind.GoalState.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{nextDeclIdx : ℕ} →
{canon : Lean.Meta.Grind.Canon.State} →
{enodeMap : Lean.Meta.Grind.ENodeMap} →
{exprs : Lean.PArray Lean.Expr} →
{parents : Lean.Meta.Grind.ParentMap} →
{congrTable : Lean.Meta.Grind.CongrTable enodeMap} →
{appMap : Lean.PHashMa... | false |
continuousMultilinearCurryFin0._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G : Type u_2) (G' : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G']
(x x_1 : ContinuousMultilinearMap 𝕜 (fun i => G) G'), (x + x_1).curry0 = (x + x_1).curry0 | false |
WithZero.instRepr | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → [Repr α] → Repr (WithZero α) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.