name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Mathlib.Tactic.Linarith.SimplexAlgorithm.Tableau._sizeOf_inst | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | (matType : ℕ → ℕ → Type) →
{inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType} →
[(a a_1 : ℕ) → SizeOf (matType a a_1)] → SizeOf (Mathlib.Tactic.Linarith.SimplexAlgorithm.Tableau matType) | false |
ContinuousMap.eval_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_5} {X : I → Type u_7} [inst : (i : I) → TopologicalSpace (X i)] (i : I),
⇑(ContinuousMap.eval i) = Function.eval i | true |
Lean.Meta.Grind.Arith.Linear.ProofM.State.cache | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Meta.Grind.Arith.Linear.ProofM.State → Std.HashMap UInt64 Lean.Expr | true |
Pi.mulZeroOneClass._proof_3 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), 0 * a = 0 | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toArray_eq_match_step.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {α β : Type u_1} →
{m : Type u_1 → Type u_2} →
(motive : Std.IterStep (Std.IterM m β) β → Sort u_3) →
(x : Std.IterStep (Std.IterM m β) β) →
((it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.IterM m β) → motive (Std.IterStep.skip it')) → (Unit → motive... | true |
CategoryTheory.Hom.group._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G X : C} [inst_2 : CategoryTheory.GrpObj G] (n : ℕ) (a : X ⟶ G),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | false |
CategoryTheory.Subgroupoid.comap_comp | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ : CategoryTheory.Functor C D) {E : Type u_2} [inst_2 : CategoryTheory.Groupoid E] (ψ : CategoryTheory.Functor D E),
CategoryTheory.Subgroupoid.comap (φ.comp ψ) = CategoryTheory.Subgroupoid.comap φ ∘ CategoryTheo... | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_refl._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
Finset.mem_map_equiv._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α ≃ β} {b : β}, (b ∈ Finset.map f.toEmbedding s) = (f.symm b ∈ s) | false |
MeasureTheory.OuterMeasure.ofFunction_le | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {m : Set α → ENNReal} {m_empty : m ∅ = 0} (s : Set α),
(MeasureTheory.OuterMeasure.ofFunction m m_empty) s ≤ m s | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State.Inv_falseToCNF | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {upper : ℕ} {h : upper < aig.decls.size},
aig.decls[upper] = Std.Sat.AIG.Decl.false → Std.Sat.AIG.toCNF.State.Inv✝ aig (Std.Sat.AIG.Decl.falseToCNF✝ upper) | true |
ProbabilityTheory.integrable_toReal_condDistrib | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_3 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpace β} {s : Set Ω},
AEMeasurable X μ →
Mea... | true |
Std.Rco.isSome_succMany?_of_lt_length_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {i : ℕ}, i < r.toList.length → (Std.PRange.succMany? i r.lower).isSome = true | true |
_private.Mathlib.Combinatorics.Additive.CauchyDavenport.0.cauchy_davenport_of_isMulTorsionFree._simp_1_1 | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.casesOn | Lean.Meta.Tactic.Grind.MBTC | {motive : Lean.Meta.Grind.Key✝ → Sort u} →
(t : Lean.Meta.Grind.Key✝) → ((mask : Lean.Expr) → motive { mask := mask }) → motive t | false |
Real.isFiniteMeasure_restrict_Ioo | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ (x y : ℝ), MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Ioo x y)) | true |
HomologicalComplex.xPrevIsoSelf_comp_dTo | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {j : ι}
(h : ¬c.Rel (c.prev j) j), CategoryTheory.CategoryStruct.comp (C.xPrevIsoSelf h).inv (C.dTo j) = 0 | true |
Int64.toInt_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toInt = (↑n).bmod Int64.size | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.mk.sizeOf_spec | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : SizeOf J]
(W : CategoryTheory.MorphismProperty J) (P : CategoryTheory.ObjectProperty J)
(src : ∀ {i j : J} {f : i ⟶ j}, W f → P i) (tgt : ∀ {i j : J} {f : i ⟶ j}, W f → P j) (hW : W.HasCardinalLT κ)
(hP : P.HasCardinalLT κ),
siz... | true |
_private.Init.System.Promise.0.IO.Promise.mk | Init.System.Promise | {α : Type} → IO.PromisePointed✝.type → Nonempty α → IO.Promise α | true |
Filter.top_mul_of_one_le | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Monoid α] {f : Filter α}, 1 ≤ f → ⊤ * f = ⊤ | true |
IntermediateField.val_mk | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{x : L} (hx : x ∈ S), S.val ⟨x, hx⟩ = x | true |
Topology.RelCWComplex.skeletonLT._proof_4 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] (C : Set X) {D : Set X} [inst : Topology.RelCWComplex C D] (n : ℕ∞),
D ∪ ⋃ n_1, ⋃ j, Topology.RelCWComplex.openCell n_1 ↑j =
D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.closedCell m j | false |
_private.Mathlib.Data.Set.Card.0.Set.encard_le_coe_iff_finite_ncard_le.match_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} {k : ℕ} (motive : (∃ n₀, s.encard = ↑n₀ ∧ n₀ ≤ k) → Prop)
(x : ∃ n₀, s.encard = ↑n₀ ∧ n₀ ≤ k), (∀ (n₀ : ℕ) (hn₀ : s.encard = ↑n₀) (hle : n₀ ≤ k), motive ⋯) → motive x | false |
CategoryTheory.Limits.PushoutCocone.mk_ι_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {W : C} (inl : Y ⟶ W)
(inr : Z ⟶ W) (eq : CategoryTheory.CategoryStruct.comp f inl = CategoryTheory.CategoryStruct.comp g inr)
(j : CategoryTheory.Limits.WalkingSpan),
(CategoryTheory.Limits.PushoutCocone.mk inl inr eq).ι... | true |
List.Matcher.rec | Batteries.Data.List.Matcher | {α : Type u_1} →
{motive : List.Matcher α → Sort u} →
((toMatcher : Array.Matcher α) → (pattern : List α) → motive { toMatcher := toMatcher, pattern := pattern }) →
(t : List.Matcher α) → motive t | false |
PartialEquiv.eqOnSource_refl | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), e ≈ e | true |
Topology.IsLowerSet.isClosed_iff_isUpper | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {s : Set α},
IsClosed s ↔ IsUpperSet s | true |
_private.Lean.Parser.Basic.0.Lean.Parser.updateTokenCache | Lean.Parser.Basic | String.Pos.Raw → Lean.Parser.ParserState → Lean.Parser.ParserState | true |
Lean.Firefox.Thread.processType._default | Lean.Util.Profiler | String | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.curriedInverse._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2)
{x₀ x₁ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 })}
(e : SSet.Truncated.Edge x₀ x₁)
(y₀ y₁ : Y.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 }))
(e' : SSet.Truncated.Edge y₀ y₁),
CategoryTheory.CategorySt... | false |
CategoryTheory.Idempotents.Karoubi.hom_eq_zero_iff | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{P Q : CategoryTheory.Idempotents.Karoubi C} {f : P ⟶ Q}, f = 0 ↔ f.f = 0 | true |
CategoryTheory.WithInitial.liftToInitial_map | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) {X Y : CategoryTheory.WithInitial C}
(f : X ⟶ Y),
(CategoryTheory.WithInitial.liftToInitial F hZ).map f =
ma... | true |
MeasurableEquiv.self_comp_symm | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β), ⇑e ∘ ⇑e.symm = id | true |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.fixingSubgroup_fixedField._simp_1_2 | Mathlib.FieldTheory.Galois.Infinite | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Submonoid M} {x : M}, (x ∈ s.toSubsemigroup) = (x ∈ s) | false |
IsLeast.lowerBounds_eq | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, IsLeast s a → lowerBounds s = Set.Iic a | true |
Std.Internal.List.getKeyD_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' fallback : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k' (Std.Internal.List.modifyKey k f l) fallback =
if (k == k') = true then if Std.Internal.List.containsKey k l... | true |
CategoryTheory.MonoidalCategory.curriedTensorPreFunctor_map_app_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{F₁ F₂ : CategoryTheory.Functor C D} (f : F₁ ⟶ F₂) (X₁ X₂ : C),
((CategoryTheory.MonoidalCategory.curriedTensorPreFunctor.map f).app X₁).app X₂... | true |
Lean.Parser.Term.nofun._regBuiltin.Lean.Parser.Term.nofun.formatter_7 | Lean.Parser.Term | IO Unit | false |
Std.TreeMap.maxKey? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → Option α | true |
PowerBasis.aeval_minpolyGen | Mathlib.RingTheory.PowerBasis | ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] (pb : PowerBasis A S),
(Polynomial.aeval pb.gen) pb.minpolyGen = 0 | true |
Bimod.instCategory._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{A B : CategoryTheory.Mon C} {X Y : Bimod A B} (f : X.Hom Y), Bimod.comp f Y.id' = f | false |
Antitone.tendstoUniformlyOn_of_forall_tendsto | Mathlib.Topology.UniformSpace.Dini | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
[inst_2 : NormedAddCommGroup G] [inst_3 : Lattice G] [HasSolidNorm G] [IsOrderedAddMonoid G] {F : ι → α → G}
{f : α → G} {s : Set α},
IsCompact s →
(∀ (i : ι), ContinuousOn (F i) s) →
(∀ x ∈ s, Antitone fun ... | true |
Std.Internal.IndexMultiMap | Std.Internal.Http.Internal.IndexMultiMap | (α : Type u) → Type v → [BEq α] → [Hashable α] → Type (max u v) | true |
Finset.ruzsa_triangle_inequality_sub_add_sub | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddCommGroup G] (A B C : Finset G),
(A - C).card * B.card ≤ (A + B).card * (B - C).card | true |
Quandles.«term_◃_» | Mathlib.Algebra.Quandle | Lean.TrailingParserDescr | true |
TopologicalSpace.Opens.comap._proof_8 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β))
(s : Set (TopologicalSpace.Opens β)),
{ carrier := ⇑f ⁻¹' ↑(sSup s), is_open' := ⋯ } = sSup ((fun s => { carrier := ⇑f ⁻¹' ↑s, is_open' := ⋯ }) '' s) | false |
instCategoryLightCondensed._aux_5 | Mathlib.Condensed.Light.Basic | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] → {X Y Z : LightCondensed C} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
SizeOf.noConfusion | Init.SizeOf | {P : Sort u_1} →
{α : Sort u} → {t : SizeOf α} → {α' : Sort u} → {t' : SizeOf α'} → α = α' → t ≍ t' → SizeOf.noConfusionType P t t' | false |
AkraBazziRecurrence.growsPolynomially_deriv_rpow_p_mul_one_sub_smoothingFn | Mathlib.Computability.AkraBazzi.AkraBazzi | ∀ (p : ℝ),
AkraBazziRecurrence.GrowsPolynomially fun x => ‖deriv (fun z => z ^ p * (1 - AkraBazziRecurrence.smoothingFn z)) x‖ | true |
Int.cast_mono | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : AddCommGroupWithOne R] [inst_1 : PartialOrder R] [AddLeftMono R] [ZeroLEOneClass R],
Monotone Int.cast | true |
AddConstMapClass.map_sub_zsmul | Mathlib.Algebra.AddConstMap.Basic | ∀ {F : Type u_1} {G : Type u_2} {H : Type u_3} [inst : FunLike F G H] {a : G} {b : H} [inst_1 : AddGroup G]
[inst_2 : AddGroup H] [AddConstMapClass F G H a b] (f : F) (x : G) (n : ℤ), f (x - n • a) = f x - n • b | true |
NonUnitalSubsemiring.mem_inf._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {p p' : NonUnitalSubsemiring R} {x : R},
(x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | false |
unitInterval.path01._proof_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | Continuous id | false |
String.endExclusive_sliceFrom | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos}, (s.sliceFrom p).endExclusive = s.endPos | true |
_private.Init.Data.List.Basic.0.List.length_dropLast_cons.match_1_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Prop) (as : List α),
(∀ (a : Unit), motive []) → (∀ (b : α) (bs : List α), motive (b :: bs)) → motive as | false |
quasiIso_iff_of_arrow_mk_iso | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L K' L' : HomologicalComplex C c}
(φ : K ⟶ L) (φ' : K' ⟶ L') (e : CategoryTheory.Arrow.mk φ ≅ CategoryTheory.Arrow.mk φ')
[inst_2 : ∀ (i : ι), K.HasHomology i] [inst_... | true |
WithTop.eq_untop_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} {b : WithTop α} (h : b ≠ ⊤), a = b.untop h ↔ ↑a = b | true |
Mathlib.Tactic.Ring.ExProd.evalNatCast | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
(sβ : Q(CommSemiring «$β»)) →
{a : Q(ℕ)} →
Mathlib.Tactic.Ring.ExProd sβ a →
Mathlib.Tactic.AtomM (Mathlib.Tactic.Ring.Common.Result (Mathlib.Ta... | true |
CategoryTheory.Oplax.StrongTrans.Modification.whiskerLeft_naturality_assoc | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (Γ : CategoryTheory.Oplax.StrongTrans.Modification η θ)
{b c : B} {a' : C} (f : a' ⟶ F.obj b) (g : b ⟶ c) {Z : a' ⟶ G.obj c}
(h : CategoryTheory.CategoryS... | true |
ContinuousMap.normedSpace | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
{E : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : CompactSpace α] →
[inst_2 : SeminormedAddCommGroup E] →
{𝕜 : Type u_5} → [inst_3 : NormedField 𝕜] → [NormedSpace 𝕜 E] → NormedSpace 𝕜 C(α, E) | true |
CategoryTheory.Idempotents.instAddCommGroupHom._proof_6 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{P Q : CategoryTheory.Idempotents.Karoubi C} (a b : P ⟶ Q), a - b = a + -b | false |
Lean.Meta.Grind.ENode.sTerms | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENode → Lean.Meta.Grind.SolverTerms | true |
IsCHSHTuple.B₀_sa | Mathlib.Algebra.Star.CHSH | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {A₀ A₁ B₀ B₁ : R}, IsCHSHTuple A₀ A₁ B₀ B₁ → star B₀ = B₀ | true |
instCompleteLinearOrderWithBotENat._aux_9 | Mathlib.Data.ENat.Lattice | WithBot ℕ∞ → WithBot ℕ∞ | false |
Lean.Meta.Sym.Config.mk | Lean.Meta.Sym.SymM | Bool → Lean.Meta.Sym.Config | true |
LLVM.MemoryBuffer._sizeOf_inst | Lean.Compiler.IR.LLVMBindings | (ctx : LLVM.Context) → SizeOf (LLVM.MemoryBuffer ctx) | false |
Char.ofNatAux.eq_1 | Batteries.Data.Char.Basic | ∀ (n : ℕ) (h : n.isValidChar), Char.ofNatAux n h = { val := { toBitVec := n#'⋯ }, valid := h } | true |
Std.Time.TimeZone.TZif.TZifV2.mk | Std.Time.Zoned.Database.TzIf | Std.Time.TimeZone.TZif.TZifV1 → Option String → Std.Time.TimeZone.TZif.TZifV2 | true |
tsum_indicator_of_disjoint_on_support_of_mem | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : γ → Set β)
(f : β → α),
∀ i ∈ ⋃ d, s d,
Pairwise (Function.onFun Disjoint fun j => s j ∩ Function.support f) → ∑' (d : γ), (s d).indicator f i = f i | true |
FormalMultilinearSeries.rightInv._proof_24 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | false |
Std.ExtTreeSet.get!_eq_default_of_contains_eq_false | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{a : α}, t.contains a = false → t.get! a = default | true |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Submodule.mem_sSup_iff_exists_finset.match_1_3 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{S : Set (Submodule R M)} {m : M} (motive : (∃ s, ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i) → Prop) (x : ∃ s, ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i),
(∀ (s : Finset (Submodule R M)) (hsS : ↑s ⊆ S) (hs : m ∈ ⨆ i ∈ s, i), motive ⋯) → motive x | false |
NonUnitalStarSubsemiring.center._proof_1 | Mathlib.Algebra.Star.NonUnitalSubsemiring | ∀ (R : Type u_1) [inst : NonUnitalNonAssocSemiring R] [inst_1 : StarRing R] {a : R},
a ∈ Set.center R → star a ∈ Set.center R | false |
Mathlib.Tactic.Algebraize.evalUnsafe._@.Mathlib.Tactic.Algebraize.533490557._hygCtx._hyg.3 | Mathlib.Tactic.Algebraize | Lean.Expr → Lean.Elab.TermElabM Mathlib.Tactic.Algebraize.Config | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.linearIndependent_option._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{v : ι → V} {x : V},
(LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v)) = LinearIndependent K fun o => o.casesOn' x v | false |
Std.HashMap.Raw.union_insert_right_equiv_insert_union | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {p : α × β}, m₁.WF → m₂.WF → (m₁ ∪ m₂.insert p.1 p.2).Equiv ((m₁ ∪ m₂).insert p.1 p.2) | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_range_diag_flip._simp_1_2 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
Set.image2_mk_eq_prod | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {s : Set α} {t : Set β}, Set.image2 Prod.mk s t = s ×ˢ t | true |
Quiver.SingleObj.hasReverse | Mathlib.Combinatorics.Quiver.SingleObj | {α : Type u_1} → (α → α) → Quiver.HasReverse (Quiver.SingleObj α) | true |
WithTop.untop | Mathlib.Order.WithBot | {α : Type u_1} → (x : WithTop α) → x ≠ ⊤ → α | true |
strictMono_iff_map_pos | Mathlib.Algebra.Order.Hom.Monoid | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [i : FunLike F α β] (f : F)
[iamhc : AddMonoidHomClass F α β], StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a | true |
«term_∪_» | Init.Core | Lean.TrailingParserDescr | true |
FreeAddGroup.IsReduced.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} (L : List (α × Bool)), FreeAddGroup.IsReduced L = List.IsChain (fun a b => a.1 = b.1 → a.2 = b.2) L | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.intMin_udiv_ne_zero_of_ne_zero._proof_1_3 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {b : BitVec w}, ¬b.toNat = 0 → ¬0 < b.toNat → False | false |
_private.Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact.0.AlgebraicGeometry.isSheaf_type_propQCTopology_iff._proof_1_3 | Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} (R : CommRingCat)
(𝒱 : AlgebraicGeometry.Scheme.AffineCover P (AlgebraicGeometry.Spec R)) (hfin : Finite 𝒱.I₀)
(i : 𝒱.cover.ofQuasiCompactCover.I₀), AlgebraicGeometry.IsAffine (𝒱.cover.ofQuasiCompactCover.X i) | false |
Aesop.ClusterState.slotQueues | Aesop.Forward.State | Aesop.ClusterState → Array (Array Aesop.RawHyp) | true |
Ordnode.ofAscListAux₁._proof_13 | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1}, [].length ≤ [].length | false |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.parseNotificationParams?.match_1 | Lean.Server.Watchdog | (motive : Lean.JsonRpc.Message → Sort u_1) →
(msg : Lean.JsonRpc.Message) →
((method : String) →
(params : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.notification method params)) →
((x : Lean.JsonRpc.Message) → motive x) → motive msg | false |
Lean.Doc.State.mk.sizeOf_spec | Lean.Elab.DocString | ∀ (scopes : List Lean.Elab.Command.Scope) (openDecls : List Lean.OpenDecl) (lctx : Lean.LocalContext)
(localInstances : Lean.LocalInstances) (options : Lean.Options),
sizeOf
{ scopes := scopes, openDecls := openDecls, lctx := lctx, localInstances := localInstances, options := options } =
1 + sizeOf scopes... | true |
Std.DTreeMap.Internal.Impl.RawView.mk.injEq | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (tree : Std.DTreeMap.Internal.Impl α β) (k_1 : α) (v_1 : β k_1)
(tree_1 : Std.DTreeMap.Internal.Impl α β),
({ k := k, v := v, tree := tree } = { k := k_1, v := v_1, tree := tree_1 }) = (k = k_1 ∧ v ≍ v_1 ∧ tree = tree_1) | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.xy_modEq_yn._simp_1_3 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {n : ℕ} (a : ℕ), (a ≡ a [MOD n]) = True | false |
hasDerivAt_zero | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (x : 𝕜), HasDerivAt 0 0 x | true |
ProbabilityTheory.condDistrib_map | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] {mα : MeasurableSpace α} {X : α → β} {Y : α → Ω} {mβ : MeasurableSpace β} {γ : Type u_5}
{mγ : MeasurableSpace γ} {ν : MeasureTheory.Measure γ} [inst_3 : MeasureTheory.IsFiniteMeasure ν] {... | true |
limsup_max._auto_1 | Mathlib.Order.LiminfLimsup | Lean.Syntax | false |
Rat.cast_mkRat_of_ne_zero | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_3} [inst : DivisionRing α] (a : ℤ) {b : ℕ}, ↑b ≠ 0 → ↑(mkRat a b) = ↑a / ↑b | true |
CategoryTheory.FreeGroupoid.lift.eq_1 | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : Type u₁} [inst_1 : CategoryTheory.Groupoid G]
(φ : CategoryTheory.Functor C G),
CategoryTheory.FreeGroupoid.lift φ =
CategoryTheory.Quotient.lift (CategoryTheory.FreeGroupoid.homRel C) (Quiver.FreeGroupoid.lift φ.toPrefunctor) ⋯ | true |
_private.Mathlib.MeasureTheory.Function.L2Space.0.MeasureTheory.«term⟪_,_⟫» | Mathlib.MeasureTheory.Function.L2Space | Lean.ParserDescr | true |
HasFibers.mk.noConfusion | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳} →
{p : CategoryTheory.Functor 𝒳 𝒮} →
{P : Sort u} →
{Fib : 𝒮 → Type u₃} →
{category :
autoParam ((S : 𝒮) → Categor... | false |
String.toByteArray_eq_empty_iff | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s.toByteArray = ByteArray.empty ↔ s = "" | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.