name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.mul_adjp_apply_ne | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R] (A : Matrix n n R)
(i j : n), i ≠ j → (A * Matrix.adjp 1 A) i j = (A * Matrix.adjp (-1) A) i j | null | true |
isFiniteLength_iff_isNoetherian_isArtinian | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsFiniteLength R M ↔ IsNoetherian R M ∧ IsArtinian R M | null | true |
continuousAt_id' | Mathlib.Topology.Continuous | ∀ {X : Type u_1} [inst : TopologicalSpace X] (y : X), ContinuousAt (fun x => x) y | null | true |
Mathlib.Tactic.ClickSuggestions.instLTResult | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} → [Ord α] → LT (Mathlib.Tactic.ClickSuggestions.Result α) | null | true |
CategoryTheory.Functor.FullyFaithful.id._proof_2 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y),
(CategoryTheory.Functor.id C).map f = f | null | false |
HomotopicalAlgebra.Cylinder.instIsGoodTrans | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {A : C}
[inst_2 : HomotopicalAlgebra.IsCofibrant A] (P P' : HomotopicalAlgebra.Cylinder A) [P.IsGood] [inst_4 : P'.IsGood],
(P.trans P').IsGood | null | true |
LieIdeal.mem_map_of_surjective | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L} {y : L'},
Function.Surjective ⇑f → y ∈ LieIdeal.map f I → ∃ x, f ↑x = y | null | true |
ProbabilityTheory.stieltjesOfMeasurableRat | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | {α : Type u_1} → [inst : MeasurableSpace α] → (f : α → ℚ → ℝ) → Measurable f → α → StieltjesFunction ℝ | Turn a measurable function `f : α → ℚ → ℝ` into a measurable function `α → StieltjesFunction ℝ`.
Composition of `toRatCDF` and `IsMeasurableRatCDF.stieltjesFunction`. | true |
Complex.I_mul_re | Mathlib.Basic.Complex.Basic | ∀ (z : ℂ), (Complex.I * z).re = -z.im | null | true |
withPtrAddr | Init.Util | {α : Type u} → {β : Type v} → α → (k : USize → β) → (∀ (u₁ u₂ : USize), k u₁ = k u₂) → β | null | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Datatypes.0.Mathlib.Tactic.BicategoryLike.Mor₂Iso.e.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | (motive : Mathlib.Tactic.BicategoryLike.Mor₂Iso → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
((α : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
motive (Mathlib.Tactic.BicategoryLike.Mor₂Iso.structuralAtom α)) →
((e : Lean.Expr) →
(f g h : Mathlib.Tactic.BicategoryLike.Mor... | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.variation_vectorMeasure_Ioi._simp_1_7 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a | null | false |
Set.WellFoundedOn.union | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s t : Set α},
s.WellFoundedOn r → t.WellFoundedOn r → (s ∪ t).WellFoundedOn r | null | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.processNextEq._sparseCasesOn_10 | Lean.Meta.Match.SimpH | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Turing.PartrecToTM2.Cont'.comp.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Cont' → Sort u} →
(t : Turing.PartrecToTM2.Cont') →
t.ctorIdx = 3 →
((a : Turing.ToPartrec.Code) →
(a_1 : Turing.PartrecToTM2.Cont') → motive (Turing.PartrecToTM2.Cont'.comp a a_1)) →
motive t | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_insert_self._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.Sheaf.coneΓ | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
[inst_2 : CategoryTheory.HasWeakSheafify J A] →
[CategoryTheory.HasGlobalSectionsFunctor J A] →
... | The cone over a given sheaf whose cone point is the global sections and whose components are
the restriction maps. | true |
Ideal.IsDecompositionRing | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | {B : Type u_1} →
[inst : CommRing B] →
(G : Type u_2) →
[inst_1 : Group G] →
[MulSemiringAction G B] → Ideal B → (R : Type u_3) → [inst_3 : CommRing R] → [Algebra R B] → Prop | `P.IsDecompositionRing G R` states that the intermediate ring `R` of `B` is a *decomposition
ring* of the prime `P`: the ring `B` is Galois over `R` with Galois group the *decomposition group*
of `P`, that is the stabilizer of `P` under the action of `G`.
This is the ring-level characteristic predicate; the classical ... | true |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.fundSystem_mk._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e y = x) = (y = e.symm x) | null | false |
ProbabilityTheory.Kernel.lintegral_deterministic | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : β → ENNReal} {g : α → β} {a : α}
(hg : Measurable g) [MeasurableSingletonClass β],
∫⁻ (x : β), f x ∂(ProbabilityTheory.Kernel.deterministic g hg) a = f (g a) | null | true |
Std.Http.Status.imUsed.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} → (t : Std.Http.Status) → t.ctorIdx = 13 → motive Std.Http.Status.imUsed → motive t | null | false |
SimpleGraph.card_edgeFinset_turanGraph_add | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r : ℕ}, SimpleGraph.turanNumber (n + r) r = SimpleGraph.turanNumber n r + n * (r - 1) + r.choose 2 | **Alias** of `SimpleGraph.turanNumber_add`. | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C} {Z : C}
(h : CategoryTheory.Arrow.rightFunc.obj f ⟶ Z),
CategoryTheory.CategoryStruct.comp (data.i.app f) (CategoryTheory.CategoryStruc... | null | true |
_private.Std.Sat.CNF.Entails.0.Std.Sat.CNF.unsat_of_entails_unsat._simp_1_1 | Std.Sat.CNF.Entails | ∀ {α : Type u_1} {f : Std.Sat.CNF α}, f.Unsat = ∀ (a : α → Bool), ¬Std.Sat.CNF.Sat a f | null | false |
_private.Mathlib.Data.Fin.VecNotation.0.Matrix.vecAlt0_vecAppend._proof_1_4 | Mathlib.Data.Fin.VecNotation | ∀ {n : ℕ} (i : Fin n), n ≤ ↑i + ↑i → ↑i + ↑i - n < n | null | false |
NonUnitalSubsemiring.centralizer._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (s : Set R), 0 ∈ s.centralizer | null | false |
Subtype.instLocallyFiniteOrder._proof_5 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] (p : α → Prop) [inst_1 : DecidablePred p] [inst_2 : LocallyFiniteOrder α]
(a b x : Subtype p), x ∈ Finset.subtype p (Finset.Ico ↑a ↑b) ↔ a ≤ x ∧ x < b | null | false |
AlgEquiv.ofLinearEquiv._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_3} {A₁ : Type u_1} {A₂ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (l : A₁ ≃ₗ[R] A₂), Function.LeftInverse l.invFun (↑l).toFun | null | false |
Std.DTreeMap.toList_roc._auto_1 | Std.Data.DTreeMap.Slice | Lean.Syntax | null | false |
_private.Mathlib.Order.Antichain.0.«term_≺_» | Mathlib.Order.Antichain | Lean.TrailingParserDescr | A function `a` is strongly less than a function `b` if `a i < b i` for all `i`. | true |
BoxIntegral.Prepartition.iUnion_ofWithBot | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (boxes : Finset (WithBot (BoxIntegral.Box ι)))
(le_of_mem : ∀ J ∈ boxes, J ≤ ↑I) (pairwise_disjoint : (↑boxes).Pairwise Disjoint),
(BoxIntegral.Prepartition.ofWithBot boxes le_of_mem pairwise_disjoint).iUnion = ⋃ J ∈ boxes, ↑J | null | true |
SimpleGraph.Walk.IsTrail.isPath_iff_isSubwalk_imp_not_isCycle | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
p.IsTrail → (p.IsPath ↔ ∀ (v_1 : V) (w : G.Walk v_1 v_1), w.IsSubwalk p → ¬w.IsCycle) | null | true |
MeasureTheory.Measure.eqOn_Icc_of_ae_eq | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : LinearOrder X] [OrderTopology X]
{m : MeasurableSpace X} [inst_3 : TopologicalSpace Y] [T2Space Y] (μ : MeasureTheory.Measure X) [μ.IsOpenPosMeasure]
[DenselyOrdered X] {a b : X},
a ≠ b →
∀ {f g : X → Y},
f =ᵐ[μ.restrict (Set.Icc a b)... | null | true |
Complex.summable_ofReal._simp_1 | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_1} {L : SummationFilter α} {f : α → ℝ}, Summable (fun x => ↑(f x)) L = Summable f L | null | false |
Group.fg_iff_subgroup_fg._simp_2 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (H : Subgroup G), Group.FG ↥H = H.FG | null | false |
AddSubmonoid.isOpen_addUnits | Mathlib.Topology.Algebra.Group.Units | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] {U : AddSubmonoid M}, IsOpen ↑U → IsOpen ↑U.addUnits | If a submonoid is open in a topological additive monoid,
then its additive units form an open subset of the additive units of the monoid. | true |
BitVec.ofBoolListBE | Init.Data.BitVec.Basic | (bs : List Bool) → BitVec bs.length | Converts a list of `Bool`s into a big-endian `BitVec`. | true |
ZFSet.IsOrdinal.subset_iff_eq_or_mem | Mathlib.SetTheory.ZFC.Ordinal | ∀ {x y : ZFSet.{u}}, x.IsOrdinal → y.IsOrdinal → (x ⊆ y ↔ x = y ∨ x ∈ y) | null | true |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go.eq_def | Init.Data.Array.BasicAux | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ)
(acc : { bs // bs.size = i }) (hle : i ≤ as.size),
Array.mapM'.go✝ f as i acc hle =
if h : i = as.size then pure (h ▸ acc)
else
have hlt := ⋯;
do
let b ← f as[i]
Array.mapM... | null | true |
instCountableFreeMonoid | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeMonoid α) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions.0.SimpleGraph.cycleGraph.tricoloring._simp_14 | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | ∀ {a : Prop}, (¬a ↔ a) = False | null | false |
_private.Aesop.Saturate.0.Aesop.saturateCore.runRule | Aesop.Saturate | {α : Type} →
Lean.MVarId →
Aesop.UnorderedArraySet Lean.MVarId →
Lean.Meta.SavedState →
Aesop.IndexMatchResult (Aesop.Rule α) →
Aesop.SaturateM (Option (Aesop.GoalDiff × Option (Array Aesop.Script.LazyStep))) | null | true |
Pi.nonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), a * 1 = a | null | false |
_private.Mathlib.Combinatorics.Enumerative.DyckWord.0.DyckWord.IsNested.nest._proof_1_3 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, ∀ i < 1 + (↑p).length + 1, i ≤ (↑p).length + 1 | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_minKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.minKey! fallback = t.minKey! | null | true |
Graph.IsLoopAt.eq_of_inc | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, G.IsLoopAt e x → G.Inc e y → x = y | null | true |
_private.Mathlib.Data.Multiset.Powerset.0.Multiset.bind_powerset_len._simp_1_2 | Mathlib.Data.Multiset.Powerset | ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} {f : β → γ} {g : α → List β} {l : List α},
List.flatMap (fun a => List.map f (g a)) l = List.map f (List.flatMap g l) | null | false |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence.0.Mathlib.Tactic.Bicategory.«term_▷_» | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | Lean.TrailingParserDescr | null | true |
Action.FunctorCategoryEquivalence.functor_μ | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] (G : Type u_2) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] (A B : Action V G),
CategoryTheory.Functor.LaxMonoidal.μ Action.FunctorCategoryEquivalence.functor A B =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalC... | null | true |
Bimod.RightUnitorBimod.hom._proof_2 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[CategoryTheory.Limits.HasCoequalizers C] {R S : CategoryTheory.Mon C} (P : Bimod R S),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.parallelPair
(CategoryTheory.MonoidalCategoryStruct.wh... | null | false |
RCLike.sqrt_of_nonneg | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {a : 𝕜}, 0 ≤ a → RCLike.sqrt a = ↑√(RCLike.re a) | null | true |
Lean.Lsp.SignatureHelpParams.toTextDocumentPositionParams | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpParams → Lean.Lsp.TextDocumentPositionParams | null | true |
MvPowerSeries.instAddGroup | Mathlib.RingTheory.MvPowerSeries.Basic | {σ : Type u_1} → {R : Type u_2} → [AddGroup R] → AddGroup (MvPowerSeries σ R) | null | true |
Finset.HasAntidiagonal.swap_mem_antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} [inst : AddCommMagma A] [inst_1 : Finset.HasAntidiagonal A] {n : A} {xy : A × A},
xy.swap ∈ Finset.HasAntidiagonal.antidiagonal n ↔ xy ∈ Finset.HasAntidiagonal.antidiagonal n | null | true |
PartialHomeomorph.map_target | Mathlib.Topology.PartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialHomeomorph X Y)
{x : Y}, x ∈ e.target → ↑e.symm x ∈ e.source | null | true |
OrderHom.antisymmetrization._proof_1 | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β)
(a b : Antisymmetrization α fun x1 x2 => x1 ≤ x2), a ≤ b → Quotient.map' ⇑f ⋯ a ≤ Quotient.map' ⇑f ⋯ b | null | false |
String.Slice.Pos.offset_cast | Init.Data.String.Basic | ∀ {s t : String.Slice} {pos : s.Pos} {h : s.copy = t.copy}, (pos.cast h).offset = pos.offset | null | true |
MeasureTheory.QuasiMeasurePreserving.casesOn | Mathlib.MeasureTheory.Measure.QuasiMeasurePreserving | {α : Type u_1} →
{β : Type u_2} →
{mβ : MeasurableSpace β} →
{m0 : MeasurableSpace α} →
{f : α → β} →
{μa : MeasureTheory.Measure α} →
{μb : MeasureTheory.Measure β} →
{motive : MeasureTheory.QuasiMeasurePreserving f μa μb → Sort u} →
(t : MeasureT... | null | false |
Lean.MonadRecDepth.getMaxRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ | null | true |
Aesop.UnsafeRuleInfo.casesOn | Aesop.Rule | {motive : Aesop.UnsafeRuleInfo → Sort u} →
(t : Aesop.UnsafeRuleInfo) →
((successProbability : Aesop.Percent) → motive { successProbability := successProbability }) → motive t | null | false |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParams.Info.format.match_1 | Lean.Elab.PreDefinition.FixedParams | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → (Unit → motive none) → ((idx : ℕ) → motive (some idx)) → motive x | null | false |
Matroid.isBase_restrict_iff._auto_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Syntax | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_diff_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
IsEmpty.toEncodable | Mathlib.Logic.Encodable.Basic | {α : Type u_1} → [IsEmpty α] → Encodable α | null | true |
MvPolynomial.esymmAlgHomMonomial | Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | (σ : Type u_1) → {R : Type u_3} → {n : ℕ} → [inst : CommSemiring R] → [Fintype σ] → (Fin n →₀ ℕ) → R → MvPolynomial σ R | The image of a monomial under `esymmAlgHom`. | true |
Std.ExtDTreeMap.size_filter_eq_size_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Bool},
(Std.ExtDTreeMap.filter f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), f k (t.get k h) = true | null | true |
Set.fintypeInsertOfMem._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {a : α} (s : Set α) [inst : Fintype ↑s], a ∈ s → ∀ (x : α), x ∈ s.toFinset ↔ x ∈ insert a s | null | false |
UInt16.instLawfulEqOrd | Init.Data.Ord.UInt | Std.LawfulEqOrd UInt16 | null | true |
Lean.Meta.isPropQuick._unsafe_rec | Lean.Meta.InferType | Lean.Expr → Lean.MetaM Lean.LBool | null | false |
MeasureTheory.volume_preserving_funUnique | Mathlib.MeasureTheory.Constructions.Pi | ∀ (α : Type u) (β : Type v) [inst : Unique α] [inst_1 : MeasureTheory.MeasureSpace β],
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.funUnique α β)) MeasureTheory.volume MeasureTheory.volume | null | true |
CategoryTheory.Functor.id._proof_1 | Mathlib.CategoryTheory.Functor.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.id X = CategoryTheory.CategoryStruct.id X | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Bessel.0.Complex.analyticAt_besselJ_int._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Bessel | ∀ (a : ℤ), ¬(-1) ^ a = 0 | null | false |
SchwartzMap.instContinuousSMul | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F], ContinuousSMul 𝕜 (SchwartzMap E F) | null | true |
Std.Http.Protocol.H1.Machine.forcedFlush | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → Bool | Whether a forced flush has been requested by the user.
| true |
CochainComplex.mappingConeCompTriangle._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.id X₃) =
CategoryTheory.CategoryStruct.co... | null | false |
RootPairing.GeckConstruction.equivLieAlgebra._proof_14 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] [inst_2 : IsAlgClosed K] {L : Type u_2} [inst_3 : LieRing L]
[inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] [inst_6 : LieAlgebra.IsSimple K L] (H : LieSubalgebra K L)
[inst_7 : H.IsCartanSubalgebra] (b : (LieAlgebra.IsKilling.rootSystem H).Base),
... | null | false |
Lean.Meta.Grind.markTheoremInstance | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.GoalM Bool | A helper function used to mark a theorem instance found by the E-matching module.
It returns `true` if it is a new instance and `false` otherwise.
| true |
Int.ceil_ofNat | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] (n : ℕ) [inst_3 : n.AtLeastTwo],
⌈OfNat.ofNat n⌉ = OfNat.ofNat n | null | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorIdIso | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) →
{ι : Type t} →
(S : C) →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
CategoryTheory.Pseudofunctor.DescentData.pullFu... | The functor `F.DescentData f ⥤ F.DescentData f` corresponding to `pullFunctor`
applied to identity morphisms is isomorphic to the identity functor. | true |
ProbabilityTheory.Kernel.iIndepFun.indepFun_prodMk₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
{m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), AEMeasurabl... | null | true |
MeasureTheory.Measure.liftLinear | Mathlib.MeasureTheory.Measure.Map | {α : Type u_1} →
{β : Type u_2} →
{mα : MeasurableSpace α} →
[inst : MeasurableSpace β] →
(f : MeasureTheory.OuterMeasure α →ₗ[ENNReal] MeasureTheory.OuterMeasure β) →
(∀ (μ : MeasureTheory.Measure α), inst ≤ (f μ.toOuterMeasure).caratheodory) →
MeasureTheory.Measure α →ₗ[ENNRe... | Lift a linear map between `OuterMeasure` spaces such that for each measure `μ` every measurable
set is Carathéodory-measurable w.r.t. `f μ` to a linear map between `Measure` spaces. | true |
CategoryTheory.Sum.inr_._proof_2 | Mathlib.CategoryTheory.Sums.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
{ down := CategoryTheory.CategoryStruct.comp f g } = CategoryTheory.CategoryStruct.comp { down := f } { down := g } | null | false |
Finpartition.isEquipartition_iff_card_parts_eq_average | Mathlib.Order.Partition.Equipartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s),
P.IsEquipartition ↔ ∀ a ∈ P.parts, a.card = s.card / P.parts.card ∨ a.card = s.card / P.parts.card + 1 | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} (n : ℕ),
Fintype.card { c // (↑c).support.card = n } = Multiset.count n σ.cycleType | null | false |
Std.DHashMap.Raw.contains_insert | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a k : α} {v : β k}, (m.insert k v).contains a = (k == a || m.contains a) | null | true |
Lean.Elab.Command.instInhabitedCommandElabM | Lean.Elab.Command | {α : Type} → Inhabited (Lean.Elab.Command.CommandElabM α) | null | true |
PresheafOfModules.Hom.naturality_assoc | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (self : M₁.Hom M₂) {X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : ModuleCat ↑(R.obj X)}
(h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M₂.obj Y) ⟶ Z),
CategoryTheory.CategoryStruct.c... | null | true |
AddSubgroup.toAddSubmonoid_zmultiples | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (g : G),
(AddSubgroup.zmultiples g).toAddSubmonoid = AddSubmonoid.multiples g ⊔ AddSubmonoid.multiples (-g) | null | true |
_private.Mathlib.Order.UpperLower.Basic.0.isUpperSet_iff_forall_lt._simp_1_3 | Mathlib.Order.UpperLower.Basic | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
CategoryTheory.CountableAB4.recOn | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCountableCoproducts C] →
{motive : CategoryTheory.CountableAB4 C → Sort u_1} →
(t : CategoryTheory.CountableAB4 C) →
((ofShape :
∀ (α : Type) [inst_2 : Countable α],
... | null | false |
Std.DHashMap.Raw.Const.contains_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(Std.DHashMap.Raw.Const.alter m k f).contains k' =
if (k == k') = true then (f (Std.DHashMap.Raw.Const.get? m k)).isSom... | null | true |
Primrec.option_orElse | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ fun x1 x2 => x1 <|> x2 | null | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformContinuous.image_hausdorff._simp_1_6 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (f '' s ⊆ t) = (s ⊆ f ⁻¹' t) | null | false |
CoalgHom.convPrecomp._proof_7 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C]
[inst_6 : AddCommMonoid B] [inst_7 : Module R B] [inst_8 : Coalgebra R B] (h : B →ₗc[R] C),
WithConv.toConv (... | null | false |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_filter_pow_dvd_eq._simp_1_2 | Mathlib.Data.Nat.Factorization.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
Finset.powerset._proof_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} (s : Finset α), ∀ _t ∈ s.val.powerset, _t.Nodup | null | false |
CompleteOrthogonalIdempotents.toOrthogonalIdempotents | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} [inst_1 : Fintype I] {e : I → R},
CompleteOrthogonalIdempotents e → OrthogonalIdempotents e | null | true |
Std.DHashMap.Raw.WF.below.casesOn | Std.Data.DHashMap.Raw | ∀ {α : Type u}
{motive : {β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → (a : Std.DHashMap.Raw α β) → a.WF → Prop}
{motive_1 :
{β : α → Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} → {a : Std.DHashMap.Raw α β} → (t : a.WF) → Std.DHashMap.Raw.WF.below t → Prop}
{β : α → Type v} {i... | null | false |
Set.Iic.orderBot._proof_2 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderBot α] (x : ↑(Set.Iic a)), ⟨⊥, ⋯⟩ ≤ x | null | false |
MvPolynomial.join₂_comp_map | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S), MvPolynomial.join₂.comp (MvPolynomial.map f) = MvPolynomial.bind₂ f | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.