name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Pi.mulSingle_le_mulSingle._simp_3 | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : DecidableEq ι] [inst_1 : (i : ι) → One (α i)]
[inst_2 : (i : ι) → Preorder (α i)] {i : ι} {a b : α i}, (Pi.mulSingle i a ≤ Pi.mulSingle i b) = (a ≤ b) | null | false |
AlgebraicGeometry.braidedAlgSpec._proof_14 | Mathlib.AlgebraicGeometry.Group.Affine | ∀ {R : CommRingCat},
(fun X Y =>
CategoryTheory.Over.homMk (AlgebraicGeometry.pullbackSpecIso ↑R ↑(Opposite.unop X) ↑(Opposite.unop Y)).inv ⋯) =
CategoryTheory.Functor.OplaxMonoidal.δ (AlgebraicGeometry.algSpec R) | null | false |
Std.Internal.UV.Loop.Options.mk.sizeOf_spec | Std.Internal.UV.Loop | ∀ (accumulateIdleTime blockSigProfSignal : Bool),
sizeOf { accumulateIdleTime := accumulateIdleTime, blockSigProfSignal := blockSigProfSignal } =
1 + sizeOf accumulateIdleTime + sizeOf blockSigProfSignal | null | true |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.rmatch_iff_matches'._simp_1_2 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} {l m : Language α} {x : List α}, (x ∈ l * m) = ∃ a ∈ l, ∃ b ∈ m, a ++ b = x | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints.0.UpperHalfPlane.gl_smul_I_eq_I_iff_of_neg._simp_1_2 | Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
CStarAlgebra.Commute.negPart_anti._auto_3 | Mathlib.Analysis.CStarAlgebra.Commutative.PosPart | Lean.Syntax | null | false |
SSetPair.instEpiFNatChainComplexπ | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (P : SSetPair) (R : C) (n : ℕ), CategoryTheory.Epi ((P.chainComplexπ R).f n) | null | true |
UInt64.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin UInt64.size), (UInt64.ofFin x).toNat = ↑x | null | true |
Std.ExtDHashMap.get_eq_get_get? | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α}
{h : a ∈ m}, m.get a h = (m.get? a).get ⋯ | null | true |
Std.Time.Database.TZdb.instBEqTZSpec | Std.Time.Zoned.Database.TZdb | BEq Std.Time.Database.TZdb.TZSpec | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.EqResult.decide.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (b b_1 : Bool), (Nat.EqResult.decide✝ b = Nat.EqResult.decide✝ b_1) = (b = b_1) | null | true |
Cardinal.power_one | Mathlib.SetTheory.Cardinal.Defs | ∀ (a : Cardinal.{u}), a ^ 1 = a | null | true |
instCompactSpaceQuotientIdeal | Mathlib.Topology.Algebra.Ring.Ideal | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : CommRing R] (N : Ideal R) [CompactSpace R], CompactSpace (R ⧸ N) | null | true |
CategoryTheory.ShortComplex.RightHomologyData.homologyIso_rightHomologyData | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
S.rightHomologyData.homologyIso = S.rightHomologyIso.symm | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.instCategory._proof_6 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_2} {C₂ : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{W X Y Z : Φ.LeftResolution X₂} (f : W.Hom X)... | null | false |
AlgebraicGeometry.GeometricallyIntegral.eq_geometricallyReduced_inf_geometricallyIrreducible | Mathlib.AlgebraicGeometry.Geometrically.Integral | @AlgebraicGeometry.GeometricallyIntegral =
@AlgebraicGeometry.GeometricallyReduced ⊓ @AlgebraicGeometry.GeometricallyIrreducible | null | true |
Homeomorph.applyMulAction._proof_1 | Mathlib.Topology.Algebra.ConstMulAction | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x x_1 : X ≃ₜ X) (x_2 : X), (x * x_1) • x_2 = (x * x_1) • x_2 | null | false |
CategoryTheory.Limits.Cocone.extendId | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cocone F) → s.extend (CategoryTheory.CategoryStruct.id s.pt) ≅ s | Extending a cocone by the identity does nothing. | true |
List.cyclicPermutations.match_1 | Mathlib.Data.List.Rotate | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) →
((l : List α) →
(head : α) → (tail : List α) → (h : l = head :: tail) → motive (namedPattern l (head :: tail) h)) →
motive x | null | false |
Std.IterStep.yield.sizeOf_spec | Init.Data.Iterators.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : SizeOf α] [inst_1 : SizeOf β] (it : α) (out : β),
sizeOf (Std.IterStep.yield it out) = 1 + sizeOf it + sizeOf out | null | true |
HomotopicalAlgebra.Precylinder.map_i₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D), (P.map F).i₁ = F.map P.i₁ | null | true |
Std.Time.Internal.Bounded.LE.ofFin'._proof_1 | Std.Time.Internal.Bounded | ∀ {hi lo : ℕ} (fin : Fin hi.succ), ↑fin ≥ lo → lo ≤ ↑fin ∧ ↑fin ≤ hi | null | false |
RingCon.comap_rel._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_2} {R' : Type u_3} {F : Type u_4} [inst : Add R] [inst_1 : Add R'] [inst_2 : FunLike F R R']
[inst_3 : AddHomClass F R R'] [inst_4 : Mul R] [inst_5 : Mul R'] [inst_6 : MulHomClass F R R'] {J : RingCon R'}
{f : F} {x y : R}, (J.comap f) x y = J (f x) (f y) | null | false |
Meromorphic.Gamma | Mathlib.Analysis.Meromorphic.Complex | Meromorphic Complex.Gamma | null | true |
LinearOrderedAddCommGroupWithTop.toAddCommMonoid | Mathlib.Algebra.Order.AddGroupWithTop | {α : Type u_3} → [self : LinearOrderedAddCommGroupWithTop α] → AddCommMonoid α | null | true |
_private.Mathlib.Tactic.ClickSuggestions.0.Mathlib.Tactic.ClickSuggestions.rpc.match_1 | Mathlib.Tactic.ClickSuggestions | (motive : Lean.SubExpr.GoalLocation → Sort u_1) →
(x : Lean.SubExpr.GoalLocation) →
((a : Lean.FVarId) → (a_1 : Lean.SubExpr.Pos) → motive (Lean.SubExpr.GoalLocation.hypValue a a_1)) →
((x : Lean.SubExpr.GoalLocation) → motive x) → motive x | null | false |
CategoryTheory.Abelian.FreydMitchell.instRingEmbeddingRing._proof_5 | Mathlib.CategoryTheory.Abelian.FreydMitchell | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(a b c : CategoryTheory.Abelian.FreydMitchell.EmbeddingRing C), a + b + c = a + (b + c) | null | false |
PointedCone.ofSubmoduleLatticeHom | Mathlib.Geometry.Convex.Cone.Pointed | {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 : Module R E] → CompleteLatticeHom (Submodule R E) (PointedCone R E) | Coercion from submodules to pointed cones as a lattice homomorphism. | true |
_private.Lean.Elab.Tactic.RCases.0.PSigma.casesOn._arg_pusher | Lean.Elab.Tactic.RCases | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.TopDown.iff_bottomUp._proof_1_4 | Batteries.Data.BinaryHeap.WF | ∀ {sz : ℕ} (i : Fin sz), ↑⟨(↑i - 1) / 2, ⋯⟩ < sz | null | false |
exists_and_right | Init.PropLemmas | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) ↔ (∃ x, p x) ∧ b | null | true |
IsDedekindDomain.selmerGroup | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[IsFractionRing R K] →
{S : Set (IsDedekindDomain.HeightOneSpectrum R)} → {n : ℕ} → Subgroup (Kˣ ⧸ (powMonoidHom n).range) | The Selmer group `K⟮S, n⟯`. | true |
_private.Lean.Elab.PreDefinition.TerminationHint.0.Lean.Elab.elabTerminationHints._sparseCasesOn_4 | Lean.Elab.PreDefinition.TerminationHint | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
GroupFilterBasis.t2Space_iff | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} [inst : Group G] [t : TopologicalSpace G] (F : GroupFilterBasis G),
F.topology = t → (T2Space G ↔ ⋂₀ F.sets = {1}) | null | true |
Rat.isUniformEmbedding_coe_real | Mathlib.Topology.Instances.Rat | IsUniformEmbedding Rat.cast | null | true |
_aux_Mathlib_Order_Notation___unexpand_HImp_himp_1 | Mathlib.Order.Notation | Lean.PrettyPrinter.Unexpander | null | false |
finprod_eq_if | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : CommMonoid M] {p : Prop} [inst_1 : Decidable p] {x : M}, ∏ᶠ (_ : p), x = if p then x else 1 | null | true |
TopologicalSpace.IsTopologicalBasis.open_eq_iUnion | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {B : Set (Set α)},
TopologicalSpace.IsTopologicalBasis B → ∀ {u : Set α}, IsOpen u → ∃ β f, u = ⋃ i, f i ∧ ∀ (i : β), f i ∈ B | null | true |
AlgebraicGeometry.ProjectiveSpectrum.Proj.toStalk_stalkMap_toSpec | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) (x : ↑((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).toTopCat),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.ΓSpecIso ↧(HomogeneousL... | null | true |
Submodule.closedComplemented_iff_exists_isTopCompl | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p : Submodule R M}, p.ClosedComplemented ↔ ∃ q, Submodule.IsTopCompl p q | null | true |
SSet.exactAt_chainComplex_of_hasDimensionLT._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | Lean.Syntax | null | false |
IO.eprintln | Init.System.IO | {α : Type u_1} → [ToString α] → α → IO Unit | Converts `s` to a string using its `ToString α` instance, and prints it with a trailing newline to
the current standard error (as determined by `IO.getStderr`).
| true |
PrimeSpectrum.primeSpectrumProdOfSum.eq_1 | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ (R : Type u) (S : Type v) [inst : CommSemiring R] [inst_1 : CommSemiring S] (I : Ideal R) (isPrime : I.IsPrime),
PrimeSpectrum.primeSpectrumProdOfSum R S (Sum.inl { asIdeal := I, isPrime := isPrime }) =
{ asIdeal := I.prod ⊤, isPrime := ⋯ } | null | true |
Std.Sat.AIG.instInhabitedFanin | Std.Sat.AIG.Basic | Inhabited Std.Sat.AIG.Fanin | null | true |
CategoryTheory.PreOneHypercover.IsStronglySheafFor.isSeparatedFor_sieve₁ | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_3)},
E.IsStronglySheafFor F →
∀ ⦃i j : E.I₀⦄ ⦃W : C⦄ (p₁ : W ⟶ E.X i) (p₂ : W ⟶ E.X j),
CategoryTheory.CategoryStruct.comp p₁ (E.f i) = CategoryTheory.Cate... | null | true |
SymmetricAlgebra.IsSymmetricAlgebra.mvPolynomial | Mathlib.LinearAlgebra.SymmetricAlgebra.Basis | ∀ {R : Type uR} {M : Type uM} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (I : Type u_1)
(b : Module.Basis I R M), IsSymmetricAlgebra ((b.constr R) MvPolynomial.X) | null | true |
HomologicalComplex.cylinder.desc.eq_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F K : HomologicalComplex C c} [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasCylinder]
(φ₀ φ₁ : K... | null | true |
Submodule.restrictScalars_image_smul_eq | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {S : Type u_1} {M : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra S R]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (s : Set S)
(N : Submodule R M), Submodule.restrictScalars S (⇑(algebraMap S R) '' s • N) = s • ... | null | true |
UInt8.decLe | Init.Prelude | (a b : UInt8) → Decidable (a ≤ b) | Decides whether one 8-bit unsigned integer is less than or equal to another. Usually accessed via the
`DecidableLE UInt8` instance.
This function is overridden at runtime with an efficient implementation.
Examples:
* `(if (15 : UInt8) ≤ 15 then "yes" else "no") = "yes"`
* `(if (15 : UInt8) ≤ 5 then "yes" else "no")... | true |
CategoryTheory.Limits.diagramIsoCospan | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingCospan C) →
F ≅
CategoryTheory.Limits.cospan (F.map CategoryTheory.Limits.WalkingCospan.Hom.inl)
(F.map CategoryTheory.Limits.WalkingCospan.Hom.inr) | Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` | true |
MeasureTheory.SimpleFunc.tendsto_approxOn_range_Lp_eLpNorm | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {β : Type u_2} {E : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace E] [inst_2 : NormedAddCommGroup E]
{p : ENNReal} [inst_3 : BorelSpace E] {f : β → E},
p ≠ ⊤ →
∀ {μ : MeasureTheory.Measure β} (fmeas : Measurable f)
[inst_4 : TopologicalSpace.SeparableSpace ↑(Set.range f ∪ {0})],
M... | null | true |
Std.DTreeMap.Equiv.any_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{p : (a : α) → β a → Bool}, t₁.Equiv t₂ → t₁.any p = t₂.any p | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_preimage | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} {ι : Type u_3} [inst : AddCommMonoid M] [Finite ι] {F : Type u_5} [inst_2 : FunLike F (ι → ℕ) M]
[AddMonoidHomClass F (ι → ℕ) M] {s : Set M}, IsSemilinearSet s → ∀ (f : F), IsSemilinearSet (⇑f ⁻¹' s) | null | true |
Quaternion.normSq_nonneg._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(0 ≤ Quaternion.normSq a) = True | null | false |
Array.set_eq_empty_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {h : i < xs.size}, xs.set i a h = #[] ↔ xs = #[] | null | true |
Inv.mk.noConfusion | Init.Prelude | {α : Type u} → {P : Sort u_1} → {inv inv' : α → α} → { inv := inv } = { inv := inv' } → (inv ≍ inv' → P) → P | null | false |
Std.DTreeMap.Internal.Impl.getEntryLT.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α)
(x_3 : Std.DTreeMap.Internal.Impl.leaf.Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.leaf, compare a k = Ordering.lt),
Std.DTreeMap.Internal.Impl.getEntryLT k Std.DTreeMap.Internal.Impl.leaf x_3 he = ⋯.elim | null | true |
AlgHom.toLieHom | Mathlib.Algebra.Lie.OfAssociative | {A : Type v} →
[inst : Ring A] →
{R : Type u} →
[inst_1 : CommRing R] →
[inst_2 : Algebra R A] → {B : Type w} → [inst_3 : Ring B] → [inst_4 : Algebra R B] → (A →ₐ[R] B) → A →ₗ⁅R⁆ B | The map `ofAssociativeAlgebra` associating a Lie algebra to an associative algebra is
functorial. | true |
CategoryTheory.Limits.WidePullbackShape.fintypeObj | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | {J : Type v} → [Fintype J] → Fintype (CategoryTheory.Limits.WidePullbackShape J) | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.core0.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{a zero a' zero' : Lean.Expr} →
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.core0 a zero =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.core0 a' zero' →
(a = a' → zero = zero' → P) → P | null | false |
OmegaCompletePartialOrder.ContinuousHom.ofFun._auto_1 | Mathlib.Order.OmegaCompletePartialOrder | Lean.Syntax | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.nonsingular_zero._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} (a b c : R), ![a, b, c] 1 = b | null | false |
Lean.Elab.DefKind.rec | Lean.Elab.DefView | {motive : Lean.Elab.DefKind → Sort u} →
motive Lean.Elab.DefKind.def →
motive Lean.Elab.DefKind.instance →
motive Lean.Elab.DefKind.theorem →
motive Lean.Elab.DefKind.example →
motive Lean.Elab.DefKind.opaque → motive Lean.Elab.DefKind.abbrev → (t : Lean.Elab.DefKind) → motive t | null | false |
IsMin.not_isMax | Mathlib.Order.Directed | ∀ {β : Type u_2} [inst : PartialOrder β] [Nontrivial β] [IsCodirectedOrder β] {b : β}, IsMin b → ¬IsMax b | null | true |
QuadraticAlgebra.im_changeGenerator_apply | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} [inst : CommRing R] (a b u k : R) {a' b' : R} (ha : a' = u ^ 2 * a - u * b * k - k ^ 2)
(hb : b' = u * b + 2 * k) (z : QuadraticAlgebra R a' b'),
((QuadraticAlgebra.changeGenerator a b u k ha hb) z).im = z.im * u | null | true |
WithBot.map_comp_map | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ),
WithBot.map g ∘ WithBot.map f = WithBot.map (g ∘ f) | null | true |
ContinuousLinearMap.const._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {M : Type u_1} [inst : TopologicalSpace M] (α : Type u_2) [inst_1 : TopologicalSpace α],
Continuous fun m => ContinuousMap.const α m | null | false |
Std.DTreeMap.foldrM | Std.Data.DTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{δ : Type w} → {m : Type w → Type w₂} → [Monad m] → ((a : α) → β a → δ → m δ) → δ → Std.DTreeMap α β cmp → m δ | Folds the given monadic function over the mappings in the map in descending order. | true |
HomotopicalAlgebra.Cylinder.IsVeryGood.rec | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : C} →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
{P : HomotopicalAlgebra.Cylinder A} →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A A] →
[inst_3 : HomotopicalAlgebra.CategoryWithCofibrati... | null | false |
Matrix.natCast_mem_unitary._simp_1 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_2} {R : Type u_3} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring R] [inst_3 : StarRing R]
[Nonempty n] {k : ℕ}, (↑k ∈ unitary (Matrix n n R)) = (↑k ∈ unitary R) | null | false |
String.Slice.Pos.le_trans | Init.Data.String.Basic | ∀ {s : String.Slice} {p q r : s.Pos}, p ≤ q → q ≤ r → p ≤ r | null | true |
Prop.instHeytingAlgebra._proof_1 | Mathlib.Order.Heyting.Basic | ∀ (x x_1 x_2 : Prop), x → x_1 → x_2 ↔ x ∧ x_1 → x_2 | null | false |
Topology.IsInducing.isCompact_preimage_iff | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Topology.IsInducing f → ∀ {K : Set Y}, K ⊆ Set.range f → (IsCompact (f ⁻¹' K) ↔ IsCompact K) | null | true |
Lean.AssocList.ctorIdx | Lean.Data.AssocList | {α : Type u} → {β : Type v} → Lean.AssocList α β → ℕ | null | false |
Std.IterM.zip | Std.Data.Iterators.Combinators.Monadic.Zip | {m : Type w → Type w'} →
{α₁ β₁ : Type w} →
[inst : Std.Iterator α₁ m β₁] → {α₂ β₂ : Type w} → Std.IterM m β₁ → Std.IterM m β₂ → Std.IterM m (β₁ × β₂) | Given two iterators `left` and `right`, `left.zip right` is an iterator that yields pairs of
outputs of `left` and `right`. When one of them terminates,
the `zip` iterator will also terminate.
**Marble diagram:**
```text
left --a ---b --c
right --x --y --⊥
le... | true |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_empty._simp_1_1 | Mathlib.Analysis.Convex.Gauge | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | null | false |
MeasureTheory.Submartingale.sub_martingale | 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 g : ι → Ω → E}
{ℱ : MeasureTheory.Filtration ι m0} [CompleteSpace E] [inst_4 : Preorder E] [AddLeftMono E],
MeasureTheory.Submarti... | null | true |
Order.IsSuccLimit.lt_iff_nonempty_Ioo | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a b : α} [inst : Preorder α], Order.IsSuccLimit a → (b < a ↔ (Set.Ioo b a).Nonempty) | null | true |
Std.DTreeMap.Internal.Impl.keysArray | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β → Array α | Returns an `Array` of the keys in order. | true |
Subarray.mergeSort.induct_unfolding | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} (le : α → α → Bool) (motive : Subarray α → Array α → Prop),
(∀ (x : Subarray α),
1 < Std.Slice.size x →
have splitIdx := (Std.Slice.size x + 1) / 2;
have left := Std.Rio.Sliceable.mkSlice x *...splitIdx;
have right := Std.Rci.Sliceable.mkSlice x (splitIdx...*);
m... | null | true |
Std.Http.Status.noContent.sizeOf_spec | Std.Http.Data.Status | sizeOf Std.Http.Status.noContent = 1 | null | true |
Ordinal.mulRightMono | Mathlib.SetTheory.Ordinal.Arithmetic | MulRightMono Ordinal.{u} | null | true |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_6 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
HeytAlg.ext | Mathlib.Order.Category.HeytAlg | ∀ {X Y : HeytAlg} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g | null | true |
HasFDerivWithinAt.pow'._f | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedAlgebra 𝕜 𝔸] [inst_4 : NormedSpace 𝕜 E] {f : E → 𝔸} {f' : E →L[𝕜] 𝔸}
{x : E} {s : Set E},
HasFDerivWithinAt f f' s x →
∀ (n : ℕ) (f_1 : Nat.below ... | null | false |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.hittingBtwn_mono_left.match_1_4 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_3} {β : Type u_2} {ι : Type u_1} [inst : ConditionallyCompleteLinearOrder ι] (u : ι → Ω → β) (s : Set β)
(m : ι) ⦃n' : ι⦄ (ω : Ω) (motive : (∃ j ∈ Set.Icc n' m, u j ω ∈ s) → Prop) (h_n' : ∃ j ∈ Set.Icc n' m, u j ω ∈ s),
(∀ (t : ι) (ht : t ∈ Set.Icc n' m ∧ u t ω ∈ s), motive ⋯) → motive h_n' | null | false |
Std.DTreeMap.Raw.WF.getThenInsertIfNew? | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {a : α} {b : β a}, t.WF → (t.getThenInsertIfNew? a b).2.WF | null | true |
SimplexCategory.Truncated.δ₂_two_comp_σ₂_zero_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {Z : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ 2}
(h : { obj := { len := 1 }, property := SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 2 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1
Simp... | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom | Mathlib.CategoryTheory.Monoidal.Action.Basic | {C : Type u_1} →
{D : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} →
{inst_2 : CategoryTheory.MonoidalCategoryStruct C} →
[self : CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D] →
{c c' : C} →
... | The action of a pair of maps `f : c ⟶ c'` and `d ⟶ d'`. By default,
this is defined in terms of `actionHomLeft` and `actionHomRight`. | true |
MeasureTheory.tendsto_of_forall_isOpen_le_liminf_nat | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{μ : MeasureTheory.ProbabilityMeasure Ω} {μs : ℕ → MeasureTheory.ProbabilityMeasure Ω},
(∀ (G : Set Ω), IsOpen G → μ G ≤ Filter.liminf (fun i => (μs i) G) Filter.atTop) →
Filter.Tendsto (fun i => μs i) Fi... | One implication of the portmanteau theorem: if for all open sets `G` we have the liminf
condition `μ(G) ≤ liminf μsₙ(G)`, then the measures `μsₙ` converge weakly to the measure `μ`.
Superseded by `tendsto_of_forall_isOpen_le_liminf` which works for all countably
generated filters. | true |
_private.Mathlib.Analysis.Real.Pi.Irrational.0.I_one | Mathlib.Analysis.Real.Pi.Irrational | ∀ {θ : ℝ}, I✝ 1 θ * θ ^ 3 = 4 * Real.sin θ - 4 * θ * Real.cos θ | Auxiliary for the proof that `π` is irrational.
The second base case for the induction on `n`, giving an explicit formula for `I 1 θ`.
| true |
eq_lim_at_left_extendFrom_Ioo | Mathlib.Topology.Order.ExtendFrom | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [DenselyOrdered α]
[OrderTopology α] [inst_4 : TopologicalSpace β] {f : α → β} {a b : α} {la : β} [T2Space β],
a < b → Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds la) → extendFrom (Set.Ioo a b) f a = la | null | true |
CategoryTheory.GrothendieckTopology.Subcanonical | Mathlib.CategoryTheory.Sites.Canonical | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.GrothendieckTopology C → Prop | A subcanonical topology is a topology which is smaller than the canonical topology.
Equivalently, a topology is subcanonical iff every representable is a sheaf.
| true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.lt_base_pow_length_digits._simp_1_1 | Mathlib.Data.Nat.Digits.Defs | ∀ {b m : ℕ}, (m < (b + 2) ^ ((b + 2).digits m).length) = True | null | false |
Std.TreeSet.max!_eq_iff_mem_and_forall | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst : Inhabited α], t.isEmpty = false → ∀ {km : α}, t.max! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | null | true |
Set.mulIndicator_apply_eq_self._simp_2 | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {s : Set α} {f : α → M} {a : α},
(s.mulIndicator f a = f a) = (a ∉ s → f a = 1) | null | false |
MonotoneOn.Iic | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
MonotoneOn f s → MonotoneOn (fun x => Set.Iic (f x)) s | null | true |
HomologicalComplex.unopEquivalence_inverse | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} (V : Type u_2) [inst : CategoryTheory.Category.{v_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V],
(HomologicalComplex.unopEquivalence V c).inverse = HomologicalComplex.unopInverse V c | null | true |
UnivLE_iff_essSurj | Mathlib.CategoryTheory.UnivLE | UnivLE.{max u v, v} ↔ CategoryTheory.uliftFunctor.{u, v}.EssSurj | null | true |
CategoryTheory.Triangulated.TStructure.ω₁._proof_4 | Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, 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 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.