name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.pushout.instIsSplitMonoInl | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f], CategoryTheory.IsSplitMono (CategoryTheory.Limits.pushout.inl f f) | true |
Order.Ideal.sup_mem | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : SemilatticeSup P] {x y : P} {s : Order.Ideal P}, x ∈ s → y ∈ s → x ⊔ y ∈ s | true |
mem_algebraicClosure_iff | Mathlib.FieldTheory.AlgebraicClosure | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
x ∈ algebraicClosure F E ↔ IsAlgebraic F x | true |
ModuleCat.injectiveDimension_le_injectiveDimension_of_isLocalizedModule | Mathlib.RingTheory.LocalProperties.InjectiveDimension | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] [IsNoetherianRing R] (S : Submonoid R) (M : ModuleCat R),
CategoryTheory.injectiveDimension (M.localizedModule S) ≤ CategoryTheory.injectiveDimension M | true |
Finset.expect_neg_distrib | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddCommGroup M] [inst_1 : Module ℚ≥0 M] (s : Finset ι) (f : ι → M),
(s.expect fun i => -f i) = -s.expect fun i => f i | true |
_private.Mathlib.Data.Set.NAry.0.Set.Nonempty.image2.match_1_1 | Mathlib.Data.Set.NAry | ∀ {β : Type u_1} {t : Set β} (motive : t.Nonempty → Prop) (x : t.Nonempty),
(∀ (w : β) (hb : w ∈ t), motive ⋯) → motive x | false |
Lean.Compiler.LCNF.ToLCNF.State.shouldCache | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.ToLCNF.State → Bool | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_union._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Finset.val_toFinset | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), s.val.toFinset = s | true |
CategoryTheory.Functor.inr_biprodComparison' | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_4 : CategoryTheory.Limits.HasBinaryBiproduct X Y]
[inst_5 : CategoryTheory.Limits.HasBinaryBiproduct (F.obj X) (F.obj Y)],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr (F.biprodComparison' X Y) =
F.map CategoryTheory.Limits.biprod.inr | true |
WithTop.instSemiring._proof_3 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : Semiring α], ↑0 = 0 | false |
HomologicalComplex.truncLE'ToRestriction._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsTruncLE],
e.op.IsRelIff | false |
WithLp.toLp.noConfusion | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} →
{V : Type u_1} → {P : Sort u} → {ofLp ofLp' : V} → WithLp.toLp p ofLp = WithLp.toLp p ofLp' → (ofLp ≍ ofLp' → P) → P | false |
Lean.Meta.Grind.NewRawFact.generation | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.NewRawFact → ℕ | true |
_private.Lean.Meta.Basic.0.Lean.initFn._@.Lean.Meta.Basic.2682336532._hygCtx._hyg.2 | Lean.Meta.Basic | IO Unit | false |
CategoryTheory.Localization.homEquiv_comp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
(W : CategoryTheory.MorphismProperty C) (L₁ : CategoryTheory.Functor C D₁) [inst_3 : L₁.IsLocalization W]
(L₂ : CategoryTheory.Functor C D₂) [inst_4 : L₂.IsLocalization W] {X Y Z : C} (f : L₁.obj X ⟶ L₁.obj Y)
(g : L₁.obj Y ⟶ L₁.obj Z),
(CategoryTheory.Localization.homEquiv W L₁ L₂) (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Localization.homEquiv W L₁ L₂) f)
((CategoryTheory.Localization.homEquiv W L₁ L₂) g) | true |
normalizedGCDMonoidOfGCD._proof_4 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (gcd : α → α → α),
(∀ (a b : α), gcd a b ∣ a) → ∀ (a b : α), gcd a b ∣ normalize (a * b) | false |
Subalgebra.centralizer_le | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s t : Set A),
s ⊆ t → Subalgebra.centralizer R t ≤ Subalgebra.centralizer R s | true |
Subgroup.fintypeQuotientOfFiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → {H : Subgroup G} → [H.FiniteIndex] → Fintype (G ⧸ H) | true |
instMonadBaseIO._aux_1 | Init.System.IO | {α β : Type} → (α → β) → BaseIO α → BaseIO β | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_alter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Int32.toInt_sub_of_le | Init.Data.SInt.Lemmas | ∀ (a b : Int32), 0 ≤ b → b ≤ a → (a - b).toInt = a.toInt - b.toInt | true |
NumberField.InfinitePlace.even_finrank_of_not_isUnramified | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
{w : NumberField.InfinitePlace K} [IsGalois k K],
¬NumberField.InfinitePlace.IsUnramified k w → Even (Module.finrank k K) | true |
_private.Mathlib.Data.PEquiv.0.PEquiv.trans_eq_none._simp_1_1 | Mathlib.Data.PEquiv | ∀ {α : Type u_1} {o : Option α}, (o = none) = ∀ (a : α), a ∉ o | false |
IsCoveringMap.monodromy._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {p : E → X} {x y : X} (e : ↑(p ⁻¹' {x})) (γ : Path x y),
γ 0 = p ↑e | false |
CategoryTheory.Endofunctor.Adjunction.AlgCoalgEquiv.unitIso_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(X : CategoryTheory.Endofunctor.Algebra F),
((CategoryTheory.Endofunctor.Adjunction.AlgCoalgEquiv.unitIso adj).inv.app X).f = CategoryTheory.CategoryStruct.id X.a | true |
NNRat.nndist_eq | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist p q = nndist ↑p ↑q | true |
_private.Batteries.Data.List.Count.0.List.idxToSigmaCount_sigmaCountToIdx._proof_1_20 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] {xs : List α} {xc : (x : α) × Fin (List.count x xs)},
↑xc.snd + 1 ≤ (List.filter (fun x => x == xc.fst) xs).length →
↑xc.snd < (List.filter (fun x => x == xc.fst) xs).length | false |
CharacterModule.eq_zero_of_ofSpanSingleton_apply_self | Mathlib.Algebra.Module.CharacterModule | ∀ {A : Type uA} [inst : AddCommGroup A] (a : A), (CharacterModule.ofSpanSingleton a) ⟨a, ⋯⟩ = 0 → a = 0 | true |
BoundedContinuousFunction.instAddMonoid | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddMonoid R] → [BoundedAdd R] → [ContinuousAdd R] → AddMonoid (BoundedContinuousFunction α R) | true |
_private.Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic.0.Path.Homotopic.Quotient.refl_trans._simp_1_2 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] (x : X),
Path.Homotopic.Quotient.refl x = Path.Homotopic.Quotient.mk (Path.refl x) | false |
Aesop.GlobalRuleSetMember.base.noConfusion | Aesop.RuleSet.Member | {P : Sort u} →
{m m' : Aesop.BaseRuleSetMember} →
Aesop.GlobalRuleSetMember.base m = Aesop.GlobalRuleSetMember.base m' → (m = m' → P) → P | false |
CategoryTheory.Join.isoMkFunctor._proof_2 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] {E : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} E]
(F : CategoryTheory.Functor (CategoryTheory.Join C D) E),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight (CategoryTheory.Join.edgeTransform C D) F)
((CategoryTheory.Prod.snd C D).isoWhiskerLeft
(CategoryTheory.Join.mkFunctorRight ((CategoryTheory.Join.inclLeft C D).comp F)
((CategoryTheory.Join.inclRight C D).comp F)
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Join.edgeTransform C D) F)).symm).hom =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Prod.fst C D).isoWhiskerLeft
(CategoryTheory.Join.mkFunctorLeft ((CategoryTheory.Join.inclLeft C D).comp F)
((CategoryTheory.Join.inclRight C D).comp F)
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Join.edgeTransform C D) F)).symm).hom
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Join.edgeTransform C D)
(CategoryTheory.Join.mkFunctor ((CategoryTheory.Join.inclLeft C D).comp F)
((CategoryTheory.Join.inclRight C D).comp F)
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Join.edgeTransform C D) F))) | false |
CategoryTheory.IsUniversalColimit.isPullback_of_isColimit_left | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_3} {S B : C} {X : ι → C}
{a : CategoryTheory.Limits.Cofan X},
CategoryTheory.IsUniversalColimit a →
∀ (f : (i : ι) → X i ⟶ S) (u : a.pt ⟶ S) (v : B ⟶ S) {P : ι → C} (q₁ : (i : ι) → P i ⟶ B)
(q₂ : (i : ι) → P i ⟶ X i),
(∀ (i : ι), CategoryTheory.IsPullback (q₁ i) (q₂ i) v (f i)) →
∀ {d : CategoryTheory.Limits.Cofan P} (hd : CategoryTheory.Limits.IsColimit d),
autoParam (∀ (i : ι), CategoryTheory.CategoryStruct.comp (a.inj i) u = f i)
CategoryTheory.IsUniversalColimit.isPullback_of_isColimit_left._auto_1 →
∀ [CategoryTheory.Limits.HasPullback v u],
CategoryTheory.IsPullback (CategoryTheory.Limits.Cofan.IsColimit.desc hd q₁)
(CategoryTheory.Limits.Cofan.IsColimit.desc hd fun x =>
CategoryTheory.CategoryStruct.comp (q₂ x) (a.inj x))
v u | true |
AlgebraicGeometry.IsAffineOpen.fromSpec_preimage_basicOpen' | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U)
(f : ↑(X.presheaf.obj (Opposite.op U))),
(TopologicalSpace.Opens.map hU.fromSpec.base).obj (X.basicOpen f) =
(AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U))).basicOpen
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.ΓSpecIso (X.presheaf.obj (Opposite.op U))).inv) f) | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.evalZSMul._proof_5 | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)} (sα : Q(CommSemiring «$α»)) (rα : Q(CommRing «$α»)), «$sα» =Q CommRing.toCommSemiring | false |
Vector.unzip_snd | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {xs : Vector (α × β) n}, xs.unzip.2 = Vector.map Prod.snd xs | true |
_private.Mathlib.Analysis.Normed.Group.SemiNormedGrp.0.SemiNormedGrp.Hom.ext.match_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (motive : M.Hom N → Prop) (h : M.Hom N),
(∀ (hom' : NormedAddGroupHom M.carrier N.carrier), motive { hom' := hom' }) → motive h | false |
_private.Mathlib.RingTheory.WittVector.Basic.0.Int.castDef.match_1.splitter | Mathlib.RingTheory.WittVector.Basic | (motive : ℤ → Sort u_1) → (x : ℤ) → ((n : ℕ) → motive (Int.ofNat n)) → ((n : ℕ) → motive (Int.negSucc n)) → motive x | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 | Mathlib.CategoryTheory.Sites.Monoidal | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u_4) →
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] →
[inst_2 : CategoryTheory.MonoidalCategory A] →
[inst_3 : J.W.IsMonoidal] →
[inst_4 : CategoryTheory.HasWeakSheafify J A] →
(X Y : CategoryTheory.Functor Cᵒᵖ A) →
CategoryTheory.MonoidalCategoryStruct.tensorObj ((CategoryTheory.presheafToSheaf J A).obj X)
((CategoryTheory.presheafToSheaf J A).obj Y) ⟶
(CategoryTheory.presheafToSheaf J A).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | false |
MeasureTheory.ComplexMeasure.equivSignedMeasure._proof_1 | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (x : MeasureTheory.SignedMeasure α × MeasureTheory.SignedMeasure α),
(MeasureTheory.ComplexMeasure.re
(match x with
| (s, t) => s.toComplexMeasure t),
MeasureTheory.ComplexMeasure.im
(match x with
| (s, t) => s.toComplexMeasure t)) =
x | false |
TypeVec.append1Cases | Mathlib.Data.TypeVec | {n : ℕ} →
{C : TypeVec.{u_1} (n + 1) → Sort u} →
((α : TypeVec.{u_1} n) → (β : Type u_1) → C (α ::: β)) → (γ : TypeVec.{u_1} (n + 1)) → C γ | true |
Polynomial.splits_of_splits_of_dvd | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f g : Polynomial R} [IsDomain R], g.Splits → g ≠ 0 → f ∣ g → f.Splits | true |
CStarAlgebra.norm_le_norm_of_nonneg_of_le._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
Filter.NeBot.nonneg_sub | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : AddGroup α] {f : Filter α}, f.NeBot → 0 ≤ f - f | true |
Lean.Doc.initFn._@.Lean.Elab.DocString.1381276721._hygCtx._hyg.2 | Lean.Elab.DocString | IO (Lean.SimpleScopedEnvExtension (Lean.Name × Lean.Name) (Lean.NameMap (Array Lean.Name))) | false |
Lean.resolveGlobalConst | Lean.ResolveName | {m : Type → Type} →
[Monad m] →
[Lean.MonadResolveName m] →
[Lean.MonadEnv m] →
[Lean.MonadOptions m] →
[Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadError m] → Lean.Syntax → m (List Lean.Name) | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order.0.CStarAlgebra.norm_le_norm_of_nonneg_of_le._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
gcd_one_right | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a 1 = 1 | true |
Aesop.Script.Tactic._sizeOf_1 | Aesop.Script.Tactic | Aesop.Script.Tactic → ℕ | false |
CategoryTheory.MonoidalCategoryStruct.associator | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z ≅
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z) | true |
_private.Lean.Data.RBMap.0.Lean.RBNode.appendTrees.match_1.splitter | Lean.Data.RBMap | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Lean.RBNode α β → Lean.RBNode α β → Sort u_3) →
(x x_1 : Lean.RBNode α β) →
((x : Lean.RBNode α β) → motive Lean.RBNode.leaf x) →
((x : Lean.RBNode α β) → (x = Lean.RBNode.leaf → False) → motive x Lean.RBNode.leaf) →
((a : Lean.RBNode α β) →
(kx : α) →
(vx : β kx) →
(b c : Lean.RBNode α β) →
(ky : α) →
(vy : β ky) →
(d : Lean.RBNode α β) →
motive (Lean.RBNode.node Lean.RBColor.red a kx vx b)
(Lean.RBNode.node Lean.RBColor.red c ky vy d)) →
((a : Lean.RBNode α β) →
(kx : α) →
(vx : β kx) →
(b c : Lean.RBNode α β) →
(ky : α) →
(vy : β ky) →
(d : Lean.RBNode α β) →
motive (Lean.RBNode.node Lean.RBColor.black a kx vx b)
(Lean.RBNode.node Lean.RBColor.black c ky vy d)) →
((a b : Lean.RBNode α β) →
(kx : α) →
(vx : β kx) →
(c : Lean.RBNode α β) →
(a = Lean.RBNode.leaf → False) →
(∀ (a_1 : Lean.RBNode α β) (kx : α) (vx : β kx) (b : Lean.RBNode α β),
a = Lean.RBNode.node Lean.RBColor.red a_1 kx vx b → False) →
motive a (Lean.RBNode.node Lean.RBColor.red b kx vx c)) →
((a : Lean.RBNode α β) →
(kx : α) →
(vx : β kx) →
(b c : Lean.RBNode α β) →
(c = Lean.RBNode.leaf → False) →
(∀ (c_1 : Lean.RBNode α β) (ky : α) (vy : β ky) (d : Lean.RBNode α β),
c = Lean.RBNode.node Lean.RBColor.red c_1 ky vy d → False) →
motive (Lean.RBNode.node Lean.RBColor.red a kx vx b) c) →
motive x x_1 | true |
SimpleGraph.cycleGraph.bicoloring_of_even | Mathlib.Combinatorics.SimpleGraph.ConcreteColorings | (n : ℕ) → Even n → (SimpleGraph.cycleGraph n).Coloring Bool | true |
Multiset.powersetAux' | Mathlib.Data.Multiset.Powerset | {α : Type u_1} → List α → List (Multiset α) | true |
Lean.Elab.Tactic.RCases.RCasesPatt.typed.sizeOf_spec | Lean.Elab.Tactic.RCases | ∀ (ref : Lean.Syntax) (a : Lean.Elab.Tactic.RCases.RCasesPatt) (a_1 : Lean.Term),
sizeOf (Lean.Elab.Tactic.RCases.RCasesPatt.typed ref a a_1) = 1 + sizeOf ref + sizeOf a + sizeOf a_1 | true |
Lean.Elab.FixedParams.Info.casesOn | Lean.Elab.PreDefinition.FixedParams | {motive : Lean.Elab.FixedParams.Info → Sort u} →
(t : Lean.Elab.FixedParams.Info) →
((graph : Array (Array (Option (Array (Option ℕ))))) →
(revDeps : Array (Array (Array ℕ))) → motive { graph := graph, revDeps := revDeps }) →
motive t | false |
Lean.Lsp.instBEqInsertReplaceEdit | Lean.Data.Lsp.LanguageFeatures | BEq Lean.Lsp.InsertReplaceEdit | true |
TwoP.swapEquiv | Mathlib.CategoryTheory.Category.TwoP | TwoP ≌ TwoP | true |
summable_congr | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α}
{L : SummationFilter β}, (∀ (b : β), f b = g b) → (Summable f L ↔ Summable g L) | true |
_private.Mathlib.Topology.Compactness.Paracompact.0.refinement_of_locallyCompact_sigmaCompact_of_nhds_basis.match_1_1 | Mathlib.Topology.Compactness.Paracompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : X → Type u_2} {p : (x : X) → ι x → Prop} {B : (x : X) → ι x → Set X}
(motive :
(∃ α c r,
(∀ (a : α), c a ∈ Set.univ ∧ p (c a) (r a)) ∧
Set.univ ⊆ ⋃ a, B (c a) (r a) ∧ LocallyFinite fun a => B (c a) (r a)) →
Prop)
(x :
∃ α c r,
(∀ (a : α), c a ∈ Set.univ ∧ p (c a) (r a)) ∧
Set.univ ⊆ ⋃ a, B (c a) (r a) ∧ LocallyFinite fun a => B (c a) (r a)),
(∀ (α : Type u_1) (c : α → X) (r : (a : α) → ι (c a)) (hp : ∀ (a : α), c a ∈ Set.univ ∧ p (c a) (r a))
(hU : Set.univ ⊆ ⋃ a, B (c a) (r a)) (hfin : LocallyFinite fun a => B (c a) (r a)), motive ⋯) →
motive x | false |
_private.Mathlib.Data.Stream.Init.0.Stream'.getElem?_take._simp_1_3 | Mathlib.Data.Stream.Init | ∀ (n : ℕ), (0 < n.succ) = True | false |
PrimeSpectrum.BasicConstructibleSetData.mk.inj | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {f : R} {n : ℕ} {g : Fin n → R} {f_1 : R} {n_1 : ℕ} {g_1 : Fin n_1 → R},
{ f := f, n := n, g := g } = { f := f_1, n := n_1, g := g_1 } → f = f_1 ∧ n = n_1 ∧ g ≍ g_1 | true |
CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃))
{X_1 Y Z : F.DescentData' sq sq₃} (f_1 : X_1 ⟶ Y) (g : Y ⟶ Z),
{ hom := (CategoryTheory.CategoryStruct.comp f_1 g).hom, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := f_1.hom, comm := ⋯ } { hom := g.hom, comm := ⋯ } | false |
Fin2.rev | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 n → Fin2 n | true |
RingPreordering.mk.sizeOf_spec | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : SizeOf R] (toSubsemiring : Subsemiring R)
(mem_of_isSquare' :
autoParam (∀ {x : R}, IsSquare x → x ∈ toSubsemiring.carrier) RingPreordering.mem_of_isSquare'._autoParam)
(neg_one_notMem' : autoParam (-1 ∉ toSubsemiring.carrier) RingPreordering.neg_one_notMem'._autoParam),
sizeOf { toSubsemiring := toSubsemiring, mem_of_isSquare' := mem_of_isSquare', neg_one_notMem' := neg_one_notMem' } =
1 + sizeOf toSubsemiring | true |
Std.DTreeMap.Internal.Const.RooSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.Const.RooSliceData α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.Const.RooSliceData α' β'} →
α = α' →
β = β' → inst ≍ inst' → t ≍ t' → Std.DTreeMap.Internal.Const.RooSliceData.noConfusionType P t t' | false |
Lean.Elab.Info.type? | Lean.Server.InfoUtils | Lean.Elab.Info → Lean.MetaM (Option Lean.Expr) | true |
String.Slice.Pattern.Model.SlicesFrom.any_head? | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} {startPos : s.Pos} (self : String.Slice.Pattern.Model.SlicesFrom startPos),
Option.any (fun x => decide (x.startInclusive = startPos)) self.l.head? = true | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.right i)) → motive j | true |
Int.toInt16 | Init.Data.SInt.Basic | ℤ → Int16 | true |
CategoryTheory.LaxFunctor.mapComp_naturality_right | Mathlib.CategoryTheory.Bicategory.Functor.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.LaxFunctor B C) {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (self.mapComp f g) (self.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.map f) (self.map₂ η))
(self.mapComp f g') | true |
Set.image_subtype_val_Ioo_Ioi | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (c : ↑(Set.Ioo a b)), Subtype.val '' Set.Ioi c = Set.Ioo (↑c) b | true |
IsCompactlyGenerated | Mathlib.Order.CompactlyGenerated.Basic | (α : Type u_3) → [CompleteLattice α] → Prop | true |
Homotopy.mkCoinductive._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0)
(comm_zero : e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero) (one : P.X 2 ⟶ Q.X 1)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) + CategoryTheory.CategoryStruct.comp (P.d 1 2) one)
(succ :
(n : ℕ) →
(p :
(f : P.X (n + 1) ⟶ Q.X n) ×'
(f' : P.X (n + 2) ⟶ Q.X (n + 1)) ×'
e.f (n + 1) =
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) +
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f') →
(f'' : P.X (n + 3) ⟶ Q.X (n + 2)) ×'
e.f (n + 2) =
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) +
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 3)) f'')
(i : ℕ),
e.f i =
(((dNext i) fun i j =>
if h : j + 1 = i then
CategoryTheory.CategoryStruct.comp (HomologicalComplex.xNextIso P h).inv
(Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ j).snd.fst
else 0) +
(prevD i) fun i j =>
if h : j + 1 = i then
CategoryTheory.CategoryStruct.comp (HomologicalComplex.xNextIso P h).inv
(Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ j).snd.fst
else 0) +
HomologicalComplex.Hom.f 0 i | false |
_private.Mathlib.RingTheory.Smooth.StandardSmoothOfFree.0.Algebra.Smooth.exists_span_eq_top_isStandardSmooth._proof_1_2 | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Algebra.Smooth R S] (p : PrimeSpectrum S), Algebra.FormallySmooth R (Localization p.asIdeal.primeCompl) | false |
ChainComplex.fromSingle₀Equiv_symm_apply_f_zero | Mathlib.Algebra.Homology.Single | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] {C : ChainComplex V ℕ} {X : V} (f : X ⟶ C.X 0),
((C.fromSingle₀Equiv X).symm f).f 0 = f | true |
Lean.instEmptyCollectionFVarIdSet | Lean.Expr | EmptyCollection Lean.FVarIdSet | true |
CategoryTheory.ShortComplex.instPreservesFiniteColimitsπ₂ | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteColimits C],
CategoryTheory.Limits.PreservesFiniteColimits CategoryTheory.ShortComplex.π₂ | true |
CategoryTheory.GrothendieckTopology.instPartialOrder._proof_4 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (x x_1 : CategoryTheory.GrothendieckTopology C),
x ≤ x_1 → x_1 ≤ x → x = x_1 | false |
GenContFract.IntFractPair.mapFr | Mathlib.Algebra.ContinuedFractions.Computation.Basic | {K : Type u_1} → {β : Type u_2} → (K → β) → GenContFract.IntFractPair K → GenContFract.IntFractPair β | true |
CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.homTo._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_5} {D : Type u_4} {H : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Category.{u_1, u_2} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.RightExtension F}
(h : E.IsPointwiseRightKanExtension) (G : L.RightExtension F) (Y₁ Y₂ : D) (φ : Y₁ ⟶ Y₂)
(X : CategoryTheory.StructuredArrow Y₂ L),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (G.left.map φ) ((h Y₂).lift (G.coneAt Y₂)))
((E.coneAt Y₂).π.app X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp ((h Y₁).lift (G.coneAt Y₁)) (E.left.map φ))
((E.coneAt Y₂).π.app X) | false |
ShareCommon.instInhabitedState | Init.ShareCommon | {σ : ShareCommon.StateFactory} → Inhabited (ShareCommon.State σ) | true |
LinearMap.mul._proof_2 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[IsScalarTower R A A] (r : R) (x y : A), r • x * y = r • (x * y) | false |
addConjugatesOf | Mathlib.Algebra.Group.Conj | {α : Type u} → [AddMonoid α] → α → Set α | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.minKey!_alter_eq_self._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
CategoryTheory.Limits.sigmaConst_map_app | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C] {X Y : C}
(f : X ⟶ Y) (n : Type w), (CategoryTheory.Limits.sigmaConst.map f).app n = CategoryTheory.Limits.Sigma.map fun x => f | true |
_private.Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree.0.Polynomial.IsMonicOfDegree.of_mul_left._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {n m : ℕ}, (n + m = 0) = (n = 0 ∧ m = 0) | false |
CategoryTheory.Functor.addMonObjObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε F)
(F.map CategoryTheory.AddMonObj.zero)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F X X)
(F.map CategoryTheory.AddMonObj.add)) =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom | false |
Module.Basis.localizationLocalization | Mathlib.RingTheory.Localization.Module | {R : Type u_1} →
(Rₛ : Type u_2) →
[inst : CommSemiring R] →
(S : Submonoid R) →
[inst_1 : CommSemiring Rₛ] →
[inst_2 : Algebra R Rₛ] →
[IsLocalization S Rₛ] →
{A : Type u_3} →
[inst_4 : CommSemiring A] →
[inst_5 : Algebra R A] →
(Aₛ : Type u_4) →
[inst_6 : CommSemiring Aₛ] →
[inst_7 : Algebra A Aₛ] →
[inst_8 : Algebra Rₛ Aₛ] →
[inst_9 : Algebra R Aₛ] →
[IsScalarTower R Rₛ Aₛ] →
[IsScalarTower R A Aₛ] →
[IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ] →
{ι : Type u_5} → Module.Basis ι R A → Module.Basis ι Rₛ Aₛ | true |
_private.Init.Data.Array.Extract.0.Array.popWhile_filterMap._simp_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α},
(List.filterMap f l).reverse = List.filterMap f l.reverse | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.mk.inj | Mathlib.Tactic.Translate.UnfoldBoundary | ∀ {unfolds : Lean.NameMap Lean.Meta.SimpTheorem} {casts : Lean.NameMap (Lean.Name × Lean.Name)}
{insertionFuns : Lean.NameSet} {unfolds_1 : Lean.NameMap Lean.Meta.SimpTheorem}
{casts_1 : Lean.NameMap (Lean.Name × Lean.Name)} {insertionFuns_1 : Lean.NameSet},
{ unfolds := unfolds, casts := casts, insertionFuns := insertionFuns } =
{ unfolds := unfolds_1, casts := casts_1, insertionFuns := insertionFuns_1 } →
unfolds = unfolds_1 ∧ casts = casts_1 ∧ insertionFuns = insertionFuns_1 | true |
Lean.TraceResult.ctorElimType | Lean.Message | {motive : Lean.TraceResult → Sort u} → ℕ → Sort (max 1 u) | false |
CategoryTheory.Functor.IsLocalization.comp | Mathlib.CategoryTheory.Localization.Composition | ∀ {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₃]
(L₁ : CategoryTheory.Functor C₁ C₂) (L₂ : CategoryTheory.Functor C₂ C₃) (W₁ : CategoryTheory.MorphismProperty C₁)
(W₂ : CategoryTheory.MorphismProperty C₂) [L₁.IsLocalization W₁] [L₂.IsLocalization W₂]
(W₃ : CategoryTheory.MorphismProperty C₁),
W₃.IsInvertedBy (L₁.comp L₂) → W₁ ≤ W₃ → W₂ ≤ W₃.map L₁ → (L₁.comp L₂).IsLocalization W₃ | true |
List.length_rightpad | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, (List.rightpad n a l).length = max n l.length | true |
_private.Mathlib.Data.Holor.0.Holor.cprankMax_add.match_1_3 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α]
(motive : (x : Holor α ds) → Holor.CPRankMax 0 x → Prop) (x : Holor α ds) (hx : Holor.CPRankMax 0 x),
(∀ (a : Unit), motive 0 ⋯) → motive x hx | false |
NumberField.ComplexEmbedding.Extension.not_isReal_of_not_isReal | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] {ψ : K →+* ℂ} [inst_2 : Algebra K L]
(φ : NumberField.ComplexEmbedding.Extension L ψ),
¬NumberField.ComplexEmbedding.IsReal ψ → ¬NumberField.ComplexEmbedding.IsReal ↑φ | true |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_2 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (x : ArchimedeanClass R),
0 • x = 0 | false |
TensorProduct.instNormedAddCommGroup._proof_7 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x x_1 x_2 : TensorProduct 𝕜 E F),
(TensorProduct.inner_✝ (x + x_1)) x_2 = (TensorProduct.inner_✝¹ x) x_2 + (TensorProduct.inner_✝² x_1) x_2 | false |
GroupSeminorm.toSeminormedCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [inst : CommGroup E] → GroupSeminorm E → SeminormedCommGroup E | true |
Lean.Meta.AC.PreContext.rec | Lean.Meta.Tactic.AC.Main | {motive : Lean.Meta.AC.PreContext → Sort u} →
((id : ℕ) →
(op assoc : Lean.Expr) →
(comm idem : Option Lean.Expr) → motive { id := id, op := op, assoc := assoc, comm := comm, idem := idem }) →
(t : Lean.Meta.AC.PreContext) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.