name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.RevMatchesAt c pos = ∃ (h : pos ≠ s.startPos), (pos.prev h).get ⋯ = c | null | false |
groupHomology.cyclesMap_comp_cyclesIso₀_hom_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑(groupHomology.cycles A 0)),
(CategoryTheory.ConcreteCategory.hom (groupHomology.cyclesIso₀ B).hom)
((CategoryTheory.ConcreteCategory.hom (group... | null | true |
_private.Mathlib.Tactic.SetNotationForOrder.0.Mathlib.Meta.SetNotationForOrder.initFn._@.Mathlib.Tactic.SetNotationForOrder.424660829._hygCtx._hyg.4 | Mathlib.Tactic.SetNotationForOrder | IO (Lean.Option Bool) | null | false |
TopCat.pullbackIsoProdSubtype | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | {X Y Z : TopCat} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
CategoryTheory.Limits.pullback f g ≅
↧{ p // (CategoryTheory.ConcreteCategory.hom f) p.1 = (CategoryTheory.ConcreteCategory.hom g) p.2 } | The pullback of two maps can be identified as a subspace of `X × Y`. | true |
Finset.range_val | Mathlib.Data.Finset.Range | ∀ (n : ℕ), (Finset.range n).val = Multiset.range n | null | true |
SaturatedAddSubmonoid.rec | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} →
[inst : AddZeroClass M] →
{motive : SaturatedAddSubmonoid M → Sort u} →
((toAddSubmonoid : AddSubmonoid M) →
(addSaturated : toAddSubmonoid.AddSaturated) →
motive { toAddSubmonoid := toAddSubmonoid, addSaturated := addSaturated }) →
(t : SaturatedAddSubmonoid M... | null | false |
IsLeftCancelVAdd.mk | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} [inst : VAdd G P],
(∀ (a : G) (b c : P), a +ᵥ b = a +ᵥ c → b = c) → IsLeftCancelVAdd G P | null | true |
AlgebraicIndependent.transcendental_adjoin_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A],
AlgebraicIndependent R x →
∀ [Nontrivial A] {s : Set ι} {i : ι}, Transcendental (↥(Algebra.adjoin R (x '' s))) (x i) ↔ i ∉ s | null | true |
instLocallyConvexSpaceRealOfPolynormableSpace | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {E : Type u_6} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [PolynormableSpace ℝ E],
LocallyConvexSpace ℝ E | A `PolynormableSpace` over `ℝ` is locally convex.
TODO: generalize to `RCLike`. | true |
Finset.le_inf_of_directed_le | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_6} [inst : SemilatticeInf α] [inst_1 : OrderTop α] (s : Set α),
s.Nonempty → DirectedOn (fun x1 x2 => x2 ≤ x1) s → ∀ (t : Finset α), (∀ x ∈ t, ∃ y ∈ s, y ≤ x) → ∃ x ∈ s, x ≤ t.inf id | null | true |
Turing.PartrecToTM2.contSupp.match_1 | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.PartrecToTM2.Cont' → Sort u_1) →
(x : Turing.PartrecToTM2.Cont') →
((fs : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive (Turing.PartrecToTM2.Cont'.cons₁ fs k)) →
((k : Turing.PartrecToTM2.Cont') → motive k.cons₂) →
((f : Turing.ToPartrec.Code) → (k : Turing.Partr... | null | false |
Lean.Server.ServerRequestResponse.success.sizeOf_spec | Lean.Server.Requests | ∀ {α : Type} [inst : SizeOf α] (response : α),
sizeOf (Lean.Server.ServerRequestResponse.success response) = 1 + sizeOf response | null | true |
OrderAddMonoidHom.snd.eq_1 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β], OrderAddMonoidHom.snd α β = { toAddMonoidHom := AddMonoidHom.snd α β, monotone' := ⋯ } | null | true |
_private.Mathlib.RingTheory.Finiteness.Nilpotent.0.Matrix.isNilpotent_iff_forall_row._simp_1_1 | Mathlib.RingTheory.Finiteness.Nilpotent | ∀ {m : Type u_2} {α : Type u_8} [inst : CommSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (M : Matrix m m α)
(k : ℕ), M.transpose ^ k = (M ^ k).transpose | null | false |
Fin.succAbove_ne_last_last | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {a : Fin (n + 2)}, a ≠ Fin.last (n + 1) → a.succAbove (Fin.last n) = Fin.last (n + 1) | null | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.filterComparisons.match_1 | Mathlib.Tactic.Linarith.Preprocessing | (motive : Mathlib.Ineq → Sort u_1) →
(x : Mathlib.Ineq) →
(Unit → motive Mathlib.Ineq.le) → (Unit → motive Mathlib.Ineq.lt) → (Unit → motive Mathlib.Ineq.eq) → motive x | null | false |
_private.Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage.0.Dynamics.dynEntourage_comp_subset._simp_1_3 | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
_private.Lean.Data.Json.Basic.0.Lean.Json.hash' | Lean.Data.Json.Basic | Lean.Json → UInt64 | null | true |
RingQuot.instOne | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → One (RingQuot r) | null | true |
_private.Mathlib.Probability.Kernel.Disintegration.CondCDF.0.ProbabilityTheory.setLIntegral_preCDF_fst._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | false |
CommRingCat.instIsLocalHomCarrierPtWalkingParallelPairEqualizerForkRingHomHomι | Mathlib.Algebra.Category.Ring.Constructions | ∀ {A B : CommRingCat} (f g : A ⟶ B), IsLocalHom (CommRingCat.Hom.hom (CommRingCat.equalizerFork f g).ι) | null | true |
Group.instIsVirtuallyCyclicQuotientSubgroup | Mathlib.GroupTheory.SpecificGroups.VirtuallyCyclic | ∀ {G : Type u_1} [inst : Group G] [Group.IsVirtuallyCyclic G] (N : Subgroup G) [inst_2 : N.Normal],
Group.IsVirtuallyCyclic (G ⧸ N) | Quotients of virtually cyclic groups are virtually cyclic. | true |
_private.Batteries.Data.List.Basic.0.List.takeWhile₂TR.go.match_1.splitter | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → List β → List α → List β → Sort u_3) →
(x : List α) →
(x_1 : List β) →
(x_2 : List α) →
(x_3 : List β) →
((a : α) →
(as : List α) →
(b : β) →
(bs : Lis... | null | true |
Finset.lcm_def | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
{f : β → α}, s.lcm f = (Multiset.map f s.val).lcm | null | true |
binomialSeries_radius_eq_one | Mathlib.Analysis.Analytic.Binomial | ∀ {𝕂 : Type v} [inst : RCLike 𝕂] {𝔸 : Type u} [inst_1 : NormedDivisionRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸] {a : 𝕂},
(∀ (k : ℕ), a ≠ ↑k) → (binomialSeries 𝔸 a).radius = 1 | The radius of convergence of `binomialSeries 𝔸 a` is `1`, when `a` is not natural. | true |
CategoryTheory.yonedaCommRingObj_map_apply | Mathlib.CategoryTheory.Monoidal.Cartesian.Ring | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {R : C} [inst_3 : CategoryTheory.CommRingObj R] {X Y : Cᵒᵖ} (f : X ⟶ Y)
(x : Opposite.unop X ⟶ R),
(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.yoneda... | null | true |
Bool.completeLinearOrder._proof_4 | Mathlib.Data.Fintype.Order | ∀ (a b c : Bool), a ≤ b ⇨ c ↔ min a b ≤ c | null | false |
ULift.seminormedCommRing._proof_10 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b c : ULift.{u_1, u_2} α), (a + b) * c = a * c + b * c | null | false |
Lean.Meta.InfoCacheKey.expr | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → Lean.Expr | The function being cached information about. It is quite often an `Expr.const`. | true |
ProbabilityTheory.cauchyPDFReal | Mathlib.Probability.Distributions.Cauchy | ℝ → NNReal → ℝ → ℝ | The pdf of the cauchy distribution depending on its location `x₀` and scale `γ` parameters. | true |
Choose.choose_modEq_choose_mod_mul_choose_div_nat | Mathlib.Data.Nat.Choose.Lucas | ∀ {n k p : ℕ} [Fact (Nat.Prime p)], n.choose k ≡ (n % p).choose (k % p) * (n / p).choose (k / p) [MOD p] | For primes `p`, `choose n k` is congruent to `choose (n % p) (k % p) * choose (n / p) (k / p)`
modulo `p`. Also see `choose_modEq_choose_mod_mul_choose_div` for the version with `ZMOD`. | true |
MeasureTheory.hasFiniteIntegral_fun_zero._simp_1 | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ (α : Type u_1) {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {ε : Type u_7} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε], MeasureTheory.HasFiniteIntegral (fun x => 0) μ = True | null | false |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity.0.MeasureTheory.eLpNorm'_le_nnreal_smul_eLpNorm'_of_ae_le_mul'._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
Algebra.norm_one_add_smul | Mathlib.RingTheory.NormTrace | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [Module.Free A B]
[Module.Finite A B] (a : A) (x : B), ∃ r, (Algebra.norm A) (1 + a • x) = 1 + (Algebra.trace A B) x * a + r * a ^ 2 | null | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.smoothNumbersUpTo_subset_image._simp_1_1 | Mathlib.NumberTheory.SmoothNumbers | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
RootPairing.pairing_smul_root_eq | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (i j k : ι),
P.reflectionPerm i = P.reflectionPerm j → P.pairing k i • P.root i = P.pairing k j • P.root j | null | true |
ContDiffWithinAt.comp_contMDiffWithinAt | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_6} [inst_6 : NormedAddCommG... | null | true |
Mathlib.Tactic.Determinant.ReifiedBirdDet.noConfusion | Mathlib.Tactic.Determinant.Bird.Meta | {P : Sort u} →
{t t' : Mathlib.Tactic.Determinant.ReifiedBirdDet} →
t = t' → Mathlib.Tactic.Determinant.ReifiedBirdDet.noConfusionType P t t' | null | false |
List.prefix_nil | Init.Data.List.Sublist | ∀ {α : Type u_1} {l : List α}, l <+: [] ↔ l = [] | null | true |
ChartedSpaceCore.open_target | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] (c : ChartedSpaceCore H M) {e : PartialEquiv M H},
e ∈ c.atlas → IsOpen e.target | null | true |
Lean.Compiler.compiler.traceUnnormalized | Lean.Compiler.Options | Lean.Option Bool | null | true |
CircularOrder.recOn | Mathlib.Order.Circular | {α : Type u_1} →
{motive : CircularOrder α → Sort u} →
(t : CircularOrder α) →
([toCircularPartialOrder : CircularPartialOrder α] →
(btw_total : ∀ (a b c : α), btw a b c ∨ btw c b a) →
motive { toCircularPartialOrder := toCircularPartialOrder, btw_total := btw_total }) →
motive... | null | false |
CategoryTheory.ObjectProperty.whiskerLeft_def | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] (X x x_1 : P.FullSubcategory) (f : x ⟶ x_1),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.ObjectProperty.homMk (CategoryTh... | null | true |
_private.Mathlib.Order.Interval.Finset.Floor.0.Nat.cast_mem_Ico_iff._simp_1_2 | Mathlib.Order.Interval.Finset.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : LinearOrder α] [inst_2 : FloorSemiring α] {a : α} {n : ℕ},
(n < ⌈a⌉₊) = (↑n < a) | null | false |
Std.Internal.List.getEntry?_filter_containsKey_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getEntry? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none | null | true |
CategoryTheory.Triangulated.TStructure.instIsLEObjTruncGT | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {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 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
_private.Mathlib.Order.Filter.AtTopBot.BigOperators.0.Function.Injective.map_atTop_finsetProd_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.BigOperators | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
IntermediateField.gi._proof_2 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : IntermediateField F E),
↑S ⊆ ↑(IntermediateField.adjoin F ↑S) | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.visited | Lean.Meta.Tactic.Grind.EMatchAction | Lean.Meta.Grind.Action.CollectState✝ → Std.HashSet Lean.Meta.Sym.ExprPtr | null | true |
_private.Lake.Util.Date.0.Lake.Date.fromJson?.match_1 | Lake.Util.Date | (motive : Option Lake.Date → Sort u_1) →
(x : Option Lake.Date) → ((d : Lake.Date) → motive (some d)) → ((x : Option Lake.Date) → motive x) → motive x | null | false |
NumberField.of_tower | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [NumberField K] [NumberField L]
[inst_4 : Algebra K L] (E : Type u_3) [inst_5 : Field E] [inst_6 : Algebra K E] [inst_7 : Algebra E L]
[IsScalarTower K E L], NumberField E | null | true |
exists_lt_of_lt_csSup' | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α} {a : α}, a < sSup s → ∃ b ∈ s, a < b | null | true |
Ordnode.splitMin_eq | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α),
l.splitMin' x r = (l.findMin' x, (Ordnode.node s l x r).eraseMin) | null | true |
ContinuousMap.setOfIdeal_open | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] [T2Space R] (I : Ideal C(X, R)), IsOpen (ContinuousMap.setOfIdeal I) | null | true |
Lean.Compiler.LCNF.LambdaLifting.State.mk.noConfusion | Lean.Compiler.LCNF.LambdaLifting | {P : Sort u} →
{decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)} →
{nextIdx : ℕ} →
{decls' : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)} →
{nextIdx' : ℕ} →
{ decls := decls, nextIdx := nextIdx } = { decls := decls', nextIdx := nextIdx' } →
... | null | false |
Ultrafilter.mem_pure._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {a : α} {s : Set α}, (s ∈ pure a) = (a ∈ s) | null | false |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.find?_toArray_eq_none_iff_contains_eq_false._simp_1_2 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF →
∀ {k : α}, (List.find? (fun x => x.1 == k) (Std.DHashMap.Raw.Const.toList ↑m) = none) = (m.contains k = false) | null | false |
εNFA.toNFA_evalFrom_match | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} (M : εNFA α σ) (start : Set σ), M.toNFA.evalFrom (M.εClosure start) = M.evalFrom start | null | true |
instUniqueFactorizationMonoidSubtypeMemSubalgebraAdjoinSingletonSetOfFactTranscendental | Mathlib.RingTheory.Adjoin.Polynomial.Transcendental | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {s : S}
[UniqueFactorizationMonoid R] [h : Fact (Transcendental R s)], UniqueFactorizationMonoid ↥R[s] | null | true |
CategoryTheory.Adjunction.counit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (G.comp F ⟶ CategoryTheory.Functor.id D) | The counit of an adjunction | true |
CategoryTheory.exactPairingUnit | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.ExactPairing (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastCpopLayer.go._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {len : ℕ} {w : ℕ} (iterNum idx idx : ℕ), ¬idx < iterNum * w → ¬iterNum * w ≤ idx → False | null | false |
Std.DTreeMap.Raw.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none | null | true |
AlgebraicGeometry.QuasiCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism is "quasi-compact" if the underlying map of topological spaces is, i.e. if the preimages
of quasi-compact open sets are quasi-compact.
| true |
_private.Mathlib.Combinatorics.SetFamily.DualVC.0.Finset.mem_cubeBitSlice_iff | Mathlib.Combinatorics.SetFamily.DualVC | ∀ {α : Type u_1} [inst : DecidableEq α] {n : ℕ} {S : Finset (Finset α)} (cube : (Fin n → Bool) ↪ ↥S) (b : Fin n → Bool)
(k : Fin n), ↑(cube b) ∈ Finset.cubeBitSlice✝ cube k ↔ b k = true | Codeword `(cube b).val` is in `cubeBitSlice cube k` iff `b k = true`. | true |
segment_translate_image | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] (a b c : E), (fun x => a + x) '' segment 𝕜 b c = segment 𝕜 (a + b) (a + c) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State.addIte.match_1 | Std.Sat.AIG.CNF | {aig : Std.Sat.AIG ℕ} →
{cond ifTrue ifFalse : Std.Sat.AIG.Fanin} →
(idx : ℕ) →
(h : idx < aig.decls.size) →
(cnf : Std.Sat.CNF ℕ) →
(cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf) →
(motive : { out // Std.Sat.AIG.toCNF.Cache.IsExtensionBy✝ cache out idx h } → Sort u_1) →
... | null | false |
AddCon.coe_multisetSum | Mathlib.GroupTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (c : AddCon M) (s : Multiset ι) (f : ι → M),
↑(Multiset.map f s).sum = (Multiset.map (fun i => ↑(f i)) s).sum | null | true |
_private.Mathlib.FieldTheory.Minpoly.ConjRootClass.0.ConjRootClass.instFintypeElemCarrierOfNormalOfDecidableEqOfAlgEquiv._simp_2 | Mathlib.FieldTheory.Minpoly.ConjRootClass | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {x y : L},
IsConjRoot K x y = (ConjRootClass.mk K x = ConjRootClass.mk K y) | null | false |
Prod.mk_left_inj | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β}, (a₁, b) = (a₂, b) ↔ a₁ = a₂ | null | true |
Algebra.adjoin_nonUnitalSubalgebra_eq_span | Mathlib.RingTheory.Adjoin.Basic | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(s : NonUnitalSubalgebra R A), Subalgebra.toSubmodule (Algebra.adjoin R ↑s) = R ∙ 1 ⊔ s.toSubmodule | null | true |
AddSubgroup.opEquiv | Mathlib.Algebra.Group.Subgroup.MulOpposite | {G : Type u_1} → [inst : AddGroup G] → AddSubgroup G ≃o AddSubgroup Gᵃᵒᵖ | An additive subgroup `H` of `G` determines an additive subgroup
`H.op` of the opposite additive group `Gᵃᵒᵖ`. | true |
Graph.mem_loopSet | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β} (x : α) (e : β), e ∈ Graph.loopSet x ↔ G.IsLoopAt e x | null | true |
ImportGraph.System.FilePath.Modules.mk | ImportGraph.Util.Modules | System.FilePath → Lean.Name → ImportGraph.System.FilePath.Modules | null | true |
analyticOrderAt_neg | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {z₀ : 𝕜}, analyticOrderAt (-f) z₀ = analyticOrderAt f z₀ | null | true |
Lean.Elab.HoverableInfoPrio.size | Lean.Elab.InfoTree.Util | Lean.Elab.HoverableInfoPrio → ℕ | null | true |
SmoothBumpCovering.apply_ind | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} (fs : SmoothBumpCovering ι I M s) (x : ... | null | true |
Mathlib.Tactic.DeprecateTo.renameTheorem | Mathlib.Tactic.DeprecateTo | Lean.TSyntax `ident → Lean.TSyntax `command → Lean.TSyntax `Lean.Parser.Command.declId × Lean.TSyntax `command | If the input command is a `theorem` or a `lemma`, then it replaces the name of the
resulting declaration with `newName` and it returns the old declaration name and the
command with the new name.
If the input command is neither a `theorem` nor a `lemma`, then it returns
`.missing` and the unchanged command.
| true |
AlgebraicGeometry.Scheme.IdealSheafData.mk.inj | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))}
{map_ideal_basicOpen :
∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (ideal U) =
ideal (X.affin... | null | true |
SimpleGraph.completeBipartiteGraphCongr | Mathlib.Combinatorics.SimpleGraph.Maps | {V₁ : Type u_5} →
{V₂ : Type u_6} →
{W₁ : Type u_7} → {W₂ : Type u_8} → V₁ ≃ V₂ → W₁ ≃ W₂ → completeBipartiteGraph V₁ W₁ ≃g completeBipartiteGraph V₂ W₂ | The isomorphism between `completeBipartiteGraph V₁ W₁` and
`completeBipartiteGraph V₂ W₂` where `V₁ ≃ V₂` and `W₁ ≃ W₂`. | true |
MeasureTheory.charFun_map_smul | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {E : Type u_2} {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E} [inst : SeminormedAddCommGroup E]
[inst_1 : InnerProductSpace ℝ E] [BorelSpace E] (r : ℝ) (t : E),
MeasureTheory.charFun (MeasureTheory.Measure.map (fun x => r • x) μ) t = MeasureTheory.charFun μ (r • t) | null | true |
SSet.S.subcomplex | Mathlib.AlgebraicTopology.SimplicialSet.Simplices | {X : SSet} → X.S → X.Subcomplex | The subcomplex generated by a simplex. | true |
Lean.Elab.OptionInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.OptionInfo} → t = t' → Lean.Elab.OptionInfo.noConfusionType P t t' | null | false |
LowerSet.instMulAction._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : Preorder α], Function.Injective SetLike.coe | null | false |
Cardinal.continuum_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Continuum | ∀ {c : Cardinal.{u}}, (Cardinal.continuum ≤ Cardinal.lift.{v, u} c) = (Cardinal.continuum ≤ c) | null | false |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.d.match_1.eq_4 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (motive : ℤ → ℤ → Sort u_1) (a a_1 : ℕ) (h_1 : (n m : ℕ) → motive (Int.ofNat n) (Int.ofNat m))
(h_2 : (n m : ℕ) → motive (Int.negSucc n) (Int.negSucc m)) (h_3 : Unit → motive (Int.negSucc 0) (Int.ofNat 0))
(h_4 : (a a_2 : ℕ) → motive (Int.ofNat a) (Int.negSucc a_2))
(h_5 : (a a_2 : ℕ) → motive (Int.negSucc a) (... | null | true |
IsUnit.mul | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit a → IsUnit b → IsUnit (a * b) | null | true |
AddHom.prod_map_comap_prod' | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {M' : Type u_5} {N' : Type u_6} [inst_2 : Add M']
[inst_3 : Add N'] (f : M →ₙ+ N) (g : M' →ₙ+ N') (S : AddSubsemigroup N) (S' : AddSubsemigroup N'),
AddSubsemigroup.comap (f.prodMap g) (S.prod S') = (AddSubsemigroup.comap f S).prod (AddSubsemigroup.com... | null | true |
Lean.Lsp.CompletionItem.getFileSource! | Lean.Server.FileSource | Lean.Lsp.CompletionItem → Lean.Lsp.DocumentUri | Yields the file source of `item` by attempting to obtain `mod : Name` from `item.data?`. \
Panics if `item.data?` is not present or does not contain a `mod` field and the first element of a
`data?` array cannot be parsed to `Name`.
Used when `completionItem/resolve` requests pass the watchdog to decide which file worke... | true |
ProbabilityTheory.IndepFun.eq_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {β : Type u_6} {γ : Type u_7} {_mΩ : MeasurableSpace Ω} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.IndepFun f g μ =
ProbabilityTheory.Kernel.IndepFun f g (ProbabilityTheory.Kernel.const Unit μ) (MeasureTheory.... | null | true |
Finset.unop_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddCommMonoid M] (s : Finset ι) (f : ι → Mᵐᵒᵖ),
MulOpposite.unop (∑ x ∈ s, f x) = ∑ x ∈ s, MulOpposite.unop (f x) | null | true |
List.all_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {f : α → Bool} {l : List (List α)}, l.flatten.all f = l.all fun x => x.all f | null | true |
ArithmeticFunction.IsMultiplicative.multiplicative_factorization | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] (f : ArithmeticFunction R),
f.IsMultiplicative → ∀ {n : ℕ}, n ≠ 0 → f n = n.factorization.prod fun p k => f (p ^ k) | For any multiplicative function `f` and any `n > 0`,
we can evaluate `f n` by evaluating `f` at `p ^ k` over the factorization of `n` | true |
Matrix.blockDiagonal_conjTranspose | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} [inst : DecidableEq o] {α : Type u_13} [inst_1 : AddMonoid α]
[inst_2 : StarAddMonoid α] (M : o → Matrix m n α),
(Matrix.blockDiagonal M).conjTranspose = Matrix.blockDiagonal fun k => (M k).conjTranspose | null | true |
Std.DTreeMap.Internal.Impl.WF.inter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] {m₁ m₂ : Std.DTreeMap.Internal.Impl α β},
m₁.WF → (m₁.inter! m₂).WF | null | true |
Batteries.Tactic.CollectOpaques.collect | Batteries.Tactic.PrintOpaques | Lean.Name → Batteries.Tactic.CollectOpaques.M Unit | Collect the results for a given constant. | true |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_3 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
CategoryTheory.IsIso.inv_eq_of_inv_hom_id | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : Y ⟶ X} [inst_1 : CategoryTheory.IsIso f]
{g : X ⟶ Y}, CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id X → CategoryTheory.inv f = g | null | true |
Aesop.OrderedHashSet.ctorIdx | Aesop.Util.OrderedHashSet | {α : Type u_1} → {inst : BEq α} → {inst_1 : Hashable α} → Aesop.OrderedHashSet α → ℕ | null | false |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.rpc.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.