name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PowerSeries.derivative_subst | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] {f g : PowerSeries R},
PowerSeries.HasSubst g →
PowerSeries.derivative (PowerSeries.subst g f) =
PowerSeries.subst g (PowerSeries.derivative f) * PowerSeries.derivative g | null | true |
_private.Aesop.Forward.LevelIndex.0.Aesop.instBEqLevelIndex.beq.match_1 | Aesop.Forward.LevelIndex | (motive : Aesop.LevelIndex → Aesop.LevelIndex → Sort u_1) →
(x x_1 : Aesop.LevelIndex) →
((a b : ℕ) → motive { toNat := a } { toNat := b }) → ((x x_2 : Aesop.LevelIndex) → motive x x_2) → motive x x_1 | null | false |
GroupNormClass.eq_one_of_map_eq_zero | Mathlib.Algebra.Order.Hom.GroupNorm | ∀ {F : Type u_4} {α : outParam (Type u_5)} {β : outParam (Type u_6)} {inst : Group α} {inst_1 : AddCommMonoid β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : GroupNormClass F α β] (f : F) {a : α}, f a = 0 → a = 1 | The argument is one if its image under the map is zero. | true |
Std.Tactic.BVDecide.BVExpr.eval_extract | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {start len a : ℕ} {expr : Std.Tactic.BVDecide.BVExpr a},
Std.Tactic.BVDecide.BVExpr.eval assign (Std.Tactic.BVDecide.BVExpr.extract start len expr) =
BitVec.extractLsb' start len (Std.Tactic.BVDecide.BVExpr.eval assign expr) | null | true |
QuasiconvexOn | Mathlib.Analysis.Convex.Quasiconvex | (𝕜 : Type u_1) →
{E : Type u_2} →
{β : Type u_3} → [Semiring 𝕜] → [PartialOrder 𝕜] → [AddCommMonoid E] → [LE β] → [SMul 𝕜 E] → Set E → (E → β) → Prop | A function is quasiconvex if all its sublevels are convex.
This means that, for all `r`, `{x ∈ s | f x ≤ r}` is `𝕜`-convex. | true |
CategoryTheory.AreEqualizedByLocalization.map_eq | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] {W : CategoryTheory.MorphismProperty C} {X Y : C} {f g : X ⟶ Y},
CategoryTheory.AreEqualizedByLocalization W f g →
∀ (L : CategoryTheory.Functor C D) [L.IsLocalization W], L.map f = L.ma... | null | true |
_private.Mathlib.Topology.Continuous.0.DenseRange.mem_nhds.match_1_1 | Mathlib.Topology.Continuous | ∀ {X : Type u_2} [inst : TopologicalSpace X] {α : Type u_1} {f : α → X} {s : Set X}
(motive : (∃ a, f a ∈ interior s) → Prop) (x : ∃ a, f a ∈ interior s),
(∀ (a : α) (ha : f a ∈ interior s), motive ⋯) → motive x | null | false |
Module.Basis.mkFinCons._proof_1 | Mathlib.LinearAlgebra.Basis.Fin | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {n : ℕ}
{N : Submodule R M} (b : Module.Basis (Fin n) R ↥N), N = Submodule.span R (Set.range (⇑N.subtype ∘ ⇑b)) | null | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.curriedInverse._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2) (x : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 })),
SSet.Truncated.HomotopyCategory.mkNatTrans
(fun y => SSet.Truncated.HomotopyCategory.homMk ((SSet.Truncated.Edge.id x).tensor (SSet.Truncated.Edge.id y)))
⋯ =
CategoryTheory.Category... | null | false |
Std.Time.PlainDate.ofWallTime | Std.Time.DateTime.PlainDateTime | Std.Time.WallTime → Std.Time.PlainDate | Converts a `WallTime` to a `PlainDate`.
| true |
MoritaEquivalence.mk.sizeOf_spec | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B] [inst_5 : SizeOf R] [inst_6 : SizeOf A] [inst_7 : SizeOf B]
(eqv : ModuleCat A ≌ ModuleCat B)
(linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) Mori... | null | true |
ZeroAtInftyContinuousMap.toOnePoint_injective | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : R1Space X] [inst_2 : TopologicalSpace R]
[inst_3 : Zero R], Function.Injective ZeroAtInftyContinuousMap.toOnePoint | null | true |
LinearMap.continuous_of_isClosed_graph | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CompleteSpace E] {F : Type u_5} [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F]
[CompleteSpace F] (g : E →ₗ[𝕜] F), IsClosed ↑g.graph → Continuous ⇑g | The **closed graph theorem** : a linear map between two Banach spaces whose graph is closed
is continuous. | true |
CategoryTheory.Limits.IndObjectPresentation.mk.injEq | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (I : Type v)
[ℐ : CategoryTheory.SmallCategory I] [hI : CategoryTheory.IsFiltered I] (F : CategoryTheory.Functor I C)
(ι : F.comp CategoryTheory.yoneda ⟶ (CategoryTheory.Functor.const I).obj A)
(isColimit : Category... | null | true |
Int.ediv_lt_of_lt_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, 0 < c → a < b * c → a / c < b | null | true |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion._aux_Mathlib_Topology_UniformSpace_AbstractCompletion___macroRules__private_Mathlib_Topology_UniformSpace_AbstractCompletion_0_AbstractCompletion_termHatβ_1_1 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.Macro | null | false |
IsCompactOpenCovered.of_finite_of_isSpectralMap | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)]
[Finite ι] [inst_2 : TopologicalSpace S],
(∀ (i : ι), IsSpectralMap (f i)) →
∀ {U : Set S}, (∀ x ∈ U, ∃ i, x ∈ Set.range (f i)) → IsOpen U → IsCompact U → IsCompactOpenCovered f U | null | true |
NeZero.nat_of_neZero | Mathlib.Data.Nat.Cast.Basic | ∀ {R : Type u_6} {S : Type u_7} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {F : Type u_8}
[inst_2 : FunLike F R S] [RingHomClass F R S] (f : F) {n : ℕ} [hn : NeZero ↑n], NeZero ↑n | null | true |
Ordnode.eraseMax.eq_2 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (size : ℕ) (l : Ordnode α) (x_1 : α), (Ordnode.node size l x_1 Ordnode.nil).eraseMax = l | null | true |
LightProfinite.continuous_iff_convergent | Mathlib.Topology.Category.LightProfinite.Sequence | ∀ {Y : Type u_1} [inst : TopologicalSpace Y] (f : ↑LightProfinite.NatUnionInfty.toTop → Y),
Continuous f ↔ Filter.Tendsto (fun x => f ↑x) Filter.atTop (nhds (f OnePoint.infty)) | null | true |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0.UpperHalfPlane.qExpansion_coeff_eq_intervalIntegral._simp_1_11 | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Finsupp.lex_def | Mathlib.Data.Finsupp.Lex | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N},
Finsupp.Lex r s a b ↔ ∃ j, (∀ (d : α), r d j → a d = b d) ∧ s (a j) (b j) | null | true |
MeasureTheory.tendsto_zero_of_hasDerivAt_of_integrableOn_Iic | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
(∀ x ∈ Set.Iic a, HasDerivAt f (f' x) x) →
MeasureTheory.IntegrableOn f' (Set.Iic a) MeasureTheory.volume →
MeasureTheory.IntegrableOn f (Set.Iic a) MeasureTheory.volume → Filter.Tendsto f Filter.atBot (nhds 0) | If a function and its derivative are integrable on `(-∞, a]`, then the function tends to zero
at `-∞`. | true |
LocallyConstant.coe_smul | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {R : Type u_4} [inst_1 : SMul R Y] (r : R)
(f : LocallyConstant X Y), ⇑(r • f) = r • ⇑f | null | true |
StarAlgHom.continuous_realContinuousMapOfNNReal | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_1} [inst : TopologicalSpace X] {A : Type u_2} [inst_1 : Ring A] [inst_2 : StarRing A]
[inst_3 : Algebra ℝ A] [inst_4 : TopologicalSpace A] [IsSemitopologicalRing A] (φ : C(X, NNReal) →⋆ₐ[NNReal] A),
Continuous ⇑φ → Continuous ⇑φ.realContinuousMapOfNNReal | null | true |
Lean.Meta.Grind.Entry.casesOn | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.Entry → Sort u} →
(t : Lean.Meta.Grind.Entry) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Entry.ext declName)) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Entry.funCC declName)) →
((declName : Lean.Name) → (eager : Bool) → motive (Lean.Meta.Grind.Entry.cases... | null | false |
exists_exists_and_eq_and._simp_1 | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | null | false |
CategoryTheory.Functor.mapTriangleIdIso._proof_8 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id C).mapTriangle.map f)
(((CategoryTheory.Functor.id C).mapTriangle.obj Y).isoMk
... | null | false |
Lake.ToolchainVer._impl.rec | Lake.Util.Version | {motive : Lake.ToolchainVer._impl → Sort u} →
((toString : String) → (ver : Lake.LeanVer) → motive (Lake.ToolchainVer.release._impl toString ver)) →
((toString : String) →
(date : Lake.Date) → (rev : Option ℕ) → motive (Lake.ToolchainVer.nightly._impl toString date rev)) →
((toString : String) → (n ... | null | false |
vieta_formula_quadratic | Mathlib.Algebra.Ring.Basic | ∀ {α : Type u_3} [inst : NonUnitalCommRing α] {b c x : α},
x * x - b * x + c = 0 → ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c | Vieta's formula for a quadratic equation, relating the coefficients of the polynomial with
its roots. This particular version states that if we have a root `x` of a monic quadratic
polynomial, then there is another root `y` such that `x + y` is negative the `a_1` coefficient
and `x * y` is the `a_0` coefficient. | true |
Filter.Germ.instNonAssocRing._proof_4 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {l : Filter α} {R : Type u_1} [inst : NonAssocRing R] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.Context.mk.sizeOf_spec | Lean.Compiler.LCNF.Specialize | ∀ (scope ground underApplied : Lean.FVarIdSet) (declName : Lean.Name),
sizeOf { scope := scope, ground := ground, underApplied := underApplied, declName := declName } =
1 + sizeOf scope + sizeOf ground + sizeOf underApplied + sizeOf declName | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.B._default | Std.Time.Format.Basic | Option Std.Time.ExtendedDayPeriod | null | false |
AddMonoidHom.eq_intCastAddHom | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_4} [inst : AddGroupWithOne A] (f : ℤ →+ A), f 1 = 1 → f = Int.castAddHom A | null | true |
IsLocalization.isLocalization_of_base_ringEquiv | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [IsLocalization M S] (h : R ≃+* P),
IsLocalization (Submonoid.map h M) S | null | true |
Lean.getPPMaxSteps | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → ℕ | null | true |
Std.DHashMap.Const.size_insertManyIfNewUnit_list_le | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} [EquivBEq α] [LawfulHashable α]
{l : List α}, (Std.DHashMap.Const.insertManyIfNewUnit m l).size ≤ m.size + l.length | null | true |
MDifferentiable.mpullback_vectorField | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | The pullback of a differentiable vector field by a `C^n` function with `2 ≤ n` is
differentiable. | true |
_private.Init.Data.List.Nat.Sum.0.List.sum_le_max_mul_length_nat._simp_1_1 | Init.Data.List.Nat.Sum | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | false |
AddGroup.FG | Mathlib.GroupTheory.Finiteness | (G : Type u_3) → [AddGroup G] → Prop | An additive group is finitely generated if it is finitely generated as an additive
subgroup of itself. | true |
Std.Time.WallTime.toDuration | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Duration | Converts a `WallTime` to a `Duration`. The epoch is 1970-01-01 00:00:00 in local
(civil) time, not UTC.
| true |
finiteness | Mathlib.Tactic.Finiteness | Lean.ParserDescr | `finiteness` proves goals of the form `*** < ∞` and (equivalently) `*** ≠ ∞` in the extended
nonnegative reals (`ℝ≥0∞`). If the goal cannot be proven, `finiteness` prints a warning and shows
its intermediate progress.
This tactic is based on `aesop`. It calls `assumption`, `intros`, `positivity`, and any
lemma or rule... | true |
Lean.Meta.Grind.Arith.Linear.UnsatProof.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.UnsatProof → ℕ | null | false |
ZSpan.isAddFundamentalDomain | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (b : Module.Basis ι ℝ E)
[Finite ι] [inst_3 : MeasurableSpace E] [OpensMeasurableSpace E] (μ : MeasureTheory.Measure E),
MeasureTheory.IsAddFundamentalDomain (↥(Submodule.span ℤ (Set.range ⇑b))) (ZSpan.fundamentalDomain b) μ | For a ℤ-lattice `Submodule.span ℤ (Set.range b)`, proves that the set defined
by `ZSpan.fundamentalDomain` is a fundamental domain. | true |
Set.eq_finite_iUnion_of_finite_subset_iUnion | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u} {ι : Type u_1} {s : ι → Set α} {t : Set α},
t.Finite →
t ⊆ ⋃ i, s i →
∃ I, I.Finite ∧ ∃ σ, (∀ (i : ↑{i | i ∈ I}), (σ i).Finite) ∧ (∀ (i : ↑{i | i ∈ I}), σ i ⊆ s ↑i) ∧ t = ⋃ i, σ i | null | true |
MaxTropical.instAddCommMonoidOfOrderBot.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LinearOrder R] [inst_1 : OrderBot R],
MaxTropical.instAddCommMonoidOfOrderBot =
{ toZero := MaxTropical.instZeroOfBot, toAdd := MaxTropical.instAddCommSemigroup.toAdd, add_assoc := ⋯,
zero_add := ⋯, add_zero := ⋯, nsmul := nsmulRec, nsmul_zero := ⋯, nsmul_succ := ⋯, add_comm := ⋯ } | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Lookup.0.Lean.Meta.RefinedDiscrTree.PartialMatch.mk.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Lookup | {P : Sort u} →
{keys : List Lean.Meta.RefinedDiscrTree.Key} →
{score : ℕ} →
{trie : Lean.Meta.RefinedDiscrTree.TrieIndex} →
{treeStars : Std.HashMap ℕ (List Lean.Meta.RefinedDiscrTree.Key)} →
{keys' : List Lean.Meta.RefinedDiscrTree.Key} →
{score' : ℕ} →
{trie' : ... | null | false |
ValuationSubring.comap._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] (A : ValuationSubring L) (f : K →+* L) (k : K),
k ∈ (Subring.comap f A.toSubring).carrier ∨ k⁻¹ ∈ (Subring.comap f A.toSubring).carrier | null | false |
Finset.insert_Ico_succ_left_eq_Ico | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : SuccOrder α] {a b : α},
a < b → insert a (Finset.Ico (Order.succ a) b) = Finset.Ico a b | null | true |
Lean.Core.Context.Cold.openDecls | Lean.CoreM | Lean.Core.Context.Cold → List Lean.OpenDecl | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.0.Equiv.Perm.closure_cycleType_eq_two_two_eq_alternatingGroup._simp_1_1 | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, (a = b) = (↑a = ↑b) | null | false |
HomologicalComplex.instFaithfulGradedObjectForget | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} (V : Type u) [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι), (HomologicalComplex.forget V c).Faithful | null | true |
Std.Rco.toArray_succ_succ_eq_map | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [DecidableLE α] [inst_2 : LT α] [inst_3 : DecidableLT α]
[inst_4 : Std.PRange.UpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst : Std.PRange.InfinitelyUpwardEnumerable α] [inst_6 : Std.Rxo.... | null | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToTerm.toTerm.match_1 | Lean.Elab.Do.Legacy | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) →
((ref : Lean.Syntax) → motive (some ref)) → ((x : Option Lean.Syntax) → motive x) → motive x | null | false |
Lat.instConcreteCategoryLatticeHomCarrier | Mathlib.Order.Category.Lat | CategoryTheory.ConcreteCategory Lat fun x1 x2 => LatticeHom ↑x1 ↑x2 | null | true |
TrivSqZeroExt.inl_mul_inr | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : MonoidWithZero R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
[inst_3 : DistribMulAction Rᵐᵒᵖ M] (r : R) (m : M),
TrivSqZeroExt.inl r * TrivSqZeroExt.inr m = TrivSqZeroExt.inr (r • m) | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.casesOn | Lean.Meta.Sym.Pattern | {motive : Lean.Meta.Sym.UnifyM.State✝ → Sort u} →
(t : Lean.Meta.Sym.UnifyM.State✝) →
((eAssignment : Array (Option Lean.Expr)) →
(uAssignment : Array (Option Lean.Level)) →
(ePending : Array (Lean.Expr × Lean.Expr)) →
(uPending : Array (Lean.Level × Lean.Level)) →
(iPe... | null | false |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Finset.memberSubfamily_image_insert._simp_1_1 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
Std.IterM.step_dropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool},
(Std.IterM.dropWhile P it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ =>
match hP ... | null | true |
CategoryTheory.initial_fst | Mathlib.CategoryTheory.Limits.Final.Connected | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
[CategoryTheory.IsConnected D], (CategoryTheory.Prod.fst C D).Initial | null | true |
Lean.Elab.Tactic.TacticParsedSnapshot._sizeOf_6_eq | Lean.Elab.Term.TermElabM | ∀ (x : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)),
Lean.Elab.Tactic.TacticParsedSnapshot._sizeOf_6 x = sizeOf x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_umod._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x : BitVec (w + 1)} {y : BitVec (w + 1)}, 2 ^ w ≤ y.toNat → ¬0 < y.toNat → False | null | false |
CoxeterMatrix.relation.eq_1 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (M : CoxeterMatrix B) (i i' : B), M.relation i i' = (FreeGroup.of i * FreeGroup.of i') ^ M.M i i' | null | true |
enorm_ne_top | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_4} [inst : NNNorm E] {x : E}, ‖x‖ₑ ≠ ⊤ | null | true |
StateTransition.Reaches₀.tail | Mathlib.Computability.StateTransition | ∀ {σ : Type u_1} {f : σ → Option σ} {a b c : σ},
StateTransition.Reaches₀ f a b → c ∈ f b → StateTransition.Reaches₀ f a c | null | true |
_private.Lean.Util.Diff.0.Lean.Diff.diff._proof_1 | Lean.Util.Diff | ∀ {α : Type} (original edited : Array α), ¬¬0 < original.size → ¬original.size > 0 → False | null | false |
OrderDual.instMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Monoid α] (a b c : αᵒᵈ), a * b * c = a * (b * c) | null | false |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.throwCasesException.match_1 | Lean.Meta.Match.Match | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((x : Lean.Exception) → motive x) → motive ex | null | false |
_private.Mathlib.LinearAlgebra.Matrix.SchurComplement.0.Matrix.isUnit_fromBlocks_zero₁₂._simp_1_1 | Mathlib.LinearAlgebra.Matrix.SchurComplement | ∀ {α : Type u} [inst : Monoid α] (a : α), IsUnit a = Nonempty (Invertible a) | null | false |
ULift.down_compl | Mathlib.Order.ULift | ∀ {α : Type u} [inst : Compl α] (a : ULift.{u_1, u} α), aᶜ.down = a.downᶜ | null | true |
Function.Injective.existsUnique_of_mem_range | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {b : β}, b ∈ Set.range f → ∃! a, f a = b | **Alias** of the forward direction of `Function.Injective.mem_range_iff_existsUnique`. | true |
Filter.exists_eventuallyEq_const_of_forall_separating | Mathlib.Order.Filter.CountableSeparatingOn | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f : α → β} [Nonempty β] (p : Set β → Prop)
[HasCountableSeparatingOn β p Set.univ],
(∀ (U : Set β), p U → (∀ᶠ (x : α) in l, f x ∈ U) ∨ ∀ᶠ (x : α) in l, f x ∉ U) → ∃ a, f =ᶠ[l] Function.const α a | null | true |
_private.Lean.Compiler.ExternAttr.0.Lean.instBEqExternEntry.beq._sparseCasesOn_2 | Lean.Compiler.ExternAttr | {motive : Lean.ExternEntry → Sort u} →
(t : Lean.ExternEntry) →
((backend : Lean.Name) → (pattern : String) → motive (Lean.ExternEntry.inline backend pattern)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instBEqAuxDeclCacheKey.beq._proof_1 | Lean.Compiler.LCNF.AuxDeclCache | ∀ (a b : Lean.Compiler.LCNF.Purity), (a == b) = true → a = b | null | false |
_private.Mathlib.Analysis.Asymptotics.Prod.0.Asymptotics.IsLittleO.comp_snd._simp_1_1 | Mathlib.Analysis.Asymptotics.Prod | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {f : α → E} {g : α → F} {l : Filter α} [inst : Norm E] [inst_1 : Norm F],
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | null | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.CWComplex.OfDiscreteClosed._simp_7 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.add_divByMonic_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {q : Polynomial R} (p₁ p₂ : Polynomial R),
(p₁ + p₂) /ₘ q = p₁ /ₘ q + p₂ /ₘ q ∧ (p₁ + p₂) %ₘ q = p₁ %ₘ q + p₂ %ₘ q | null | true |
AlgebraicGeometry.Scheme.fullyFaithfulForgetToLocallyRingedSpace._proof_2 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
{ toLRSHom' := AlgebraicGeometry.Scheme.forgetToLocallyRingedSpace.map f } = f | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.MonoidHom.isMulCommutative_of_isCyclic_of_ker_le_center._simp_1_11 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ n * a = a ^ (n + 1) | null | false |
PreconnectedSpace.mk | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α], IsPreconnected Set.univ → PreconnectedSpace α | null | true |
CategoryTheory.ObjectProperty.IsTriangulatedClosed₃ | Mathlib.CategoryTheory.Triangulated.Subcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[CategoryThe... | Given `P : ObjectProperty C` with `C` a pretriangulated category, this
is the property that whenever `X₁ ⟶ X₂ ⟶ X₃ ⟶ X₁⟦1⟧` is a distinguished triangle
such that `P X₁` and `P X₂` hold, then `P.isoClosure X₃` holds. | true |
AddSubmonoid.mem_centralizer_iff | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ {M : Type u_1} {S : Set M} [inst : AddMonoid M] {z : M}, z ∈ AddSubmonoid.centralizer S ↔ ∀ g ∈ S, g + z = z + g | null | true |
AlgebraicGeometry.Scheme.directedAffineCover | Mathlib.AlgebraicGeometry.Cover.Directed | (X : AlgebraicGeometry.Scheme) → X.OpenCover | The directed affine open cover of `X` given by all affine opens. | true |
_private.Mathlib.CategoryTheory.Functor.OfSequence.0.CategoryTheory.Functor.OfSequence.map.match_3.eq_2 | Mathlib.CategoryTheory.Functor.OfSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(motive : (x : ℕ → C) → ((n : ℕ) → x n ⟶ x (n + 1)) → ℕ → ℕ → Sort u_3) (x : ℕ → C) (f : (n : ℕ) → x n ⟶ x (n + 1))
(h_1 : (x : ℕ → C) → (x_1 : (n : ℕ) → x n ⟶ x (n + 1)) → motive x x_1 0 0)
(h_2 : (x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → motiv... | null | true |
Std.DHashMap.Const.get!_eq_default_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {a : α}, m.contains a = false → Std.DHashMap.Const.get! m a = default | null | true |
exteriorPower.presentation.Rels.add.sizeOf_spec | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} {ι : Type u_4} {M : Type u_5} [inst : SizeOf R] [inst_1 : SizeOf ι] [inst_2 : SizeOf M] (m : ι → M)
(i : ι) (x y : M), sizeOf (exteriorPower.presentation.Rels.add m i x y) = 1 + sizeOf i + sizeOf x + sizeOf y | null | true |
_private.Init.Data.List.Nat.Modify.0.List.eraseIdx_modify_of_lt._proof_1_4 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α) (k : ℕ), ¬i - 1 = k → i = k + 1 → False | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_map | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w} [Std.TransOrd α]
{f : (a : α) → β a → γ a} {k fallback : α},
t.WF → (Std.DTreeMap.Internal.Impl.map f t).getKeyD k fallback = t.getKeyD k fallback | null | true |
CategoryTheory.MorphismProperty.RightFraction.map._proof_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(φ : W.RightFraction X Y) (L : CategoryTheory.Functor C D), W.IsInvertedBy L → CategoryTheory.IsIso (L.map φ.s) | null | false |
_private.Mathlib.Data.Num.ZNum.0.PosNum.divMod.match_3.eq_2 | Mathlib.Data.Num.ZNum | ∀ (motive : PosNum → Sort u_1) (n : PosNum) (h_1 : (n : PosNum) → motive n.bit0) (h_2 : (n : PosNum) → motive n.bit1)
(h_3 : Unit → motive PosNum.one),
(match n.bit1 with
| n.bit0 => h_1 n
| n.bit1 => h_2 n
| PosNum.one => h_3 ()) =
h_2 n | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.toList_succ_eq_map._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α] {a : ... | null | false |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.tfae_equational_criterion._simp_1_9 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_4} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M)
(a : α), b • v a = (b • v) a | null | false |
_private.Mathlib.MeasureTheory.Function.ContinuousMapDense.0.MeasureTheory.exists_continuous_eLpNorm_sub_le_of_closed._simp_1_2 | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) | null | false |
Ideal.Filtration.submodule_closure_single | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
(F : I.Filtration M), AddSubmonoid.closure (⋃ i, PolynomialModule.single R i '' ↑(F.N i)) = F.submodule.toAddSubmonoid | null | true |
IO.Error.interrupted | Init.System.IOError | String → UInt32 → String → IO.Error | The operation was interrupted.
This corresponds to the POSIX error `EINTR`.
| true |
Finset.decidableForallOfDecidableSubsets'._proof_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {s : Finset α} {p : Finset α → Prop}, (∀ t ⊆ s, p t) ↔ ∀ t ⊆ s, p t | null | false |
Set.Icc._to_dual_cast_1 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), Set.Icc a b = {x | a ≤ x ∧ x ≤ b} | null | false |
ContinuousGeneratedByCat.toTopCat_obj | Mathlib.Topology.Convenient.Category | ∀ {ι : Type t} (X : ι → Type u) [inst : (i : ι) → TopologicalSpace (X i)] (Y : ContinuousGeneratedByCat X),
(ContinuousGeneratedByCat.toTopCat X).obj Y = ↧(Topology.WithGeneratedByTopology X ↑Y) | null | true |
IO.Error.mkEofError | Init.System.IOError | Unit → IO.Error | null | true |
ChainComplex.mk_d_1_0 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(X₀ X₁ X₂ : V) (d₀ : X₁ ⟶ X₀) (d₁ : X₂ ⟶ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0)
(succ :
(S : CategoryTheory.ShortComplex V) →
(X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' CategoryTheory.Category... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.