name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ISize.xor_self | Init.Data.SInt.Bitwise | ∀ {a : ISize}, a ^^^ a = 0 | true |
List.head! | Init.Data.List.BasicAux | {α : Type u_1} → [Inhabited α] → List α → α | true |
_private.Init.Data.List.Impl.0.List.setTR.go.match_1.eq_3 | Init.Data.List.Impl | ∀ {α : Type u_1} (motive : List α → ℕ → Array α → Sort u_2) (x : α) (xs : List α) (n : ℕ) (acc : Array α)
(h_1 : (x : ℕ) → (x_1 : Array α) → motive [] x x_1)
(h_2 : (head : α) → (xs : List α) → (acc : Array α) → motive (head :: xs) 0 acc)
(h_3 : (x : α) → (xs : List α) → (n : ℕ) → (acc : Array α) → motive (x :: x... | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic.0.NumberField.mixedEmbedding.mem_span_latticeBasis._simp_1_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
SimpleGraph.Embedding.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} → {β : Type u_5} → {A : SimpleGraph α} → {B : SimpleGraph β} → A ↪g B → A.Copy B | true |
DFinsupp.sigmaCurry_apply | Mathlib.Data.DFinsupp.Sigma | ∀ {ι : Type u} {α : ι → Type u_2} {δ : (i : ι) → α i → Type v} [inst : DecidableEq ι]
[inst_1 : (i : ι) → (j : α i) → Zero (δ i j)] (f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd) (i : ι) (j : α i),
(f.sigmaCurry i) j = f ⟨i, j⟩ | true |
_private.Init.Data.Int.Linear.0.Int.Linear.Poly.isUnsatEq.match_1.splitter._sparseCasesOn_2 | Init.Data.Int.Linear | {motive : Int.Linear.Poly → Sort u} →
(t : Int.Linear.Poly) → ((k : ℤ) → motive (Int.Linear.Poly.num k)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Nat.minSqFac | Mathlib.Data.Nat.Squarefree | ℕ → Option ℕ | true |
Std.HashMap.Raw.get?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂).get? k = none | true |
MeasurableSet.Subtype.instSDiff | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} → [inst : MeasurableSpace α] → SDiff (Subtype MeasurableSet) | true |
NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet_mixedEmbedding | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : NumberField.RingOfIntegers K}
(hx : (NumberField.mixedEmbedding K) ↑x ∈ NumberField.mixedEmbedding.fundamentalCone.integerSet K),
↑(NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet ⟨(NumberField.mixedEmbedding K) ↑x, hx⟩) = x | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loop.wf._unary._proof_4 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] (LargeEnough : α → Prop),
(∀ (a b : α), a ≤ b → LargeEnough a → LargeEnough b) →
∀ (next : α), LargeEnough next → ∀ (next' : α), Std.PRange.succ? next = some next... | false |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno.0.iteratedDeriv_comp_two._simp_1_2 | Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, deriv f = derivWithin f Set.univ | false |
OrthogonalIdempotents.map_injective_iff | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {I : Type u_3} {e : I → R},
Function.Injective ⇑f → (OrthogonalIdempotents (⇑f ∘ e) ↔ OrthogonalIdempotents e) | true |
Graph.IsLink.right_mem | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, G.IsLink e x y → y ∈ G.vertexSet | true |
IO.Error.protocolError | Init.System.IOError | UInt32 → String → IO.Error | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.isSemilinearSet_setOfFloorNeg | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι],
IsSemilinearSet (IsProperLinearSet.setOfFloorNeg✝ hs) | true |
CategoryTheory.Limits.FormalCoproduct.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
[inst_1 : SizeOf C] (f : X.I → Y.I) (φ : (i : X.I) → X.obj i ⟶ Y.obj (f i)), sizeOf { f := f, φ := φ } = 1 | true |
IsUnit.smul_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {G : Type u_2} {M : Type u_3} [inst : Monoid G] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction G M] {u : G}
{x : M}, IsUnit u → (u • x = 0) = (x = 0) | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_8 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀) (r : R),
(v r ≤ 1) = (r ∈ v.integer) | false |
SingularManifold.sum_f | Mathlib.Geometry.Manifold.Bordism | ∀ {X : Type u_1} [inst : TopologicalSpace X] {k : WithTop ℕ∞} {E : Type u_4} {H : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : FiniteDimensional ℝ E]
[inst_4 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} (s : SingularManifold X k I) (t : SingularManifold X k I),
(s.sum t).f ... | true |
MulEquiv.coprodAssoc_symm_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P] (x : M),
(MulEquiv.coprodAssoc M N P).symm (Monoid.Coprod.inl x) = Monoid.Coprod.inl (Monoid.Coprod.inl x) | true |
CategoryTheory.Subgroupoid.instCompleteLattice._proof_4 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_1} [inst : CategoryTheory.Groupoid C] (x x_1 x_2 : CategoryTheory.Subgroupoid C),
x ≤ x_1 →
x ≤ x_2 → ∀ x_3 ∈ x, x_3.snd.snd ∈ x_1.arrows x_3.fst x_3.snd.fst ∧ x_3.snd.snd ∈ x_2.arrows x_3.fst x_3.snd.fst | false |
Std.ExtDTreeMap.getKey_maxKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α} {hc : t.contains km = true}, t.maxKey?.get ⋯ = km → t.getKey km hc = km | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerLet.lowerNonObjectFields.loop.match_1 | Lean.Compiler.LCNF.ToImpure | (motive : Lean.Compiler.LCNF.CtorFieldInfo → Sort u_1) →
(x : Lean.Compiler.LCNF.CtorFieldInfo) →
((usizeIdx : ℕ) → motive (Lean.Compiler.LCNF.CtorFieldInfo.usize usizeIdx)) →
((sz offset : ℕ) → (argType : Lean.Expr) → motive (Lean.Compiler.LCNF.CtorFieldInfo.scalar sz offset argType)) →
((i : ℕ) → ... | false |
CategoryTheory.Monad.MonadicityInternal.unitCofork | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{F : CategoryTheory.Functor C D} →
{adj : F ⊣ G} →
(A : adj.toMonad.Algebra) →
[Categor... | true |
TotalComplexShape.ε₂ | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₁₂ : Type u_4} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) → (c₁₂ : ComplexShape I₁₂) → [self : TotalComplexShape c₁ c₂ c₁₂] → I₁ × I₂ → ℤˣ | true |
_private.Mathlib.Algebra.Lie.Cochain.0.LieModule.Cohomology.d₂₃_aux._proof_18 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_3) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
(a : ↥(LieModule.Cohomology.twoCochain R L M)) (x : R) (x_1 y x_2 x_3 : L),
⁅x • x_1, (a y) (x_2 + x_3)⁆ - ⁅y, (a (x • x_1)... | false |
Finset.sorted_zero_eq_min' | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {h : 0 < (s.sort fun a b => a ≤ b).length},
(s.sort fun a b => a ≤ b)[0] = s.min' ⋯ | true |
Mathlib.Tactic.Choose.ElimStatus.failure.injEq | Mathlib.Tactic.Choose | ∀ (ts ts_1 : List Lean.Expr),
(Mathlib.Tactic.Choose.ElimStatus.failure ts = Mathlib.Tactic.Choose.ElimStatus.failure ts_1) = (ts = ts_1) | true |
ComplexShape.Embedding.extendFunctor | Mathlib.Algebra.Homology.Embedding.Extend | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
c.Embedding c' →
(C : Type u_3) →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMo... | true |
Filter.le_add_iff | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f g h : Filter α}, h ≤ f + g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s + t ∈ h | true |
PrimeSpectrum.specComap_comp | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} {S' : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : CommSemiring S']
(f : R →+* S) (g : S →+* S'), PrimeSpectrum.comap (g.comp f) = PrimeSpectrum.comap f ∘ PrimeSpectrum.comap g | true |
MeasureTheory.lintegral_enorm_neg | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, ∫⁻ (a : α), ‖(-f) a‖ₑ ∂μ = ∫⁻ (a : α), ‖f a‖ₑ ∂μ | true |
Lean.Sym.BitVec.lt_eq_true | Init.Sym.Lemmas | ∀ {n : ℕ} (a b : BitVec n), decide (a < b) = true → (a < b) = True | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.contains.match_3.splitter | Std.Data.DTreeMap.Internal.WF.Lemmas | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(t : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k' : α) →
(v : β k') →
(l r : Std.DTreeMap.In... | true |
Lean.Server.Test.Cancel._aux_Lean_Server_Test_Cancel___elabRules_Lean_Server_Test_Cancel_tacticUnblock_1 | Lean.Server.Test.Cancel | Lean.Elab.Tactic.Tactic | false |
Ideal.orderEmbeddingOfSurjective | Mathlib.RingTheory.Ideal.Maps | {R : Type u} →
{S : Type v} →
{F : Type u_1} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : FunLike F R S] → (f : F) → [RingHomClass F R S] → Function.Surjective ⇑f → Ideal S ↪o Ideal R | true |
rTensor.linearEquiv_of_rightInverse | Mathlib.LinearAlgebra.TensorProduct.RightExactness | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
{P : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : AddCommGroup N] →
[inst_3 : AddCommGroup P] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | true |
UInt32.shiftRight_xor | Init.Data.UInt.Bitwise | ∀ {a b c : UInt32}, (a ^^^ b) >>> c = a >>> c ^^^ b >>> c | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.neg.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (c : Lean.Meta.Grind.Arith.Linear.EqCnstr), sizeOf (Lean.Meta.Grind.Arith.Linear.EqCnstrProof.neg c) = 1 + sizeOf c | true |
FreeGroup.Red.decidableRel.match_5 | Mathlib.GroupTheory.FreeGroup.Reduce | {α : Type u_1} →
(x1 : α) →
(b1 : Bool) →
(tl1 : List (α × Bool)) →
(x2 : α) →
(b2 : Bool) →
(tl2 : List (α × Bool)) →
(motive : Decidable (FreeGroup.Red tl1 ((x1, !b1) :: (x2, b2) :: tl2)) → Sort u_2) →
(x : Decidable (FreeGroup.Red tl1 ((x1, !b1)... | false |
RelSeries.head_tail | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (len_pos : p.length ≠ 0), (p.tail len_pos).head = p.toFun 1 | true |
TangentBundle.chartAt_toPartialEquiv | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_6}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] (p : Tangen... | true |
Submodule.ker_mapQ | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{R₂ : Type u_3} {M₂ : Type u_4} [inst_3 : Ring R₂] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
(q : Submodule R₂ M₂) (f : M →ₛₗ[τ₁₂] M₂) (h : p ≤ Submodule.comap f q),
(p.map... | true |
DividedPowers.subDPIdeal_inf_of_quot.match_1 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommRing A] {I J : Ideal A} (a : A) (motive : a ∈ J ⊓ I → Prop) (x : a ∈ J ⊓ I),
(∀ (haJ : a ∈ ↑J) (haI : a ∈ ↑I), motive ⋯) → motive x | false |
FreeLieAlgebra.Rel.subRight | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {a b : FreeNonUnitalNonAssocAlgebra R X}
(c : FreeNonUnitalNonAssocAlgebra R X), FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (a - c) (b - c) | true |
AddCommMonCat.Hom.hom.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : AddCommMonCat} (f : X.Hom Y), f.hom = CategoryTheory.ConcreteCategory.hom f | true |
Std.ExtTreeSet.contains_of_contains_filter | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {f : α → Bool} {k : α},
(Std.ExtTreeSet.filter f t).contains k = true → t.contains k = true | true |
Lean.Compiler.LCNF.ToLCNF.Context | Lean.Compiler.LCNF.ToLCNF | Type | true |
_private.Init.Data.Repr.0.Nat.reprArray | Init.Data.Repr | Array String | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_endpoint._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {α : Type u_1} {p q : α × α}, Sym2.Rel α p q = (p = q ∨ p = q.swap) | false |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.addKeywordCompletionItem | Lean.Server.Completion.CompletionCollectors | String → Lean.Server.Completion.M✝ Unit | true |
ProbabilityTheory.IndepFun.pdf_add_eq_lconvolution_pdf | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {G : Type u_2} {mΩ : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω} [inst : AddGroup G]
{mG : MeasurableSpace G} [MeasurableAdd₂ G] [MeasurableNeg G] {μ : MeasureTheory.Measure G} [μ.IsAddLeftInvariant]
{X Y : Ω → G} [MeasureTheory.SFinite μ] [MeasureTheory.HasPDF X ℙ μ] [MeasureTheory.HasPDF Y ℙ... | true |
Lean.MessageData.tagWithErrorName | Lean.Message | Lean.MessageData → Lean.Name → Lean.MessageData | true |
Std.Time.Number.mk._flat_ctor | Std.Time.Format.Basic | ℕ → Std.Time.Number | false |
Subalgebra.mem_saturation_of_mul_mem_right | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
{s : Subalgebra R S} {M : Submonoid S} {H : M ≤ s.toSubmonoid} {x y : S},
x * y ∈ s.saturation M H → y ∈ M → x ∈ s.saturation M H | true |
BiheytingHomClass.mk._flat_ctor | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β]
[inst_2 : FunLike F α β],
(∀ (f : F) (a b : α), f (a ⊔ b) = f a ⊔ f b) →
(∀ (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b) →
(∀ (f : F) (a b : α), f (a ⇨ b) = f a ⇨ f b) →
(∀ (f : F) (a b : α), f (a... | false |
Set.nonempty_uIoc | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (Set.uIoc a b).Nonempty ↔ a ≠ b | true |
PFunctor._sizeOf_inst | Mathlib.Data.PFunctor.Univariate.Basic | SizeOf PFunctor.{uA, uB} | false |
_private.Mathlib.Data.Set.Card.0.Set.eq_insert_of_ncard_eq_succ._simp_1_2 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
MeasureTheory.Measure.map_right_add_eq_addModularCharacterFun_vadd | Mathlib.MeasureTheory.Group.ModularCharacter | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : LocallyCompactSpace G] [inst_4 : MeasurableSpace G] [BorelSpace G] (μ : MeasureTheory.Measure G)
[μ.IsAddHaarMeasure] [μ.InnerRegular] (g : G),
MeasureTheory.Measure.map (fun x => x + g) μ = MeasureTheo... | true |
_private.Lean.Meta.Tactic.Apply.0.Lean.MVarId.splitAndCore.go | Lean.Meta.Tactic.Apply | Lean.Name → Lean.Expr → StateRefT' IO.RealWorld (Array Lean.MVarId) Lean.MetaM Lean.Expr | true |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mk_eq_top._simp_1_1 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p q : Submodule R M},
(p = q) = (p.toAddSubmonoid = q.toAddSubmonoid) | false |
Int64.reduceToInt | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | Lean.Meta.Simp.DSimproc | true |
_private.Mathlib.Algebra.CharP.Lemmas.0.Commute.add_pow_prime_pow_eq'._proof_1_2 | Mathlib.Algebra.CharP.Lemmas | ∀ {p : ℕ} (n k : ℕ), k < p ^ n → ¬k = p ^ n | false |
_private.Mathlib.Analysis.Complex.Polynomial.Basic.0.Complex.exists_root._simp_1_1 | Mathlib.Analysis.Complex.Polynomial.Basic | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddGroup E] {f : α → E} {l : Filter α},
Filter.Tendsto (fun x => ‖f x‖) l Filter.atTop = Filter.Tendsto f l (Bornology.cobounded E) | false |
CategoryTheory.Limits.FormalCoproduct.instPreservesColimitDiscreteFunctorObjFunctorEval | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] (J : Type w) (f : J → CategoryTheory.Limits.FormalCoproduct C)
(F : CategoryTheory.Functor C A),
CategoryTheory.Limits.PreservesColimit (CategoryThe... | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput._proof_9 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f)
{ X₁ := X, X₂ := X ⊞ Y, X₃ := Y, f := CategoryTheory.Limits.biprod.inl, g := CategoryTheory.Limits.bipro... | false |
TensorProduct.quotTensorEquivQuotSMul | Mathlib.LinearAlgebra.TensorProduct.Quotient | {R : Type u_1} →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (I : Ideal R) → TensorProduct R (R ⧸ I) M ≃ₗ[R] M ⧸ I • ⊤ | true |
DiscreteConvolution.AddConvolutionExists.add_distrib | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {S : Type u_2} {E : Type u_3} {E' : Type u_4} {F : Type u_6} [inst : AddMonoid M]
[inst_1 : CommSemiring S] [inst_2 : AddCommMonoid E] [inst_3 : AddCommMonoid E'] [inst_4 : AddCommMonoid F]
[inst_5 : Module S E] [inst_6 : Module S E'] [inst_7 : Module S F] [inst_8 : TopologicalSpace F] [T2Space F]
... | true |
Lean.Meta.Grind.EMatchTheoremKind.eqBoth.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (gen : Bool), sizeOf (Lean.Meta.Grind.EMatchTheoremKind.eqBoth gen) = 1 + sizeOf gen | true |
Polynomial.dvd_C_mul_X_sub_one_pow_add_one | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {R : Type u_1} [inst : CommRing R] {p : ℕ},
Nat.Prime p →
p ≠ 2 → ∀ (a r : R), r ∣ a ^ p → r ∣ ↑p * a → Polynomial.C r ∣ (Polynomial.C a * Polynomial.X - 1) ^ p + 1 | true |
Lean.Json.instHashable | Lean.Data.Json.Basic | Hashable Lean.Json | true |
TopologicalSpace.NoetherianSpace.finite | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α] [T2Space α], Finite α | true |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.forExprsIn.go._unsafe_rec | Mathlib.Lean.MessageData.ForExprs | {m : Type → Type u} →
[Monad m] →
[MonadLiftT BaseIO m] →
{σ : Type} →
(Lean.PPContext × Lean.Expr → σ → m (ForInStep σ)) →
Lean.NamingContext → Option Lean.MessageDataContext → σ → Lean.MessageData → m (ForInStep σ) | false |
Fin.modNat_rev | Mathlib.Data.Fin.Basic | ∀ {n m : ℕ} (i : Fin (m * n)), i.rev.modNat = i.modNat.rev | true |
BialgHomClass.toMonoidHomClass | Mathlib.RingTheory.Bialgebra.Hom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Algebra R A} {inst_3 : Semiring B} {inst_4 : Algebra R B}
{inst_5 : CoalgebraStruct R A} {inst_6 : CoalgebraStruct R B} {inst_7 : FunLike F A B} [self : BialgHomClas... | true |
_private.Mathlib.SetTheory.Cardinal.Finite.0.Nat.card_eq_one_iff_exists.match_1_1 | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} (motive : Subsingleton α ∧ Nonempty α → Prop) (x : Subsingleton α ∧ Nonempty α),
(∀ (s : Subsingleton α) (a : α), motive ⋯) → motive x | false |
FormalMultilinearSeries.derivSeries_apply_diag | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) (x : E),
((p.derivSeries n) fun x_1 => x) x = (n + 1) • (p (n + 1)) f... | true |
subset_sInf_of_not_bddBelow | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s] {t : Set ↑s},
¬BddBelow t → sInf t = default | true |
Lean.Elab.WF.GuessLex.BasicMeasure.mk._flat_ctor | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Syntax → Bool → Lean.Expr → Lean.Expr → Lean.Elab.WF.GuessLex.BasicMeasure | false |
FirstOrder.Language.Embedding.subtype_equivRange | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N), f.toHom.range.subtype.comp f.equivRange.toEmbedding = f | true |
Lean.Lsp.instFromJsonCallHierarchyItem | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.CallHierarchyItem | true |
AddSubgroup.Normal.mk._flat_ctor | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {A : Type u_2} [inst : AddGroup A] {H : AddSubgroup A}, (∀ n ∈ H, ∀ (g : A), g + n + -g ∈ H) → H.Normal | false |
ContinuousMap.instCommMonoidOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : CommMonoid β] → [ContinuousMul β] → CommMonoid C(α, β) | true |
CategoryTheory.Idempotents.Karoubi.p | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → (self : CategoryTheory.Idempotents.Karoubi C) → self.X ⟶ self.X | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_list_le._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) | false |
FirstOrder.Language.BoundedFormula.listDecode.eq_def | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (x : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
FirstOrder.Language.BoundedFormula.listDecode x =
match x with
| Sum.inr (Sum.inr n.succ.succ) :: l =>
⟨n, FirstOrder.Language.BoundedFormula.falsum⟩ :: FirstOrder.Language.BoundedFormula.l... | true |
Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVPredCache | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | Lean.Expr →
(Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred)) →
Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred) | true |
BitVec.cpopNatRec_of_le | Init.Data.BitVec.Lemmas | ∀ {w acc : ℕ} {x : BitVec w} (k n : ℕ), w ≤ n → x.cpopNatRec (n + k) acc = x.cpopNatRec n acc | true |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.restrict._simp_5 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, (a ≤ 0) = (a = 0) | false |
Set.Countable.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Countable → IsGδ sᶜ | true |
Lean.IR.EmitC.M | Lean.Compiler.IR.EmitC | Type → Type | true |
Matroid.restrict_closure_eq' | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X R : Set α), (M.restrict R).closure X = M.closure (X ∩ R) ∩ R ∪ R \ M.E | true |
Lean.Compiler.LCNF.CodeDecl.inc.elim | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u} →
(t : Lean.Compiler.LCNF.CodeDecl pu) →
t.ctorIdx = 5 →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
... | false |
Lean.Meta.Sym.MatchUnifyResult.noConfusionType | Lean.Meta.Sym.Pattern | Sort u → Lean.Meta.Sym.MatchUnifyResult → Lean.Meta.Sym.MatchUnifyResult → Sort u | false |
Std.Sat.AIG.RefVec.LawfulZipOperator.denote_prefix_cast_ref | Std.Sat.AIG.RefVecOperator.Zip | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {assign : α → Bool} {aig : Std.Sat.AIG α}
{input1 input2 : aig.BinaryInput} {f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α}
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f] [Std.Sat.AIG.RefVec.LawfulZipOperator α f]
... | true |
_private.Mathlib.Tactic.Qify.0.Mathlib.Tactic.Qify._aux_Mathlib_Tactic_Qify___macroRules_Mathlib_Tactic_Qify_qify_1._sparseCasesOn_1 | Mathlib.Tactic.Qify | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_r._simp_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} (self : aig.Ref),
(self.gate < aig.decls.size) = True | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.