name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
inf_sup_self | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ (a ⊔ b) = a | true |
CategoryTheory.Preadditive.epi_of_cokernel_zero | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} {f : X ⟶ Y}
[inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f 0)],
CategoryTheory.Limits.cokernel.π f = 0 → CategoryTheory.Epi f | true |
MonCat.ofHom_hom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : MonCat} (f : M ⟶ N), MonCat.ofHom (MonCat.Hom.hom f) = f | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.whnfCore.go._unsafe_rec | Lean.Meta.WHNF | Lean.Expr → Lean.MetaM Lean.Expr | false |
ZMod.ringEquivOfPrime | Mathlib.Data.ZMod.Basic | (R : Type u_1) → [inst : Ring R] → [inst_1 : Fintype R] → {p : ℕ} → Nat.Prime p → Fintype.card R = p → ZMod p ≃+* R | true |
_private.Lean.Elab.PreDefinition.Eqns.0.Lean.Elab.Eqns.mkEqns.doRealize | Lean.Elab.PreDefinition.Eqns | Lean.Name → Lean.Name → Lean.DefinitionVal → Lean.Expr → Lean.MetaM Unit | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.insertMany_list_eq_empty_iff._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) | false |
CategoryTheory.FreeBicategory.mk_associator_hom | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h) =
(CategoryTheory.Bicategory.associator f g h).hom | true |
Aesop.SearchM.State.mk._flat_ctor | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.Iteration → Q → Bool → Aesop.SearchM.State Q | false |
WeierstrassCurve.Projective.dblZ_ne_zero_of_Y_ne' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 ≠ W'.negY Q * P 2 → W'.dblZ P ≠ 0 | true |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.eval_single_add'._simp_1_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | false |
Lean.Meta.Grind.AC.MonadGetStruct.ctorIdx | Lean.Meta.Tactic.Grind.AC.Util | {m : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m → ℕ | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.index_union_eq._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Dyadic.blt.eq_3 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), (Dyadic.ofOdd n k hn).blt Dyadic.zero = decide (n < 0) | true |
max_zero_add_max_neg_zero_eq_abs_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] (a : G),
max a 0 + max (-a) 0 = |a| | true |
Polynomial.ofFn._proof_1 | Mathlib.Algebra.Polynomial.OfFn | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : DecidableEq R] (n : ℕ) (x y : Fin n → R),
{ toFinsupp := (List.ofFn (x + y)).toFinsupp } =
{ toFinsupp := (List.ofFn x).toFinsupp } + { toFinsupp := (List.ofFn y).toFinsupp } | false |
Equiv.nonUnitalNonAssocRing._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocRing β] (x y : α),
e (e.symm (e x * e y)) = e x * e y | false |
GetElem.casesOn | Init.GetElem | {coll : Type u} →
{idx : Type v} →
{elem : Type w} →
{valid : coll → idx → Prop} →
{motive : GetElem coll idx elem valid → Sort u_1} →
(t : GetElem coll idx elem valid) →
((getElem : (xs : coll) → (i : idx) → valid xs i → elem) → motive { getElem := getElem }) → motive t | false |
Equiv.Perm.extendDomain_one | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p),
Equiv.Perm.extendDomain 1 f = 1 | true |
TopCat.prodIsoProd_hom_snd | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat),
CategoryTheory.CategoryStruct.comp (X.prodIsoProd Y).hom TopCat.prodSnd = CategoryTheory.Limits.prod.snd | true |
Lean.Elab.Do.DoElemContKind.noConfusion | Lean.Elab.Do.Basic | {P : Sort v✝} → {x y : Lean.Elab.Do.DoElemContKind} → x = y → Lean.Elab.Do.DoElemContKind.noConfusionType P x y | false |
Lean.ScopedEnvExtension.StateStack.recOn | Lean.ScopedEnvExtension | {α β σ : Type} →
{motive : Lean.ScopedEnvExtension.StateStack α β σ → Sort u} →
(t : Lean.ScopedEnvExtension.StateStack α β σ) →
((stateStack : List (Lean.ScopedEnvExtension.State σ)) →
(scopedEntries : Lean.ScopedEnvExtension.ScopedEntries β) →
(newEntries : List (Lean.ScopedEnvExtens... | false |
_private.Mathlib.RingTheory.Multiplicity.0.Nat.finiteMultiplicity_iff.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {b : ℕ} (motive : (a : ℕ) → (∀ (n : ℕ), a ^ n ∣ b) → a ≠ 0 → a ≠ 1 → a ≤ 1 → Prop) (a : ℕ) (h : ∀ (n : ℕ), a ^ n ∣ b)
(ha : a ≠ 0) (ha1 : a ≠ 1) (x : a ≤ 1),
(∀ (h : ∀ (n : ℕ), 0 ^ n ∣ b) (ha : 0 ≠ 0) (ha1 : 0 ≠ 1) (x : 0 ≤ 1), motive 0 h ha ha1 x) →
(∀ (h : ∀ (n : ℕ), 1 ^ n ∣ b) (ha : 1 ≠ 0) (ha1 : 1 ≠ 1) (x... | false |
Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.SplitIfs | Lean.Elab.Tactic.Tactic | false |
norm_le_norm_div_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (a b : E), ‖a‖ ≤ ‖a / b‖ + ‖b‖ | true |
NonemptyInterval.length_nonneg | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (s : NonemptyInterval α),
0 ≤ s.length | true |
MeasureTheory.AnalyticSet.preimage | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {X : Type u_3} {Y : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [PolishSpace X] [T2Space Y]
{s : Set Y}, MeasureTheory.AnalyticSet s → ∀ {f : X → Y}, Continuous f → MeasureTheory.AnalyticSet (f ⁻¹' s) | true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_16 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → 0 < (x :: y :: tail).length | false |
instMulActionSemiHomClassMulActionHom | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} (φ : M → N) (X : Type u_5) [inst : SMul M X] (Y : Type u_6) [inst_1 : SMul N Y],
MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y | true |
ProbabilityTheory.Kernel.coe_mk | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (f : α → MeasureTheory.Measure β)
(hf : Measurable f), ⇑{ toFun := f, measurable' := hf } = f | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRel.symm.match_1_3 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} (R : α → α → Prop) (x : Computation α) {x_1 : α} (motive : (∃ b ∈ x, R x_1 b) → Prop)
(x_2 : ∃ b ∈ x, R x_1 b), (∀ (b : α) (b2 : b ∈ x) (ab : R x_1 b), motive ⋯) → motive x_2 | false |
CommGroupWithZero.instNormalizedGCDMonoid._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] {x y : G₀},
x ≠ 0 →
y ≠ 0 →
↑(if h : x * y = 0 then 1 else (Units.mk0 (x * y) h)⁻¹) =
↑((if h : x = 0 then 1 else (Units.mk0 x h)⁻¹) * if h : y = 0 then 1 else (Units.mk0 y h)⁻¹) | false |
List.attach_reverse | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α},
xs.reverse.attach =
List.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach.reverse | true |
AlgebraicGeometry.Scheme.Hom.normalizationDiagramMap._proof_1 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U V : (TopologicalSpace.Opens ↥Y)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map i)
(CommRingCat.ofHom
(algebraMap ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↥(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.uno... | false |
AlgebraicGeometry.Scheme.Cover.gluedCover._proof_4 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f j))
(CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f k)) | false |
Lean.Parser.Tactic.appendConfig | Init.Meta.Defs | Lean.Syntax → Lean.Syntax → Lean.TSyntax `Lean.Parser.Tactic.optConfig | true |
RightCancelSemigroup.toSemigroup | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : RightCancelSemigroup G] → Semigroup G | true |
Subfield.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L), Subfield.extendScalars ⋯ = ⊥ | true |
MeasureTheory.diracProbaEquiv.congr_simp | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
[inst_3 : T0Space X], MeasureTheory.diracProbaEquiv = MeasureTheory.diracProbaEquiv | true |
HomologicalComplex.HomologySequence.snakeInput._proof_33 | Mathlib.Algebra.Homology.HomologySequence | 2 < 3 + 1 | false |
Mathlib.Deriving.Fintype.«_aux_Mathlib_Tactic_DeriveFintype___macroRules_Mathlib_Deriving_Fintype_termDerive_fintype%__1» | Mathlib.Tactic.DeriveFintype | Lean.Macro | false |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk.injEq | Lean.Elab.DocString | ∀ (footnotes : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls : Std.HashMap String (Lean.Doc.Ref✝¹ String))
(footnotes_1 : Std.HashMap String (Lean.Doc.Ref✝² (Lean.Doc.Inline Lean.ElabInline)))
(urls_1 : Std.HashMap String (Lean.Doc.Ref✝³ String)),
({ footnotes := footnotes, urls :=... | true |
CategoryTheory.Limits.ReflectsLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | true |
Matroid.Indep.exists_insert_of_not_maximal | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) ⦃I B : Set α⦄,
M.Indep I → ¬Maximal M.Indep I → Maximal M.Indep B → ∃ x ∈ B \ I, M.Indep (insert x I) | true |
LieModule.iSupIndep_genWeightSpace | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsDomain R] [Module.IsTorsionFree R M],
iSupIndep fun χ => Lie... | true |
Submodule.comapSubtypeEquivOfLe._proof_3 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (x : ↥(Submodule.comap q.subtype p)), ↑x ∈ Submodule.comap q.subtype p | false |
Aesop.TreeM.Context.mk.noConfusion | Aesop.Tree.TreeM | {P : Sort u} →
{currentIteration : Aesop.Iteration} →
{ruleSet : Aesop.LocalRuleSet} →
{currentIteration' : Aesop.Iteration} →
{ruleSet' : Aesop.LocalRuleSet} →
{ currentIteration := currentIteration, ruleSet := ruleSet } =
{ currentIteration := currentIteration', ruleSet := ... | false |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0.ModularFormClass.qExpansion_coeff_eq_intervalIntegral._simp_1_1 | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} (f : ℝ → E) (c : ℝ),
∫ (x : ℝ) in a * c..b * c, f x = c • ∫ (x : ℝ) in a..b, f (x * c) | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | false |
Std.IterM.DefaultConsumers.forIn'_eq_forIn'._unary | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type w'} {α β : Type w} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x} {P Q : β → Prop}
(Pl : β → γ → ForInStep γ → Prop) {f : (b : β) → P b → (c : γ) → n (Subtype (Pl b c))}
{g : (b : ... | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IicProdIoc_preimage._simp_1_2 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {f : (i : ι) → α i},
(f ∈ s.pi t) = ∀ i ∈ s, f i ∈ t i | false |
FormalMultilinearSeries.applyComposition_ones | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopologicalAddGroup E] [inst_8 : ContinuousConstSMul 𝕜 E] [inst_9 : IsTopolo... | true |
_private.Mathlib.Analysis.Convex.Integral.0.Convex.integral_mem._simp_1_3 | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
(b ∈ f.range) = (b ∈ Set.range ⇑f) | false |
CategoryTheory.Bicategory.LeftLift.whiskering | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
{x : B} →
(h : x ⟶ c) →
CategoryTheory.Functor (CategoryTheory.Bicategory.LeftLift f g)
(CategoryTheory.Bicategory.LeftLift f (CategoryTheory.CategorySt... | true |
Lean.Elab.Tactic.liftMetaTacticAux | Lean.Elab.Tactic.Basic | {α : Type} → (Lean.MVarId → Lean.MetaM (α × List Lean.MVarId)) → Lean.Elab.Tactic.TacticM α | true |
Bool.recOn._@.Mathlib.Util.CompileInductive.3618634379._hygCtx._hyg.5 | Mathlib.Util.CompileInductive | {motive : Bool → Sort u} → (t : Bool) → motive false → motive true → motive t | false |
Topology.IsInducing.isOpenMap | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Topology.IsInducing f → IsOpen (Set.range f) → IsOpenMap f | true |
CategoryTheory.CartesianMonoidalCategory.whiskerRight_toUnit_comp_leftUnitor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X Y : C)
{Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) Y)
(CategoryTheory.... | true |
CategoryTheory.Limits.ker._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {X Y Z : CategoryTheory.Arrow C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.kernel.lift Z.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory... | false |
MeasureTheory.Measure.ext_of_generateFrom_of_iUnion | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (C : Set (Set α)) (B : ℕ → Set α),
m0 = MeasurableSpace.generateFrom C →
IsPiSystem C → ⋃ i, B i = Set.univ → (∀ (i : ℕ), B i ∈ C) → (∀ (i : ℕ), μ (B i) ≠ ⊤) → (∀ s ∈ C, μ s = ν s) → μ = ν | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C},
CategoryTheory.CategoryStruct.comp (data.i.app f) (data.p.app f) = f.hom | true |
Submonoid.unitsTypeEquivIsUnitSubmonoid._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : Monoid M] (x : ↥(IsUnit.submonoid M)), (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x | false |
TrivSqZeroExt.kerIdeal._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M | false |
Std.HashSet.erase_emptyWithCapacity | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashSet.emptyWithCapacity c).erase a = Std.HashSet.emptyWithCapacity c | true |
Set.vadd_set_univ_pi | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {M : Type u_5} {ι : Type u_6} {π : ι → Type u_7} [inst : (i : ι) → VAdd M (π i)] (c : M) (s : (i : ι) → Set (π i)),
c +ᵥ Set.univ.pi s = Set.univ.pi (c +ᵥ s) | true |
HomologicalComplex.cyclesFunctor_map | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C]
{X Y : HomologicalComplex C c} (f : X ⟶ Y),
(HomologicalComplex.cyclesFunctor C c i).map f = HomologicalCo... | true |
Nat.Partrec.Code.zero.elim | Mathlib.Computability.PartrecCode | {motive : Nat.Partrec.Code → Sort u} → (t : Nat.Partrec.Code) → t.ctorIdx = 0 → motive Nat.Partrec.Code.zero → motive t | false |
AlgebraicTopology.NormalizedMooreComplex.objD._proof_1 | Mathlib.AlgebraicTopology.MooreComplex | ∀ (n : ℕ) (i : Fin (n + 1)), i.succ ∈ Finset.univ | false |
ComplexShape.Embedding.not_boundaryGE_next' | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsRelIff]
{j k : ι}, ¬e.BoundaryGE j → c.next j = k → ¬e.BoundaryGE k | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.noConfusion | Batteries.Data.MLList.Basic | {P : Sort u_1} →
{m : Type u → Type u} →
{t : MLList.Spec✝ m} →
{m' : Type u → Type u} → {t' : MLList.Spec✝¹ m'} → m = m' → t ≍ t' → MLList.Spec.noConfusionType✝ P t t' | false |
Rat.cast_min | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] (p q : ℚ), ↑(min p q) = min ↑p ↑q | true |
Mathlib.Meta.FunProp.Config.mk | Mathlib.Tactic.FunProp.Types | ℕ → ℕ → Mathlib.Meta.FunProp.Config | true |
ZMod.val_le | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} [NeZero n] (a : ZMod n), a.val ≤ n | true |
_private.Lean.Data.KVMap.0.Lean.KVMap.insert.match_1 | Lean.Data.KVMap | (motive : Lean.KVMap → Lean.Name → Lean.DataValue → Sort u_1) →
(x : Lean.KVMap) →
(x_1 : Lean.Name) →
(x_2 : Lean.DataValue) →
((m : List (Lean.Name × Lean.DataValue)) →
(k : Lean.Name) → (v : Lean.DataValue) → motive { entries := m } k v) →
motive x x_1 x_2 | false |
HomologicalComplex.truncLE'ToRestriction_naturality | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c') [inst_2 : e.IsTruncLE]
[inst_3 : ∀ (i' : ι'), K.HasHomology... | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_val_Iio._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
_private.Mathlib.RingTheory.Extension.Presentation.Submersive.0.Algebra.PreSubmersivePresentation.jacobian_reindex._simp_1_4 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), ⇑φ₁ ∘ ⇑φ₂ = ⇑(φ₁.comp φ₂) | false |
Lean.AttributeImpl.applicationTime._inherited_default | Lean.Attributes | Lean.AttributeApplicationTime | false |
ProbabilityTheory.setBernoulli._proof_1 | Mathlib.Probability.Distributions.SetBernoulli | IsScalarTower NNReal ENNReal ENNReal | false |
instCoeSortProfiniteGrpType | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CoeSort ProfiniteGrp.{u} (Type u) | true |
Topology.IsQuotientMap.trivializationOfSMulDisjoint._proof_9 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {G : Type u_1} [inst : Group G] [inst_1 : MulAction G E] (U : Set E),
(∀ (g : G), ((fun x => g • x) '' U ∩ U).Nonempty → g = 1) →
∀ {g₁ g₂ : G}, g₁ ≠ g₂ → Disjoint ((fun x => g₁ • x) ⁻¹' U) ((fun x => g₂ • x) ⁻¹' U) | false |
Order.krullDim_int | Mathlib.Order.KrullDimension | Order.krullDim ℤ = ⊤ | true |
MvPolynomial.support_rename_killCompl_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {p : MvPolynomial τ R} {f : σ → τ}
(hf : Function.Injective f), ((MvPolynomial.rename f) ((MvPolynomial.killCompl hf) p)).support ⊆ p.support | true |
MeasureTheory.Measure.rnDeriv_withDensity_withDensity_rnDeriv_left | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ENNReal} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
(∀ᵐ (x : α) ∂μ, f x ≠ ⊤) → ((ν.withDensity (μ.rnDeriv ν)).withDensity f).rnDeriv ν =ᵐ[ν] (μ.withDensity f).rnDeriv ν | true |
AdicCompletion.instCommRingAdicCauchySequence | Mathlib.RingTheory.AdicCompletion.Algebra | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → CommRing (AdicCompletion.AdicCauchySequence I R) | true |
CochainComplex.homOfDegreewiseSplit | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
((n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
(S.X₃ ⟶ (CategoryTheory.shiftFunctor (CochainC... | true |
_private.Mathlib.Tactic.NormNum.ModEq.0.Mathlib.Meta.NormNum.evalNatModEq.match_1 | Mathlib.Tactic.NormNum.ModEq | (αP : Q(Type)) →
(e : Q(«$αP»)) →
(motive : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b → Sort u_1) →
(__discr : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b) →
((b : Bool) → (pb : Mathlib.Meta.NormNum.BoolResult e b) → motive ⟨b, pb⟩) → motive __discr | false |
upperSemicontinuous_biInf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), UpperSemicontinuous (f i hi)) → UpperSemicontinuous fun x' => ⨅ i, ⨅ (hi : p i), f i hi x' | true |
_private.Std.Time.Time.HourMarker.0.Std.Time.HourMarker.toAbsolute._proof_1 | Std.Time.Time.HourMarker | 12 ≤ 23 | false |
Equiv.Perm.one_lt_of_mem_cycleType | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ}, n ∈ σ.cycleType → 1 < n | true |
Nat.two_pow_pred_mul_two | Init.Data.Nat.Lemmas | ∀ {w : ℕ}, 0 < w → 2 ^ (w - 1) * 2 = 2 ^ w | true |
Lean.Meta.Config.ctxApprox._default | Lean.Meta.Basic | Bool | false |
_private.Mathlib.Algebra.Group.Defs.0.npowBinRec.go_spec._proof_1_6 | Mathlib.Algebra.Group.Defs | ∀ (k' : ℕ), k' ≠ 0 → ¬2 * k' = 0 | false |
AddGroupNormClass.toAddGroupSeminormClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : AddGroup α} {inst_1 : AddCommMonoid β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : AddGroupNormClass F α β], AddGroupSeminormClass F α β | true |
_private.Mathlib.Analysis.Convex.Deriv.0.bddBelow_slope_lt_of_mem_interior.match_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜} {x : 𝕜} (y' : 𝕜)
(motive : y' ∈ slope f x '' {y | y ∈ s ∧ x < y} → Prop) (x_1 : y' ∈ slope f x '' {y | y ∈ s ∧ x < y}),
(∀ (z : 𝕜) (hz : z ∈ {y | y ∈ s ∧ x < y}) (hz' : slope f x z = y'), motive ⋯) → motive x_1 | false |
NonUnitalSubring.instSetLike | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} → [inst : NonUnitalNonAssocRing R] → SetLike (NonUnitalSubring R) R | true |
Filter.Germ.instDivisionRing._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionRing β], Nontrivial ((↑φ).Germ β) | false |
LinearMap.shortComplexKer._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom f.ker.subtype) (ModuleCat.ofHom f) = 0 | false |
MulOpposite.instSemifield._proof_2 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Semifield α] (a : αᵐᵒᵖ), DivisionSemiring.zpow 0 a = 1 | false |
StarMulEquiv.coe_trans | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Mul C] [inst_3 : Star A]
[inst_4 : Star B] [inst_5 : Star C] (e₁ : A ≃⋆* B) (e₂ : B ≃⋆* C), ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.