name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.RpcWireFormat.v1 | Lean.Server.Rpc.Basic | Lean.Lsp.RpcWireFormat | Version `1` is like `0`,
except that RPC references are serialized as `{"__rpcref": n}`. | true |
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsM.handleLit | Std.Sat.CNF.Dimacs | Std.Sat.Literal ℕ → Std.Sat.CNF.DimacsM✝ Unit | null | true |
FirstOrder.Language.Term.varFinset | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α | The `Finset` of variables used in a given term. | true |
Subalgebra.rTensorBot | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | {R : Type u_1} →
{S : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] → [inst_2 : Algebra R S] → (A : Subalgebra R S) → TensorProduct R ↥A ↥⊥ ≃ₐ[R] ↥A | If `A` is a subalgebra of `S/R`, there is the natural `R`-algebra isomorphism between
`A ⊗[R] i(R)` and `A` induced by multiplication in `S`, here `i : R → S` is the structure map.
This generalizes `Algebra.TensorProduct.rid` as `i(R)` is not necessarily isomorphic to `R`.
This is the `Subalgebra` version of `Submodul... | true |
WithVal.instRing._proof_22 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(a : WithVal v), -a + a = 0 | null | false |
UInt16.or_eq_zero_iff | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, a ||| b = 0 ↔ a = 0 ∧ b = 0 | null | true |
Bool.ite_then_false_eq_false | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Bool}, (if p then false else x) = false ↔ p ∨ x = false | null | true |
Real.HolderTriple.lt | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → r < p | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Comon (CategoryTheory.Functor C D)),
CategoryTheory.CategoryStruct.comp
{
app := fun x =>
CategoryT... | null | false |
Lean.Compiler.LCNF.LetValue.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive : Lean.Compiler.LCNF.LetValue pu → Sort u} → ℕ → Sort (max 1 u) | null | false |
CochainComplex.ConnectData.homologyIsoPos._proof_11 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (m : ℤ), (ComplexShape.up ℤ).prev m = m - 1 | null | false |
Finset.affineCombinationLineMapWeights_apply_of_ne | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j t : ι},
t ≠ i → t ≠ j → ∀ (c : k), Finset.affineCombinationLineMapWeights i j c t = 0 | null | true |
IsLocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_5} {β : Type u_6} (f : X → α) (g : α → β),
IsLocallyConstant (g ∘ f) → Function.Injective g → IsLocallyConstant f | If a composition of a function `f` followed by an injection `g` is locally
constant, then the locally constant property descends to `f`. | true |
UInt32.toUSize_shiftLeft_of_lt | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), b < 32 → (a <<< b).toUSize = a.toUSize <<< b.toUSize % 4294967296 | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_subset | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α} (n : ℕ),
MeasureTheory.SignedMeasure.restrictNonposSeq✝ s i n ⊆ i | null | true |
_private.Mathlib.Analysis.Normed.Module.Seminorm.Basic.0.Seminorm.ball_sup._simp_1_3 | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max b c < a) = (b < a ∧ c < a) | null | false |
Nat.gcdB_zero_right | Mathlib.Data.Int.GCD | ∀ {s : ℕ}, s ≠ 0 → s.gcdB 0 = 0 | null | true |
PartialEquiv.single_apply | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (a : α) (b : β) (a_1 : α), ↑(PartialEquiv.single a b) a_1 = Function.const α b a_1 | null | true |
MonoidWithZeroHom.one_apply_def | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_7} {N₀ : Type u_8} [inst : MulZeroOneClass M₀] [inst_1 : MulZeroOneClass N₀]
[inst_2 : DecidablePred fun x => x = 0] [inst_3 : Nontrivial M₀] [inst_4 : NoZeroDivisors M₀] (x : M₀),
1 x = if x = 0 then 0 else 1 | null | true |
_private.ProofWidgets.Data.Html.0.ProofWidgets.instFromJsonRpcEncodablePacket.fromJson.match_1._@.ProofWidgets.Data.Html.2463204861._hygCtx._hyg.32 | ProofWidgets.Data.Html | (motive : String → Sort u_1) →
(tag : String) →
(Unit → motive "text") →
(Unit → motive "element") → (Unit → motive "component") → ((x : String) → motive x) → motive tag | null | false |
CantorBendixson.«term_ᵈ[_]» | Mathlib.Topology.CantorBendixson | Lean.TrailingParserDescr | The transfinite iteration of the relative derived-set operator on a set. | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided._proof_7 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.CommMon C),
{
hom :=
{ hom := { app := fun x => (CategoryTheory.CategoryStruct.id X).hom.hom, naturality := ⋯ },
isMonoi... | null | false |
Std.DTreeMap.Const.getKey_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
[Inhabited α] {k k' : α} {f : Option β → Option β} {hc : k' ∈ Std.DTreeMap.Const.alter t k f},
(Std.DTreeMap.Const.alter t k f).getKey k' hc = if heq : cmp k k' = Ordering.eq then k else t.getKey k' ... | null | true |
PosSMulReflectLT.recOn | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulReflectLT α β → Sort u} →
(t : PosSMulReflectLT α β) →
((lt_of_smul_lt_smul_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b... | null | false |
Nat.toList_roc_append_toList_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {l m n : ℕ}, l ≤ m → m ≤ n → (l<...=m).toList ++ (m<...=n).toList = (l<...=n).toList | null | true |
Std.DTreeMap.Internal.Impl.maxKey?_erase!_eq_iff_not_compare_eq_maxKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α},
(Std.DTreeMap.Internal.Impl.erase! k t).maxKey? = t.maxKey? ↔
∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq | null | true |
Std.TreeSet.getGT | Std.Data.TreeSet.AdditionalOperations | {α : Type u} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeSet α cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.gt) → α | Given a proof that such an element exists, retrieves the smallest element that is
greater than the given element.
| true |
Nat.toList_ric_eq_toList_rio_append | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toList = (*...n).toList ++ [n] | null | true |
LieAlgebra.HasCentralRadical.radical_eq_center | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ {R : Type u_1} {L : Type u_2} {inst : CommRing R} {inst_1 : LieRing L} {inst_2 : LieAlgebra R L}
[self : LieAlgebra.HasCentralRadical R L], LieAlgebra.radical R L = LieAlgebra.center R L | null | true |
Option.filterM_none | Init.Data.Option.Monadic | ∀ {m : Type → Type u_1} {α : Type} [inst : Applicative m] (p : α → m Bool), Option.filterM p none = pure none | null | true |
Lean.Elab.Term.Context.isNoncomputableSection._default | Lean.Elab.Term.TermElabM | Bool | null | false |
Std.DTreeMap.Raw.insertMany | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{ρ : Type u_1} → [ForIn Id ρ ((a : α) × β a)] → Std.DTreeMap.Raw α β cmp → ρ → Std.DTreeMap.Raw α β cmp | Inserts multiple mappings into the tree map by iterating over the given collection and calling
`insert`. If the same key appears multiple times, the last occurrence takes precedence.
Note: this precedence behavior is true for `TreeMap`, `DTreeMap`, `TreeMap.Raw` and `DTreeMap.Raw`.
The `insertMany` function on `TreeSe... | true |
RegularExpression.rmatch.congr_simp | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (a a_1 : RegularExpression α),
a = a_1 → ∀ (a_2 a_3 : List α), a_2 = a_3 → a.rmatch a_2 = a_1.rmatch a_3 | null | true |
CategoryTheory.GrpObj.instIsIsoInv | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(A : C) [inst_2 : CategoryTheory.GrpObj A], CategoryTheory.IsIso CategoryTheory.GrpObj.inv | null | true |
SkewMonoidAlgebra.ctorIdx | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} → {G : Type u_2} → {inst : Zero k} → SkewMonoidAlgebra k G → ℕ | null | false |
Fintype.ofMultiset._proof_1 | Mathlib.Data.Fintype.OfMap | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), (∀ (x : α), x ∈ s) → ∀ (x : α), x ∈ s.toFinset | null | false |
IntermediateField.finInsepDegree_bot | Mathlib.FieldTheory.SeparableClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E], Field.finInsepDegree F ↥⊥ = 1 | null | true |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.TaggedState.ctorIdx | Lean.Widget.TaggedText | Lean.Widget.TaggedText.TaggedState✝ → ℕ | null | false |
Quiver.SingleObj.toPrefunctor_symm_apply | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {β : Type u_2} (f : Quiver.SingleObj α ⥤q Quiver.SingleObj β) (a : α),
Quiver.SingleObj.toPrefunctor.symm f a = f.map (Quiver.SingleObj.toHom a) | null | true |
LinearOrderedAddCommGroupWithTop.sub_left_inj_of_ne_top._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α] {a b c : α}, a ≠ ⊤ → (b - a = c - a) = (b = c) | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.Int64.instUpwardEnumerable_eq._simp_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ {a b : Int64}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
VAdd.recOn | Mathlib.Algebra.Notation.Defs | {G : Type u} →
{P : Type v} →
{motive : VAdd G P → Sort u_1} → (t : VAdd G P) → ((vadd : G → P → P) → motive { vadd := vadd }) → motive t | null | false |
AddSemigrp.coe_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y Z : AddSemigrp} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
Multiset.gcd | Mathlib.Algebra.GCDMonoid.Multiset | {α : Type u_1} → [inst : CommMonoidWithZero α] → [NormalizedGCDMonoid α] → Multiset α → α | Greatest common divisor of a multiset | true |
Lean.Lsp.DiagnosticCode.string.sizeOf_spec | Lean.Data.Lsp.Diagnostics | ∀ (s : String), sizeOf (Lean.Lsp.DiagnosticCode.string s) = 1 + sizeOf s | null | true |
Subring.unop_toSubsemiring | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] (S : Subring Rᵐᵒᵖ), S.unop.toSubsemiring = S.unop | null | true |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite | Mathlib.CategoryTheory.Sites.CartesianClosed | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] →
[CategoryTheory.HasSheafify J A] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory A] →
... | null | true |
Lean.Meta.ppGoal | Lean.Meta.PPGoal | Lean.MVarId → Lean.MetaM Std.Format | null | true |
AddSubgroup.quotientEquivProdOfLE'._proof_4 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s t : AddSubgroup α} (h_le : s ≤ t) (f : α ⧸ t → α)
(hf : Function.RightInverse f QuotientAddGroup.mk),
Function.RightInverse (fun a => Quotient.map' (fun b => f a.1 + ↑b) ⋯ a.2) fun a =>
(Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨-f (Quotient.mk'' g) + g, ⋯⟩) ⋯ a) | null | false |
Frm.Hom.rec | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → (t : X.Hom Y) → motive t | null | false |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.iUnion_Icc_eq_Ici_self_iff._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = Set.Ici a ∩ Set.Iic b | null | false |
MeasureTheory.hittingAfter_anti | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] (u : ι → Ω → β) (n : ι),
Antitone fun x => MeasureTheory.hittingAfter u x n | `hittingAfter` is nonincreasing with respect to the set. | true |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.rw.elim | Mathlib.Tactic.ClickSuggestions.TryPremises | {motive : Mathlib.Tactic.ClickSuggestions.Candidates✝ → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.Candidates✝) →
Mathlib.Tactic.ClickSuggestions.Candidates.ctorIdx✝ t = 0 →
((i : Mathlib.Tactic.ClickSuggestions.RwInfo) →
(arr : Array Mathlib.Tactic.ClickSuggestions.RwLemma) →
moti... | null | false |
Lean.Elab.Term.ExtractMonadResult.noConfusionType | Lean.Elab.Do.Legacy | Sort u → Lean.Elab.Term.ExtractMonadResult → Lean.Elab.Term.ExtractMonadResult → Sort u | null | false |
ScottContinuousOn.prodMk | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{D : Set (Set α)} {f : α → β} {g : α → γ},
(∀ (a b : α), a ≤ b → {a, b} ∈ D) →
ScottContinuousOn D f → ScottContinuousOn D g → ScottContinuousOn D fun x => (f x, g x) | null | true |
Filter.coprodᵢ_bot' | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2}, Filter.coprodᵢ ⊥ = ⊥ | null | true |
subalgebraEquivIntermediateField._proof_3 | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : Algebra.IsAlgebraic K L] {a b : Subalgebra K L},
{ toFun := fun S => S.toIntermediateField ⋯, invFun := fun S => S.toSubalgebra, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := fun S => S.toIntermediateField ⋯,... | null | false |
CategoryTheory.MonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Category___unexpand_CategoryTheory_MonoidalCategoryStruct_tensorObj_1 | Mathlib.CategoryTheory.Monoidal.Category | Lean.PrettyPrinter.Unexpander | null | false |
Finsupp.update_eq_add_single | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] {f : ι →₀ M} {a : ι},
f a = 0 → ∀ (b : M), f.update a b = f + fun₀ | a => b | null | true |
Mathlib.Tactic.Ring.Common.ExSum.add.inj | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)} {BaseType : Q(«$α») → Type} {sα : Q(CommSemiring «$α»)} {a b : Q(«$α»)}
{a_1 : Mathlib.Tactic.Ring.Common.ExProd BaseType sα a} {a_2 : Mathlib.Tactic.Ring.Common.ExSum BaseType sα b}
{a_3 : Mathlib.Tactic.Ring.Common.ExProd BaseType sα a} {a_4 : Mathlib.Tactic.Ring.Common.ExSum Ba... | null | true |
FormalGroup.recOn | Mathlib.RingTheory.FormalGroup.Basic | {R : Type u_1} →
[inst : CommRing R] →
{motive : FormalGroup R → Sort u} →
(t : FormalGroup R) →
((toPowerSeries : MvPowerSeries (Fin 2) R) →
(zero_constantCoeff : MvPowerSeries.constantCoeff toPowerSeries = 0) →
(lin_coeff_X : (MvPowerSeries.coeff fun₀ | 0 => 1) toPowerSer... | null | false |
Lean.ToLevel.casesOn | Lean.ToLevel | {motive : Lean.ToLevel → Sort u_1} →
(t : Lean.ToLevel) →
((toLevel : Lean.Level) → (univ : ∀ (x : Sort u), True) → motive { toLevel := toLevel }) → motive t | null | false |
CompHausLike.productIsLimit._proof_7 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) [inst : CompHausLike.HasProp P (↑X.toTop × ↑Y.toTop)]
(x : CategoryTheory.Limits.BinaryFan X Y) (x_1 : x.pt ⟶ ↧(↑X.toTop × ↑Y.toTop)),
CategoryTheory.CategoryStruct.comp x_1 (CompHausLike.ofHom P { toFun := Prod.fst, continuous_toFun := ⋯ }) = x.fst →
CategoryTheory.... | null | false |
Lean.Meta.Grind.Arith.CommRing.Semiring.type | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.Semiring → Lean.Expr | null | true |
UInt8.left_eq_add._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = a + b) = (b = 0) | null | false |
ProbabilityTheory.Kernel.iIndepSets_zero_right | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {π : ι → Set (Set Ω)}, ProbabilityTheory.Kernel.iIndepSets π κ 0 | null | true |
String.ltb._unary.induct_unfolding | Mathlib.Data.String.Basic | ∀ (motive : (_ : String.Legacy.Iterator) ×' String.Legacy.Iterator → Bool → Prop),
(∀ (s₁ s₂ : String.Legacy.Iterator),
s₂.hasNext = true →
s₁.hasNext = true →
s₁.curr = s₂.curr →
motive ⟨s₁.next, s₂.next⟩ (String.ltb._unary ⟨s₁.next, s₂.next⟩) →
motive ⟨s₁, s₂⟩ (Stri... | null | false |
MeasurableSpace.DynkinSystem.generate_le | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} (d : MeasurableSpace.DynkinSystem α) {s : Set (Set α)},
(∀ t ∈ s, d.Has t) → MeasurableSpace.DynkinSystem.generate s ≤ d | null | true |
CategoryTheory.Precoverage.instCompleteLattice._proof_1 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {x y : CategoryTheory.Precoverage C},
x.coverings ≤ y.coverings ↔ x.coverings ≤ y.coverings | null | false |
TopPair.HomologyPretheory.Hom.ext_iff | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
{ι : Type u_2} {c : ComplexShape ι} {HP HP' : TopPair.HomologyPretheory C c} {x y : HP.Hom HP'},
x = y ↔ x.homₚ = y.homₚ ∧ x.hom = y.hom | null | true |
CategoryTheory.Abelian.Ext.add_comp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α₁ α₂ : CategoryTheory.Abelian.Ext X Y n) {m : ℕ}
(β : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p), (α₁ + α₂).comp β h = α₁.comp β h + α₂.comp β h | null | true |
Lean.Doc.MdRendererState.noConfusionType | Lean.DocString.Markdown | Sort u → Lean.Doc.MdRendererState → Lean.Doc.MdRendererState → Sort u | null | false |
Topology.IsOpenEmbedding.recOn | Mathlib.Topology.Defs.Induced | {X : Type u_1} →
{Y : Type u_2} →
[tX : TopologicalSpace X] →
[tY : TopologicalSpace Y] →
{f : X → Y} →
{motive : Topology.IsOpenEmbedding f → Sort u} →
(t : Topology.IsOpenEmbedding f) →
((toIsEmbedding : Topology.IsEmbedding f) → (isOpen_range : IsOpen (Set.rang... | null | false |
Lean.TraceResult.success | Lean.Message | Lean.TraceResult | The traced action succeeded (✅️, `checkEmoji`). | true |
Finset.sum_Ico_succ_sub_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {m n : ℕ} [inst : AddCommGroup M],
m ≤ n → ∑ i ∈ Finset.Ico m (n + 1), f i - f n = ∑ i ∈ Finset.Ico m n, f i | null | true |
Filter.mem_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {s t : Set α}, s ∈ f ⊓ Filter.principal t ↔ {x | x ∈ t → x ∈ s} ∈ f | null | true |
_private.Init.Data.List.Sublist.0.List.prefix_concat_iff._simp_1_4 | Init.Data.List.Sublist | ∀ {α : Type u_1} {as bs : List α}, (as.reverse = bs) = (as = bs.reverse) | null | false |
Unitary.path._proof_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)),
Continuous fun t => selfAdjoint.expUnitary (↑t • Unitary.argSelfAdjoint (v * star u)) * u | null | false |
Sym2.fromRel._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop}, Std.Symm r → ∀ (x x_1 : α), r x x_1 = r x_1 x | null | false |
Set.preimage_const_sub_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a - x) ⁻¹' Set.Ico b c = Set.Ioc (a - c) (a - b) | null | true |
BitVec.toFin_umod | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x % y).toFin = x.toFin % y.toFin | null | true |
DividedPowers.ofInjective._proof_1 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B) (hJ : DividedPowers J)
(hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {n : ℕ} {x : A},
x ∉ I → (if hx : x ∈ I then ⋯.choose else 0) = 0 | null | false |
Nat.toList_roo_eq_cons | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, m + 1 < n → (m<...n).toList = (m + 1) :: (m + 1<...n).toList | null | true |
PiTensorProduct.dualDistrib.congr_simp | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι], PiTensorProduct.dualDistrib = PiTensorProduct.dualDistrib | null | true |
_private.Init.Data.Array.Lemmas.0.Array.mem_flatMap._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xss : Array (Array α)}, (a ∈ xss.flatten) = ∃ xs ∈ xss, a ∈ xs | null | false |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.iterate_mul_succ' | Mathlib.Analysis.SpecificLimits.Normed | ∀ {G : Type u_4} [inst : Semigroup G] (x : G) (n : ℕ), (fun x_1 => x_1 * x)^[n + 1] x = x * (fun x_1 => x_1 * x)^[n] x | null | true |
Lean.Server.FileWorker.handleSignatureHelp | Lean.Server.FileWorker.RequestHandling | Lean.Lsp.SignatureHelpParams → Lean.Server.RequestM (Lean.Server.RequestTask (Option Lean.Lsp.SignatureHelp)) | null | true |
GroupExtension.Section._sizeOf_inst | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
{inst : Group N} →
{inst_1 : Group E} →
{inst_2 : Group G} → (S : GroupExtension N E G) → [SizeOf N] → [SizeOf E] → [SizeOf G] → SizeOf S.Section | null | false |
_private.Mathlib.LinearAlgebra.Matrix.NonsingularInverse.0.Matrix.add_mul_mul_inv_eq_sub._simp_1_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
[inst_3 : Invertible A], A⁻¹ = ⅟A | null | false |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.finite_of_nat_weight_le._simp_1_5 | Mathlib.Data.Finsupp.Weight | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
ByteArray.validateUTF8 | Init.Data.String.Basic | ByteArray → Bool | null | true |
_private.Mathlib.LinearAlgebra.Dimension.StrongRankCondition.0.strongRankCondition_iff_forall_zero_lt_finrank.match_1_3 | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u_1} [inst : Semiring R] (motive : (∃ n, Cardinal.aleph0 ≤ Module.rank R (Fin n → R)) → Prop)
(x : ∃ n, Cardinal.aleph0 ≤ Module.rank R (Fin n → R)),
(∀ (n : ℕ) (le : Cardinal.aleph0 ≤ Module.rank R (Fin n → R)), motive ⋯) → motive x | null | false |
NFA.Path.cons | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} → (t s u : σ) → (a : α) → (x : List α) → t ∈ M.step s a → M.Path t u x → M.Path s u (a :: x) | null | true |
Finset.attachFin_ssubset_attachFin_iff | Mathlib.Data.Finset.Fin | ∀ {n : ℕ} {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n), s.attachFin hs ⊂ t.attachFin ht ↔ s ⊂ t | null | true |
_private.Mathlib.CategoryTheory.Discrete.SumsProducts.0.CategoryTheory.Discrete.productEquiv.match_5.eq_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete J × CategoryTheory.Discrete K}
(motive : (X ⟶ Y) → Sort u_3) (f₁ : X.1 ⟶ Y.1) (f₂ : X.2 ⟶ Y.2)
(h_1 : (f₁ : X.1 ⟶ Y.1) → (f₂ : X.2 ⟶ Y.2) → motive (f₁, f₂)),
(match (f₁, f₂) with
| (f₁, f₂) => h_1 f₁ f₂) =
h_1 f₁ f₂ | null | true |
Vector.ofFn_add | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {n m : ℕ} {f : Fin (n + m) → α},
Vector.ofFn f = (Vector.ofFn fun i => f (Fin.castLE ⋯ i)) ++ Vector.ofFn fun i => f (Fin.natAdd n i) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_erase._simp_1_3 | 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 |
ContDiffOn.norm_sq | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E}
{s : Set G} {n : WithTop ℕ∞}, ContDiffOn ℝ n f s → ContDiffOn ℝ n (fun y => ‖f y‖ ^ 2) s | null | true |
Rat.infinitePlace | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | NumberField.InfinitePlace ℚ | The infinite place of `ℚ`, coming from the canonical map `ℚ → ℂ`. | true |
List.map_flatMap._f | Init.Data.List.Lemmas | ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} {f : β → γ} {g : α → List β} (x : List α) (f_1 : List.below x),
List.map f (List.flatMap g x) = List.flatMap (fun a => List.map f (g a)) x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.