name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.SemanticTokenType.class | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenType | true |
MeasureTheory.integral_coe_le_of_lintegral_coe_le | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → NNReal} {b : NNReal},
∫⁻ (a : α), ↑(f a) ∂μ ≤ ↑b → ∫ (a : α), ↑(f a) ∂μ ≤ ↑b | true |
Quiver.Arborescence.mk._flat_ctor | Mathlib.Combinatorics.Quiver.Arborescence | {V : Type u} → [inst : Quiver V] → (root : V) → ((b : V) → Unique (Quiver.Path root b)) → Quiver.Arborescence V | false |
_private.Mathlib.Data.Setoid.Partition.Card.0.Setoid.IsPartition.ncard_eq_finsum._simp_1_16 | Mathlib.Data.Setoid.Partition.Card | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (a = b) = (↑a = ↑b) | false |
ArithmeticFunction.carmichael_dvd | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {a b : ℕ}, a ∣ b → ArithmeticFunction.Carmichael a ∣ ArithmeticFunction.Carmichael b | true |
Finset.sum_Ico_Ico_comm | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} [inst : AddCommMonoid M] (a b : ℕ) (f : ℕ → ℕ → M),
∑ i ∈ Finset.Ico a b, ∑ j ∈ Finset.Ico i b, f i j = ∑ j ∈ Finset.Ico a b, ∑ i ∈ Finset.Ico a (j + 1), f i j | true |
PowerSeries.derivative_subst | Mathlib.RingTheory.PowerSeries.Derivative | ∀ (A : Type u_1) [inst : CommRing A] {f g : PowerSeries A},
PowerSeries.HasSubst g →
(PowerSeries.derivative A) (PowerSeries.subst g f) =
PowerSeries.subst g ((PowerSeries.derivative A) f) * (PowerSeries.derivative A) g | 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 | false |
GroupNormClass.eq_one_of_map_eq_zero | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : Group α} {inst_1 : AddCommMonoid β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : GroupNormClass F α β] (f : F) {a : α}, f a = 0 → a = 1 | 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) | 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 | 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.map g | 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 | 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), Submodule.span R (Set.range (⇑N.subtype ∘ ⇑b)) = N | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.curriedInverse._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2)
(x : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 })),
(fun {x₀ x₁} e =>
SSet.Truncated.HomotopyCategory.mkNatTrans
(fun y => SSet.Truncated.HomotopyCategory.homMk (e.tensor (SSet.Truncated.Edge.id y))) ⋯)
(SSet.Truncated.Edge.id x) =
CategoryTheory.CategoryStruct.id
((fun x =>
SSet.Truncated.HomotopyCategory.lift (fun y => SSet.Truncated.HomotopyCategory.mk (x, y))
(fun {y₀ y₁} e => SSet.Truncated.HomotopyCategory.homMk ((SSet.Truncated.Edge.id x).tensor e)) ⋯ ⋯)
x) | false |
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) MoritaEquivalence.linear._autoParam),
sizeOf { eqv := eqv, linear := linear } = 1 + sizeOf eqv + sizeOf linear | 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 | 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 : CategoryTheory.Limits.IsColimit { pt := A, ι := ι }) (I_1 : Type v)
(ℐ_1 : CategoryTheory.SmallCategory I_1) (hI_1 : CategoryTheory.IsFiltered I_1) (F_1 : CategoryTheory.Functor I_1 C)
(ι_1 : F_1.comp CategoryTheory.yoneda ⟶ (CategoryTheory.Functor.const I_1).obj A)
(isColimit_1 : CategoryTheory.Limits.IsColimit { pt := A, ι := ι_1 }),
({ I := I, ℐ := ℐ, hI := hI, F := F, ι := ι, isColimit := isColimit } =
{ I := I_1, ℐ := ℐ_1, hI := hI_1, F := F_1, ι := ι_1, isColimit := isColimit_1 }) =
(I = I_1 ∧ ℐ ≍ ℐ_1 ∧ F ≍ F_1 ∧ ι ≍ ι_1 ∧ isColimit ≍ isColimit_1) | true |
Int.ediv_lt_of_lt_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, 0 < c → a < b * c → a / c < b | 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 | false |
Lean.Meta.Grind.Arith.Linear.OfNatModuleM.Context.natStructId | Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule | Lean.Meta.Grind.Arith.Linear.OfNatModuleM.Context → ℕ | true |
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 | 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 | 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 | 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)) | true |
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) | 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) | 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 | 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 | 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 declName eager)) →
((thm : Lean.Meta.Grind.EMatchTheorem) → motive (Lean.Meta.Grind.Entry.ematch thm)) →
((thm : Lean.Meta.Grind.InjectiveTheorem) → motive (Lean.Meta.Grind.Entry.inj thm)) → motive t | false |
exists_exists_and_eq_and._simp_1 | Mathlib.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) | 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)
((fun T =>
((CategoryTheory.Functor.id C).mapTriangle.obj T).isoMk
((CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)).obj T)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₁)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₂)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₃) ⋯ ⋯ ⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun T =>
((CategoryTheory.Functor.id C).mapTriangle.obj T).isoMk
((CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)).obj T)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₁)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₂)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapTriangle.obj T).obj₃) ⋯ ⋯ ⋯)
X).hom
((CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)).map f) | 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 | 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 | 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 | true |
AddMonoidHom.eq_intCastAddHom | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddGroupWithOne A] (f : ℤ →+ A), f 1 = 1 → f = Int.castAddHom A | 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 | true |
Lean.getPPMaxSteps | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → ℕ | 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 | 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 : TopologicalSpace H']
{E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'}
{V : (x : M') → TangentSpace I' x} {n : WithTop ℕ∞} [inst_11 : IsManifold I 2 M] [inst_12 : IsManifold I' 2 M']
[CompleteSpace E],
MDiffAt (T% V) →
ContMDiff I I' n f →
(∀ (x : M), (mfderiv% f x).IsInvertible) → 2 ≤ n → MDiff fun x => ⟨x, VectorField.mpullback I I' f V x⟩ | 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 | false |
AddGroup.FG | Mathlib.GroupTheory.Finiteness | (H : Type u_4) → [AddGroup H] → Prop | true |
finiteness | Mathlib.Tactic.Finiteness | Lean.ParserDescr | true |
Lean.Meta.Grind.Arith.Linear.UnsatProof.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.UnsatProof → ℕ | 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) μ | 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 | 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' : Lean.Meta.RefinedDiscrTree.TrieIndex} →
{treeStars' : Std.HashMap ℕ (List Lean.Meta.RefinedDiscrTree.Key)} →
{ keys := keys, score := score, trie := trie, treeStars := treeStars } =
{ keys := keys', score := score', trie := trie', treeStars := treeStars' } →
(keys = keys' → score = score' → trie = trie' → treeStars = treeStars' → P) → P | 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 | 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 | true |
Aesop.FVarIdSubst.insert | Aesop.RuleTac.FVarIdSubst | Aesop.FVarIdSubst → Lean.FVarId → Lean.FVarId → Aesop.FVarIdSubst | 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) | 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 | 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.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {lo hi : α},
((Std.PRange.succ lo)...Std.PRange.succ hi).toArray = Array.map Std.PRange.succ (lo...hi).toArray | 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 | false |
Lat.instConcreteCategoryLatticeHomCarrier | Mathlib.Order.Category.Lat | CategoryTheory.ConcreteCategory Lat fun x1 x2 => LatticeHom ↑x1 ↑x2 | 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) | 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)) →
(iPending : Array (Lean.Expr × Lean.Expr)) →
(tPending : Array ℕ) →
(us : List Lean.Level) →
(args : Array Lean.Expr) →
motive
{ eAssignment := eAssignment, uAssignment := uAssignment, ePending := ePending,
uPending := uPending, iPending := iPending, tPending := tPending, us := us, args := args }) →
motive t | 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 | 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 : P out with
| true => pure (Std.Shrink.deflate (Std.PlausibleIterStep.skip (Std.IterM.Intermediate.dropWhile P true it') ⋯))
| false =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.yield (Std.IterM.Intermediate.dropWhile P false it') out ⋯))
| ⟨Std.IterStep.skip it', h⟩ =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.skip (Std.IterM.Intermediate.dropWhile P true it') ⋯))
| ⟨Std.IterStep.done, h⟩ => pure (Std.Shrink.deflate (Std.PlausibleIterStep.done ⋯)) | true |
Lean.Doc.MarkdownM.run | Lean.DocString.Markdown | {α : Type} →
Lean.Doc.MarkdownM α → optParam Lean.Doc.MarkdownM.Context { } → optParam Lean.Doc.MarkdownM.State { } → α × String | 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 | true |
_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 | 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' | true |
enorm_ne_top | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} [inst : NNNorm E] {x : E}, ‖x‖ₑ ≠ ⊤ | 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 | 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 |
OrderDual.instMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : Monoid α] (a : αᵒᵈ), 1 * a = a | 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 | 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) | false |
ULift.down_compl | Mathlib.Order.ULift | ∀ {α : Type u} [inst : Compl α] (a : ULift.{u_1, u} α), aᶜ.down = a.downᶜ | 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 | 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 | 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 | 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 | false |
_private.Lean.Elab.DocString.Builtin.Postponed.0.Lean.Doc.Stats.casesOn | Lean.Elab.DocString.Builtin.Postponed | {motive : Lean.Doc.Stats✝ → Sort u} →
(t : Lean.Doc.Stats✝¹) →
((passed : ℕ) → (failed : Array Lean.Exception) → motive { passed := passed, failed := failed }) → motive t | false |
AlgebraicGeometry.Scheme.fullyFaithfulForgetToLocallyRingedSpace._proof_2 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
{ toLRSHom' := AlgebraicGeometry.Scheme.forgetToLocallyRingedSpace.map f } = f | false |
PreconnectedSpace.mk | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α], IsPreconnected Set.univ → PreconnectedSpace α | 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] →
[CategoryTheory.Pretriangulated C] → CategoryTheory.ObjectProperty C → Prop | 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 | true |
AlgebraicGeometry.Scheme.directedAffineCover | Mathlib.AlgebraicGeometry.Cover.Directed | (X : AlgebraicGeometry.Scheme) → X.OpenCover | 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)) → motive x f 0 1)
(h_3 : (x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → (l : ℕ) → motive x f 0 l.succ)
(h_4 : (x : ℕ → C) → (x_1 : (n : ℕ) → x n ⟶ x (n + 1)) → (n : ℕ) → motive x x_1 n.succ 0)
(h_5 : (x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → (k l : ℕ) → motive x f k.succ l.succ),
(match x, f, 0, 1 with
| x, x_1, 0, 0 => h_1 x x_1
| x, f, 0, 1 => h_2 x f
| x, f, 0, l.succ => h_3 x f l
| x, x_1, n.succ, 0 => h_4 x x_1 n
| x, f, k.succ, l.succ => h_5 x f k l) =
h_2 x f | 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 | 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 | 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 | 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 | 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) | false |
Fin.rec.eq._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.356 | Mathlib.Util.CompileInductive | @Fin.rec = @Fin.rec✝ | 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 | 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 : α}, (a ∈ r.toList) = (a ∈ r) | 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_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M)
(a : α), b • v a = (b • v) a | 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 ≠ ⊤) | 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 | true |
IO.Error.interrupted | Init.System.IOError | String → UInt32 → String → IO.Error | 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 | 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} | false |
IO.Error.mkEofError | Init.System.IOError | Unit → IO.Error | 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.CategoryStruct.comp d₂ S.f = 0),
(ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 0 = d₀ | true |
SetRel.isSymm_inv_comp | Mathlib.Data.Rel | ∀ {α : Type u_1} {R : SetRel α α}, (R.inv.comp R).IsSymm | true |
Matrix.single_mul_apply_of_ne | Mathlib.Data.Matrix.Basis | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq l] [inst_1 : DecidableEq m]
[inst_2 : Fintype m] [inst_3 : NonUnitalNonAssocSemiring α] (c : α) (i : l) (j : m) (a : l) (b : n),
a ≠ i → ∀ (M : Matrix m n α), (Matrix.single i j c * M) a b = 0 | true |
Std.HashSet.get!_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∉ m₁ → (m₁ \ m₂).get! k = default | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.