name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Basic.ENNReal.Basic.0.Mathlib.Meta.Positivity.evalENNRealOfNNReal._proof_1 | Mathlib.Basic.ENNReal.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q ENNReal.instZero)), «$_zα» =Q ENNReal.instZero | null | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.whnfMatcher.match_1 | Lean.Meta.WHNF | (motive : Lean.Meta.TransparencyMode → Sort u_1) →
(__do_lift : Lean.Meta.TransparencyMode) →
(Unit → motive Lean.Meta.TransparencyMode.reducible) →
(Unit → motive Lean.Meta.TransparencyMode.instances) →
(Unit → motive Lean.Meta.TransparencyMode.implicit) →
((x : Lean.Meta.TransparencyMode... | null | false |
RootPairingCat.weightIsModule | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} → [inst : CommRing R] → (self : RootPairingCat R) → Module R self.weight | null | true |
Matroid.isCircuit_iff_minimal_not_indep | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C : Set α}, C ⊆ M.E → (M.IsCircuit C ↔ Minimal (fun x => ¬M.Indep x) C) | null | true |
Option.any_filter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p q : α → Bool} (o : Option α), Option.any q (Option.filter p o) = Option.any (fun a => p a && q a) o | null | true |
PresheafOfModulesOfCommRing.Derivation.mk.sizeOf_spec | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModulesOfCommRing R} {φ : S ⟶ F.op.comp R}
[inst_2 : Siz... | null | true |
StructureGroupoid.LocalInvariantProp.liftProp_subtype_val | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
{G : StructureGroupoid H} {Q : (H → H) → Set H → H → Prop},
G.LocalInvariantProp G Q →
(∀ (y : H), Q id Set.univ y) → ∀ (U : TopologicalSpace.Opens M), ChartedSpace.LiftProp Q Subtype.val | null | true |
CategoryTheory.NonemptyParallelPairPresentationAux.hg | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f g : A ⟶ B)
(P₁ : CategoryTheory.Limits.IndObjectPresentation A) (P₂ : CategoryTheory.Limits.IndObjectPresentation B),
g =
(CategoryTheory.NonemptyParallelPairPresentationAux.isColimit₁ f g P₁ P₂).map
... | null | true |
FrameHom.comp._proof_1 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
[inst_2 : CompleteLattice γ] (f : FrameHom β γ) (g : FrameHom α β) (s : Set α),
({ toFun := ⇑f, map_sSup' := ⋯ }.comp { toFun := ⇑g, map_sSup' := ⋯ }).toFun (sSup s) =
sSup (({ toFun := ⇑f, map_sSup' := ⋯ }.co... | null | false |
Lean.ModuleHeader.recOn | Lean.Setup | {motive : Lean.ModuleHeader → Sort u} →
(t : Lean.ModuleHeader) →
((imports : Array Lean.Import) → (isModule : Bool) → motive { imports := imports, isModule := isModule }) → motive t | null | false |
Ideal.modulePi._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_2} {R : Type u_1} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] (a₁ : R) (a₂ : ι → R) (b₁ : R)
(b₂ : ι → R),
(Submodule.quotientRel I) a₁ b₁ →
(Submodule.quotientRel (Ideal.pi fun x => I)) a₂ b₂ →
Submodule.Quotient.mk (a₁ • a₂) = Submodule.Quotient.mk (b₁ • b₂) | null | false |
Lean.MetavarContext.MkBindingM.Context.quotContext | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → Lean.Name | null | true |
Lean.Meta.Match.Problem._sizeOf_inst | Lean.Meta.Match.Basic | SizeOf Lean.Meta.Match.Problem | null | false |
Int8.ofNat_toNatClampNeg | Init.Data.SInt.Lemmas | ∀ (x : Int8), 0 ≤ x → Int8.ofNat x.toNatClampNeg = x | null | true |
Frm.Hom._sizeOf_1 | Mathlib.Order.Category.Frm | {X Y : Frm} → X.Hom Y → ℕ | null | false |
Vector.insertIdx_size_self._proof_1 | Init.Data.Vector.InsertIdx | ∀ {n : ℕ}, n ≤ n | null | false |
Lean.Parser.Term.letNegOpt | Lean.Parser.Term | Lean.Parser.Parser | null | true |
Valued.toNormedField.norm_eq_one_iff | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [val : Valued L Γ₀]
[hv : Valued.v.RankOne] {x : L}, ‖x‖ = 1 ↔ Valued.v x = 1 | null | true |
Turing.TM2Computable._sizeOf_1 | Mathlib.Computability.TuringMachine.Computable | {α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} → [SizeOf α] → [SizeOf β] → [SizeOf αΓ] → [SizeOf βΓ] → Turing.TM2Computable ea eb f → ℕ | null | false |
dist_eq_norm_div | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedCommGroup E] (a b : E), dist a b = ‖a / b‖ | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Path.ordered_iff._simp_1_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | null | false |
Set.MapsTo.restrict_inj | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.MapsTo f s t),
Function.Injective (Set.MapsTo.restrict f s t h) ↔ Set.InjOn f s | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_of_linearIndepOn_of_finite_span._simp_1_12 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Type u_1} (x : α) (s : Set α), (s ⊆ insert x s) = True | null | false |
SetSemiring.instIdemSemiringOfMonoid._proof_6 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} [inst : Monoid α] (a : SetSemiring α), a * 1 = a | null | false |
_private.Mathlib.Data.List.Map2.0.List.map₂Left_eq_map₂Left'.match_1_1 | Mathlib.Data.List.Map2 | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Prop) (x : List α) (x_1 : List β),
(∀ (x : List β), motive [] x) →
(∀ (a : α) (as : List α), motive (a :: as) []) →
(∀ (a : α) (as : List α) (b : β) (bs : List β), motive (a :: as) (b :: bs)) → motive x x_1 | null | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.sUnion_singleton._simp_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, a = a' ∧ p a) = p a' | null | false |
CategoryTheory.Limits.Fork.ext._to_dual_3._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : Y ⟶ X}
{s t : CategoryTheory.Limits.Cofork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp t.π i.inv = s.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.mkHom i.hom ⋯)
(CategoryTheory.Limits.Cof... | null | false |
_private.Init.Data.Order.Ord.0.Array.instOrientedOrd._proof_1 | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.OrientedOrd α], Std.OrientedOrd (Array α) | null | false |
Std.Time.Month.instOfNatOrdinal | Std.Time.Date.Unit.Month | {n : ℕ} → OfNat Std.Time.Month.Ordinal n | null | true |
Asymptotics.IsBigO.triangle | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {F : Type u_3} {E' : Type u_4} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ f₃ : α → E'},
(fun x => f₁ x - f₂ x) =O[l] g → (fun x => f₂ x - f₃ x) =O[l] g → (fun x => f₁ x - f₃ x) =O[l] g | null | true |
HahnSeries.SummableFamily.instAddCommGroup._proof_2 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_2} {R : Type u_3} {α : Type u_1} [inst : PartialOrder Γ] [inst_1 : AddCommGroup R],
autoParam (∀ (a : HahnSeries.SummableFamily Γ R α), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
CategoryTheory.Limits.PreservesFiniteBiproducts.mk._flat_ctor | 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} [inst_4 : F.PreservesZeroMorphisms],
(∀ {J : Type} [Finit... | null | false |
BoxIntegral.Box.coe_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι}, ↑↑I = ↑I | null | true |
FreeAddMonoid.ofList_comp_toList | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, ⇑FreeAddMonoid.ofList ∘ ⇑FreeAddMonoid.toList = id | null | true |
Lean.Meta.MonadSimp.casesOn | Lean.Meta.MonadSimp | {m : Type → Type} →
{motive : Lean.Meta.MonadSimp m → Sort u} →
(t : Lean.Meta.MonadSimp m) →
((withNewLemmas : {α : Type} → Array Lean.Expr → m α → m α) →
(dsimp : Lean.Expr → m Lean.Expr) →
(simp : Lean.Expr → m Lean.Meta.MonadSimp.Result) →
motive { withNewLemmas := wi... | null | false |
Std.DTreeMap.Internal.Impl.applyCell.match_1 | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
{δ : Type u_4} →
[inst : Ord α] →
(k : α) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
((c : Std.DTreeMap.Internal.Cell α β (compare k)) →
(Std.DTreeMap.Internal.Impl.contains' (compare k) l = tru... | null | false |
WeierstrassCurve.IsCharThreeJNeZeroNF.a₃ | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} {inst : CommRing R} {W : WeierstrassCurve R} [self : W.IsCharThreeJNeZeroNF], W.a₃ = 0 | null | true |
Lean.Elab.Command.ComputedFieldView.recOn | Lean.Elab.MutualInductive | {motive : Lean.Elab.Command.ComputedFieldView → Sort u} →
(t : Lean.Elab.Command.ComputedFieldView) →
((ref modifiers : Lean.Syntax) →
(fieldId : Lean.Name) →
(type : Lean.Term) →
(matchAlts : Lean.TSyntax `Lean.Parser.Term.matchAlts) →
motive { ref := ref, modifiers :=... | null | false |
RightDerivMeasurableAux.B.eq_1 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] (f : ℝ → F) (K : Set F) (r s ε : ℝ),
RightDerivMeasurableAux.B f K r s ε = ⋃ L ∈ K, RightDerivMeasurableAux.A f L r ε ∩ RightDerivMeasurableAux.A f L s ε | null | true |
_private.Mathlib.Topology.Constructions.0.Topology.isOpenEmbedding_sigmaMap._simp_1_3 | Mathlib.Topology.Constructions | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
NzsNum.drec' | Mathlib.Data.Num.Bitwise | {C : SNum → Sort u_1} →
((b : Bool) → C (SNum.zero b)) → ((b : Bool) → (p : SNum) → C p → C (SNum.bit b p)) → (p : NzsNum) → C (SNum.nz p) | A dependent induction principle for `NzsNum`, with base cases `0 : SNum` and `(-1) : SNum`. | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.isLocalIdent?.match_3 | Lean.Elab.Term.TermElabM | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info rawVal val preresolved)) →
((x : Lean.Syntax) → motive x) → motive ... | null | false |
ArithmeticFunction.IsMultiplicative.intCast | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} {f : ArithmeticFunction ℤ} [inst : Ring R], f.IsMultiplicative → (↑f).IsMultiplicative | null | true |
Real.sqrt_eq_cases | Mathlib.Analysis.Real.Sqrt | ∀ {x y : ℝ}, √x = y ↔ y * y = x ∧ 0 ≤ y ∨ x < 0 ∧ y = 0 | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileNonFinalLet.match_12 | Lean.Compiler.LCNF.SimpleGroundExpr | (motive : Lean.Compiler.LCNF.SimpleGroundValue✝ → Sort u_1) →
(x : Lean.Compiler.LCNF.SimpleGroundValue✝) →
((size : ℕ) → motive (Lean.Compiler.LCNF.SimpleGroundValue.arg✝ (Lean.Compiler.LCNF.SimpleGroundArg.tagged size))) →
((x : Lean.Compiler.LCNF.SimpleGroundValue✝) → motive x) → motive x | null | false |
_private.Mathlib.Probability.Martingale.Basic.0.MeasureTheory.martingale_iff.match_1_1 | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] {f : ι → Ω → E}
{ℱ : MeasureTheory.Filtration ι m0} [inst_3 : PartialOrder E]
(motive : MeasureTheory.Supermartingale f ℱ μ ∧ Measure... | null | false |
_private.Mathlib.Data.List.Chain.0.List.IsChain.cons.match_1_1 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {x : α}
(motive : (x_1 : List α) → List.IsChain R x_1 → (∀ y ∈ x_1.head?, R x y) → Prop) (x_1 : List α)
(x_2 : List.IsChain R x_1) (x_3 : ∀ y ∈ x_1.head?, R x y),
(∀ (x_4 : List.IsChain R []) (x : ∀ y ∈ [].head?, R x y), motive [] x_4 x) →
(∀ (head : α) (tail : List α) (hl ... | null | false |
AdjoinRoot.coe_mapRingEquiv | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R ≃+* S) (p : Polynomial R)
(q : Polynomial S) (h : Associated (Polynomial.map (↑f) p) q),
⇑(AdjoinRoot.mapRingEquiv f p q h) = ⇑(AdjoinRoot.map (↑f) p q ⋯) | null | true |
Real.instSemigroup | Mathlib.Basic.Real.Basic | Semigroup ℝ | null | true |
IndiscreteTopology.nnnorm_eq_zero | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] [IndiscreteTopology E] (x : E), ‖x‖₊ = 0 | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLTLTIsoLT | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | The natural isomorphism `t.eTruncLT.obj a ⋙ t.eTruncLT.obj b ⟶ t.eTruncLT.obj b`
when `a` and `b` in `EInt` satisfy `b ≤ a`. | true |
SkewMonoidAlgebra.singleOneRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] (x y : k),
(↑(SkewMonoidAlgebra.singleAddHom 1)).toFun (x * y) =
(↑(SkewMonoidAlgebra.singleAddHom 1)).toFun x * (↑(SkewMonoidAlgebra.singleAddHom 1)).toFun y | null | false |
_private.Mathlib.Geometry.Convex.Cone.Pointed.0.PointedCone.sup_inf_assoc_of_le_submodule._simp_1_1 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{S T : Submodule R M}, (-S ≤ T) = (S ≤ -T) | null | false |
_private.Mathlib.Order.Cover.0.Pi.covBy_iff_exists_right_eq._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
SlashInvariantForm.coe_prod | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {ι : Type u_2} {s : Finset ι} {k : ι → ℤ} (m : ℤ) (hm : m = ∑ i ∈ s, k i) {Γ : Subgroup (GL (Fin 2) ℝ)}
[inst : Γ.HasDetPlusMinusOne] (f : (i : ι) → SlashInvariantForm Γ (k i)),
⇑(SlashInvariantForm.prod m hm f) = ∏ i ∈ s, ⇑(f i) | null | true |
SSet.Subcomplex.liftPath._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet} (A : X.Subcomplex) {n : ℕ} (p : X.Path n),
(∀ (j : Fin (n + 1)), p.vertex j ∈ A.obj (Opposite.op { len := 0 })) →
∀ (j : Fin n), p.vertex j.succ ∈ A.obj (Opposite.op { len := 0 }) | null | false |
addParenHeuristic | Init.Data.ToString.Basic | String → String | null | true |
Sbtw.const_add | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V} (v : V), Sbtw R x y z → Sbtw R (v + x) (v + y) (v + z) | **Alias** of the reverse direction of `sbtw_const_add_iff`. | true |
Rep.indResHomEquiv._proof_10 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_4} {H : Type u_2} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{max u_3 u_2 u_1, u_1, u_4} k G) (B : Rep.{max u_3 u_2 u_1, u_1, u_2} k H) (x : k) (x_1 : Rep.ind φ A ⟶ B),
Rep.ofHom
{ toLinearMap := (Rep.Hom.hom (x • x_1)).toLinearMap ∘ₗ Represent... | null | false |
MultilinearMap.piFamily._proof_3 | Mathlib.LinearAlgebra.Multilinear.Pi | ∀ {ι : Type u_1} {κ : ι → Type u_2} {R : Type u_5} {M : (i : ι) → κ i → Type u_4} {N : ((i : ι) → κ i) → Type u_3}
[inst : Semiring R] [inst_1 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)]
[inst_2 : (p : (i : ι) → κ i) → AddCommMonoid (N p)] [inst_3 : (i : ι) → (k : κ i) → Module R (M i k)]
[inst_4 : (p : (i : ι... | null | false |
CategoryTheory.Limits.biproduct.toSubtype | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(f : J → C) →
[inst_2 : CategoryTheory.Limits.HasBiproduct f] →
(p : J → Prop) →
[inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.r... | The canonical morphism from a biproduct to the biproduct over a restriction of its index
type. | true |
Nat.succ_pos | Init.Prelude | ∀ (n : ℕ), 0 < n.succ | null | true |
Ordinal.one_toType_eq | Mathlib.SetTheory.Ordinal.Basic | ∀ (x : Ordinal.ToType 1), x = (Ordinal.enum fun x1 x2 => x1 < x2) ⟨0, Ordinal.uniqueToTypeOne._proof_2⟩ | null | true |
AlgebraicGeometry.instFaithfulOverSchemePullbackOfSurjectiveOfFlatOfLocallyOfFinitePresentation | Mathlib.AlgebraicGeometry.Morphisms.FlatDescent | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Surjective f] [AlgebraicGeometry.Flat f]
[AlgebraicGeometry.LocallyOfFinitePresentation f], (CategoryTheory.Over.pullback f).Faithful | null | true |
OrderIso.image_Ico | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b a : α),
⇑e '' Set.Ico b a = Set.Ico (e b) (e a) | null | true |
Nat.sub_lt_sub_right | Init.Data.Nat.Basic | ∀ {a b c : ℕ}, c ≤ a → a < b → a - c < b - c | null | true |
Std.DTreeMap.Internal.Impl.getKey.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (t t_1 : Std.DTreeMap.Internal.Impl α β) (e_t : t = t_1) (k k_1 : α)
(e_k : k = k_1) (hlk : Std.DTreeMap.Internal.Impl.contains k t = true), t.getKey k hlk = t_1.getKey k_1 ⋯ | null | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1 | Mathlib.Algebra.Homology.ExactSequence | ¬0 ≤ 1 → False | null | false |
norm_iteratedFDeriv_clm_apply | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F →L[𝕜] G} {g : E → F} {N : Wi... | null | true |
ImportGraph.Shake.Bitset.ofArray | ImportGraph.Shake.Basic | Array ℕ → ImportGraph.Shake.Bitset | Regarding `idxs : Array Nat` as a set of `Bitset` indices, create a bitset which contains each
`idx ∈ idxs`. | true |
Set.Icc_inter_Icc | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Lattice α] {a₁ a₂ b₁ b₂ : α}, Set.Icc a₁ b₁ ∩ Set.Icc a₂ b₂ = Set.Icc (a₁ ⊔ a₂) (b₁ ⊓ b₂) | null | true |
Lean.Level.PP.Result.num.sizeOf_spec | Lean.Level | ∀ (a : ℕ), sizeOf (Lean.Level.PP.Result.num a) = 1 + sizeOf a | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.associator._proof_8 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.not_continuous_cofiniteTopology_of_symm._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | null | false |
MeasureTheory.SimpleFunc.instDiv | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Div β] → Div (MeasureTheory.SimpleFunc α β) | null | true |
Batteries.Tactic.Lint.SimpTheoremInfo.mk.noConfusion | Batteries.Tactic.Lint.Simp | {P : Sort u} →
{hyps : Array Lean.Expr} →
{lhs rhs : Lean.Expr} →
{hyps' : Array Lean.Expr} →
{lhs' rhs' : Lean.Expr} →
{ hyps := hyps, lhs := lhs, rhs := rhs } = { hyps := hyps', lhs := lhs', rhs := rhs' } →
(hyps = hyps' → lhs = lhs' → rhs = rhs' → P) → P | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.Opposite.instAdditiveOppositeShiftFunctorInt._proof_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (n : ℤ),
(CategoryTheory.shiftFunctor Cᵒᵖ n).Additive | null | false |
Module.End.mem_center_iff | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
{f : Module.End R M}, f ∈ Set.center (Module.End R M) ↔ ∃ α, ∃ (hα : α ∈ Set.center R), f = Module.End.smulLeft α hα | null | true |
Polynomial.isMonicOfDegree_two_iff' | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R] {f : Polynomial R},
f.IsMonicOfDegree 2 ↔ ∃ a b, f = Polynomial.X ^ 2 - Polynomial.C a * Polynomial.X + Polynomial.C b | A version of `Polynomial.isMonicOfDegree_two_iff` with negated middle coefficient. | true |
Std.Internal.USquashOrUnit | Std.Data.Iterators.Lemmas.Equivalence.HetT | Type v → Type u | null | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalFunInduction | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.Tactic | null | true |
PMF.mem_support_bindOnSupport_iff | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} {p : PMF α} (f : (a : α) → a ∈ p.support → PMF β) (b : β),
b ∈ (p.bindOnSupport f).support ↔ ∃ a, ∃ (h : a ∈ p.support), b ∈ (f a h).support | null | true |
CategoryTheory.Precoverage.SubsheafClosure.below | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))} →
{motive : (Z : C) → (a : F.obj (Opposite.op Z)) → K.SubsheafClosure 𝒮 Z a → Prop} →
{Z : C... | null | true |
Std.ExtTreeSet.minD_le_of_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true → ∀ {fallback : α}, (cmp (t.minD fallback) k).isLE = true | null | true |
_private.Mathlib.Data.PFunctor.Univariate.Basic.0.PFunctor.liftp_iff'._simp_1_1 | Mathlib.Data.PFunctor.Univariate.Basic | ∀ {P : PFunctor.{uA, uB}} {α : Type u} (p : α → Prop) (x : ↑P α),
Functor.Liftp p x = ∃ a f, x = PFunctor.Obj.mk a f ∧ ∀ (i : P.B a), p (f i) | null | false |
Std.ExtTreeSet.get_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α}
{hc : t.contains km = true}, t.max?.get ⋯ = km → t.get km hc = km | null | true |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj_obj_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.bojanic_mahler_step1._simp_1_2 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {α : Type u} (f : α → α) (m n : ℕ) (x : α), f^[m] (f^[n] x) = f^[m + n] x | null | false |
LinearMap.instNeg._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_3} {R₂ : Type u_4} {M : Type u_2} {N₂ : Type u_1} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommGroup N₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ N₂] {σ₁₂ : R₁ →+* R₂}
(f : M →ₛₗ[σ₁₂] N₂) (m : R₁) (x : M), (-⇑f) (m • x) = σ₁₂ m • (-⇑f) x | null | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.IsLocalizedModule.exists_isLocalizedModule_powers_of_finitePresentation._simp_1_4 | Mathlib.Algebra.Module.FinitePresentation | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x | null | false |
Stream'.WSeq.join_join._simp_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} (SS : Stream'.WSeq (Stream'.WSeq (Stream'.WSeq α))),
(SS.join.join ~ʷ (Stream'.WSeq.map Stream'.WSeq.join SS).join) = True | null | false |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._proof_38 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (a b : AdjoinPthRoots k), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Array.min?_eq_some_iff | Init.Data.Array.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] {xs : Array α} [Std.IsLinearOrder α] [Std.LawfulOrderMin α],
xs.min? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, a ≤ b | null | true |
MultilinearMap.instAddMonoid._proof_6 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R ℕ M₂ | null | false |
TwoSidedIdeal.instZeroSubtypeMem | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → (I : TwoSidedIdeal R) → Zero ↥I | null | true |
MvQPF.Pi.inst | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} → {A : Type u} → (F : A → TypeVec.{u} n → Type u) → [(α : A) → MvQPF (F α)] → MvQPF (MvQPF.Pi F) | null | true |
LowerSet.map._proof_6 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) (x : LowerSet β),
{ carrier := ⇑f '' ↑{ carrier := ⇑f ⁻¹' ↑x, lower' := ⋯ }, lower' := ⋯ } = x | null | false |
NormedAddGroupHom.mk | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] →
(toFun : V → W) →
(∀ (v₁ v₂ : V), toFun (v₁ + v₂) = toFun v₁ + toFun v₂) →
(∃ C, ∀ (v : V), ‖toFun v‖ ≤ C * ‖v‖) → NormedAddGroupHom V W | null | true |
PointedCone.positive.congr_simp | Mathlib.Geometry.Convex.Cone.Dual | ∀ (R : Type u_1) (E : Type u_2) [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : PartialOrder E] [inst_5 : IsOrderedAddMonoid E] [inst_6 : Module R E]
[inst_7 : PosSMulMono R E], PointedCone.positive R E = PointedCone.positive R E | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.UniversalCoprimeFactorizationRing.factor₁_mul_factor₂._simp_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A],
(algebraMap S A).comp (algebraMap R S) = algebraMap R A | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.