name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LLVM.buildSwitch | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Builder ctx → LLVM.Value ctx → LLVM.BasicBlock ctx → UInt64 → BaseIO (LLVM.Value ctx) | true |
SimpleGraph.hasse | Mathlib.Combinatorics.SimpleGraph.Hasse | (α : Type u_1) → [Preorder α] → SimpleGraph α | true |
GenContFract.IntFractPair.one_le_succ_nth_stream_b | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {ifp_succ_n : GenContFract.IntFractPair K},
GenContFract.IntFractPair.stream v (n + 1) = some ifp_succ_n → 1 ≤ ifp_succ_n.b | true |
AddGroupSeminormClass.toSeminormedAddGroup._proof_2 | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [AddGroupSeminormClass F α ℝ] (f : F)
(x y : α), f (-x + y) = f (-y + x) | false |
OrderIsoClass.toSupHomClass | Mathlib.Order.Hom.Lattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : SemilatticeSup α]
[inst_2 : SemilatticeSup β] [OrderIsoClass F α β], SupHomClass F α β | true |
CategoryTheory.CommComon.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommComon C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruc... | false |
Lean.Meta.DSimp.Config.failIfUnchanged | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | true |
CategoryTheory.FreeMonoidalCategory.instMonoidalCategory._proof_4 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(Quot.map
(fun f => CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft CategoryTheory.FreeMonoidalCategory.unit f) ⋯ f)
{ hom := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_hom Y⟧,
... | false |
Composition.ext_iff | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {x y : Composition n}, x = y ↔ x.blocks = y.blocks | true |
CharacterModule.int | Mathlib.Algebra.Module.CharacterModule | Type | true |
CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproduct._proof_2 | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C},
CategoryTheory.Limits.HasBinaryBiproduct X Y | false |
MulEquiv.toGrpIso_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (e : ↑X ≃* ↑Y), e.toGrpIso.hom = GrpCat.ofHom e.toMonoidHom | true |
PSigma.fst | Init.Core | {α : Sort u} → {β : α → Sort v} → PSigma β → α | true |
CategoryTheory.ObjectProperty.IsCardinalFilteredGenerator.presentable | Mathlib.CategoryTheory.Presentable.CardinalFilteredPresentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {κ : Cardinal.{w}}
[inst_1 : Fact κ.IsRegular],
P.IsCardinalFilteredGenerator κ →
∀ [CategoryTheory.LocallySmall.{w, v, u} C] (X : C), CategoryTheory.IsPresentable.{w, v, u} X | true |
MeasureTheory.Submartingale.sum_mul_sub' | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
[MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ},
MeasureTheory.Submartingale f 𝒢 μ →
(MeasureTheory.StronglyAdapted 𝒢 fun n => ξ (n + 1)) →
(∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) →
(∀... | true |
Polynomial.expand.eq_1 | Mathlib.Algebra.Polynomial.Expand | ∀ (R : Type u) [inst : CommSemiring R] (p : ℕ),
Polynomial.expand R p = { toRingHom := Polynomial.eval₂RingHom Polynomial.C (Polynomial.X ^ p), commutes' := ⋯ } | true |
Std.Legacy.Range.«_aux_Init_Data_Range_Basic___macroRules_Std_Legacy_Range_term[_:_:_]_1» | Init.Data.Range.Basic | Lean.Macro | false |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerRight_naturality_comp_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(η : F ⟶ G) {a b c : B} {a' : CategoryTheory.Cat} (f : a ⟶ b) (g : b ⟶ c) (h : G.obj c ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((η.naturality (CategoryTheory.Cate... | true |
Lean.Elab.Tactic.elabLinarithConfig | Lean.Elab.Tactic.Grind.Main | Lean.Syntax → Lean.Elab.Tactic.TacticM Lean.Grind.LinarithConfig | true |
Int.Linear.Poly.isUnsatEq.eq_2 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (∀ (k : ℤ), p = Int.Linear.Poly.num k → False) → p.isUnsatEq = false | true |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂),
(... | true |
Finset.sup'_singleton | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] (f : β → α) {b : β}, {b}.sup' ⋯ f = f b | true |
Lean.Compiler.CSimp.State.casesOn | Lean.Compiler.CSimpAttr | {motive : Lean.Compiler.CSimp.State → Sort u} →
(t : Lean.Compiler.CSimp.State) →
((map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) →
(thmNames : Lean.SSet Lean.Name) → motive { map := map, thmNames := thmNames }) →
motive t | false |
MeasureTheory.Measure.rnDeriv_smul_same | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (ν μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure ν]
[ν.HaveLebesgueDecomposition μ] {r : NNReal}, r ≠ 0 → (r • ν).rnDeriv (r • μ) =ᵐ[μ] ν.rnDeriv μ | true |
Lean.Doc.Inline.link.elim | Lean.DocString.Types | {i : Type u} →
{motive_1 : Lean.Doc.Inline i → Sort u_1} →
(t : Lean.Doc.Inline i) →
t.ctorIdx = 6 →
((content : Array (Lean.Doc.Inline i)) → (url : String) → motive_1 (Lean.Doc.Inline.link content url)) →
motive_1 t | false |
AddOreLocalization.add_cancel | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {r : R} {s t : ↥S},
↑s -ₒ t + (r -ₒ s) = r -ₒ t | true |
Module.Invertible.rTensorEquiv_symm_apply_apply | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {N : Type u_1} (P : Type u_2) (Q : Type u_3) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q]
(e : TensorProduct R ... | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop_actionUnitIso_hom | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) [inst_3 : F.Monoidal] (d : D),
(CategoryTheory.MonoidalCategory.MonoidalLeftActi... | true |
LaurentSeries.coeff_zero_of_lt_valuation | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] {n D : ℤ} {f : LaurentSeries K},
Valued.v f ≤ WithZero.exp (-D) → n < D → f.coeff n = 0 | true |
Lean.Elab.Do.ReturnCont.resultType | Lean.Elab.Do.Basic | Lean.Elab.Do.ReturnCont → Lean.Expr | true |
Commute.add_left._simp_1 | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : Distrib R] {a b c : R}, Commute a c → Commute b c → Commute (a + b) c = True | false |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.bipartiteDoubleCover.match_1.splitter._sparseCasesOn_5 | Mathlib.Combinatorics.SimpleGraph.Bipartite | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Lean.Language.Lean.HeaderProcessedSnapshot.infoTree?._inherited_default | Lean.Language.Lean.Types | Option Lean.Elab.InfoTree | false |
MeasureTheory.diracProbaEquiv | Mathlib.MeasureTheory.Measure.DiracProba | {X : Type u_1} →
[inst : MeasurableSpace X] →
[inst_1 : TopologicalSpace X] → [OpensMeasurableSpace X] → [T0Space X] → X ≃ ↑(Set.range MeasureTheory.diracProba) | true |
eventually_mabs_div_lt | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CommGroup α] [inst_2 : LinearOrder α] [IsOrderedMonoid α]
[OrderTopology α] (a : α) {ε : α}, 1 < ε → ∀ᶠ (x : α) in nhds a, |x / a|ₘ < ε | true |
Std.Rcc.count_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] [inst_6 : Std.Rxc.HasSize α] [Std.Rxc.LawfulHasSize α] {r : Std.Rcc α},
r.iter.length = r.size | true |
Lean.Name.eraseMacroScopes | Init.Prelude | Lean.Name → Lean.Name | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.RingEqCnstr.toExprProof.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | (motive : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) →
((a b : Lean.Expr) →
(la lb : Lean.Grind.CommRing.Expr) → motive (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.core a b la lb)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnst... | false |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.natDegree_mul'._simp_1_1 | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.leadingCoeff ≠ 0) = (p ≠ 0) | false |
LieModule.toEnd | Mathlib.Algebra.Lie.OfAssociative | (R : Type u) →
(L : Type v) →
(M : Type w) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] → [inst_5 : LieRingModule L M] → [LieModule R L M] → L →ₗ⁅R⁆ Module.End R M | true |
CategoryTheory.ChosenPullbacksAlong.Over.tensorHom_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
{R S T U : CategoryTheory.Over X} (f : R ⟶ S) (g : T ⟶ U),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g).left
(CategoryTheory.ChosenPullbacksAlong.fst S.ho... | true |
Nat.ModEq.listSum_zero | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℕ} {l : List ℕ}, (∀ x ∈ l, x ≡ 0 [MOD n]) → l.sum ≡ 0 [MOD n] | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.isLocalization_away_iff_atPrime_of_basicOpen_eq_singleton.match_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] {f : R} (r : R)
(motive : (∃ p, p.IsPrime ∧ Ideal.span {r} ≤ p ∧ Disjoint ↑p ↑(Submonoid.powers f)) → Prop)
(x : ∃ p, p.IsPrime ∧ Ideal.span {r} ≤ p ∧ Disjoint ↑p ↑(Submonoid.powers f)),
(∀ (q : Ideal R) (prime : q.IsPrime) (le : Ideal.span {r} ≤ q) (disj : Disjoint ↑q ↑(S... | false |
Std.DTreeMap.Internal.Cell.getEntry?.match_1 | Std.Data.DTreeMap.Internal.Cell | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Option ((a : α) × β a) → Sort u_3) →
(x : Option ((a : α) × β a)) → (Unit → motive none) → ((p : (a : α) × β a) → motive (some p)) → motive x | false |
CategoryTheory.Join.instCategory._proof_15 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x y : CategoryTheory.Join C D} (f : x.Hom y),
CategoryTheory.Join.comp f y.id = f | false |
Lean.Meta.Grind.CanonArgKey.i | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.CanonArgKey → ℕ | true |
InnerProductSpace.ringOfCoalgebra._proof_21 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (a : E), -a + a = 0 | false |
NFA.evalFrom.eq_1 | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (S : Set σ), M.evalFrom S = List.foldl M.stepSet S | true |
gcd_zero_right | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a 0 = normalize a | true |
CategoryTheory.LaxBraidedFunctor.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D],
autoParam... | false |
Lean.Doc.instOrdMathMode.ord | Lean.DocString.Types | Lean.Doc.MathMode → Lean.Doc.MathMode → Ordering | true |
HasSummableGeomSeries.mk | Mathlib.Analysis.SpecificLimits.Normed | ∀ {K : Type u_4} [inst : NormedRing K], (∀ (ξ : K), ‖ξ‖ < 1 → Summable fun n => ξ ^ n) → HasSummableGeomSeries K | true |
ShrinkingLemma.PartialRefinement.chainSup._proof_1 | Mathlib.Topology.ShrinkingLemma | ∀ {ι : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {u : ι → Set X} {s : Set X} {p : Set X → Prop}
(c : Set (ShrinkingLemma.PartialRefinement u s p)) (ne : c.Nonempty) (i : ι),
IsOpen ((ShrinkingLemma.PartialRefinement.find c ne i).toFun i) | false |
_private.Mathlib.CategoryTheory.GradedObject.Monoidal.0.CategoryTheory.GradedObject.instFiniteElemProdNatPreimageHAddFstSndSingletonSet._proof_3 | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ (n i₁ i₂ : ℕ), i₁ + i₂ = n → i₁ < n + 1 | false |
Matrix.linftyOpNormSMulClass | Mathlib.Analysis.Matrix.Normed | ∀ {R : Type u_1} {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedRing R] [inst_3 : SeminormedAddCommGroup α] [inst_4 : Module R α] [NormSMulClass R α],
NormSMulClass R (Matrix m n α) | true |
MeasureTheory.VectorMeasure.trim._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_2} {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {m n : MeasurableSpace α}
(v : MeasureTheory.VectorMeasure α M) (i : Set α),
¬MeasurableSet i → (fun i => if MeasurableSet i then ↑v i else 0) i = 0 | false |
CategoryTheory.MorphismProperty.IsStableUnderColimitsOfShape.rec | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] →
{motive : W.IsStableUnderColimitsOfShape J → Sort u_2} →
((condition :
∀ (X₁ X₂ : CategoryTh... | false |
TensorPower.multilinearMapToDual._proof_3 | Mathlib.LinearAlgebra.TensorPower.Pairing | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ),
(∀ (x : DecidableEq (Fin n)) (f : Fin n → Module.Dual R M) (φ : Module.Dual R M) (i j : Fin n) (v : Fin n → M),
(Function.update f i φ j) (v j) = Function.update (fun j => (f j) (v j)) i (φ (v i)) j... | false |
orderOf_eq_zero_iff_eq_zero | Mathlib.GroupTheory.OrderOfElement | ∀ {G₀ : Type u_6} [inst : GroupWithZero G₀] [Finite G₀] {a : G₀}, orderOf a = 0 ↔ a = 0 | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_24 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬x.toNat < 2 ^ n → ¬x.toNat - 2 ^ n ≤ y.toNat + 2 ^ n → False | false |
CategoryTheory.ShortComplex.cyclesMapIso_hom | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
(CategoryTheory.ShortComplex.cyclesMapIso e).hom = CategoryTheory.ShortComplex.cyclesM... | true |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso._proof_7 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰.affineRefinement.openCover).I₀),
CategoryTheory.Limits.HasPullback f (𝒰.affineRefinement.openCover.f i) | false |
Turing.TM2ComputableInTime.casesOn | Mathlib.Computability.TuringMachine.Computable | {α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{motive : Turing.TM2ComputableInTime ea eb f → Sort u} →
(t : Turing.TM2ComputableInTime ea eb f) →
((toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ) →
(time : ℕ → ℕ) →
... | false |
Lean.Expr.getForallBinderNames._unsafe_rec | Lean.Expr | Lean.Expr → List Lean.Name | false |
Lean.Lsp.LeanPrepareModuleHierarchyParams.mk.injEq | Lean.Data.Lsp.Extra | ∀ (textDocument textDocument_1 : Lean.Lsp.TextDocumentIdentifier),
({ textDocument := textDocument } = { textDocument := textDocument_1 }) = (textDocument = textDocument_1) | true |
BoxIntegral.Prepartition.IsPartition.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), π.IsPartition = ∀ x ∈ I, ∃ J ∈ π, x ∈ J | true |
Set.not_infinite | Mathlib.Data.Finite.Defs | ∀ {α : Type u} {s : Set α}, ¬s.Infinite ↔ s.Finite | true |
HurwitzKernelBounds.isBigO_atTop_F_int_one | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ∀ (a : UnitAddCircle), ∃ p, 0 < p ∧ HurwitzKernelBounds.F_int 1 a =O[Filter.atTop] fun t => Real.exp (-p * t) | true |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.instInfSet._simp_5 | Mathlib.Probability.Process.Filtration | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
_private.Mathlib.LinearAlgebra.Dual.Lemmas.0.Module.finite_dual_iff.match_1_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (K : Type u_2) {V : Type u_1} [inst : CommSemiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
(motive : Nonempty ((I : Type u_1) × Module.Basis I K V) → Prop) (x : Nonempty ((I : Type u_1) × Module.Basis I K V)),
(∀ (ι : Type u_1) (b : Module.Basis ι K V), motive ⋯) → motive x | false |
CategoryTheory.MorphismProperty.RightFraction.ofInv.congr_simp | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(s s_1 : Y ⟶ X) (e_s : s = s_1) (hs : W s),
CategoryTheory.MorphismProperty.RightFraction.ofInv s hs = CategoryTheory.MorphismProperty.RightFraction.ofInv s_1 ⋯ | true |
smul_one_strictMono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} (β : Type u_2) [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : PartialOrder β] [inst_3 : Zero β]
[inst_4 : One β] [ZeroLEOneClass β] [NeZero 1] [SMulPosStrictMono α β], StrictMono fun x => x • 1 | true |
InfTopHomClass.toInfHomClass | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : Min α} {inst_1 : Min β} {inst_2 : Top α} {inst_3 : Top β}
{inst_4 : FunLike F α β} [self : InfTopHomClass F α β], InfHomClass F α β | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.continuousOn_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {a : α} {s : Set α},
ContinuousWithinAt f s a = ∀ ε > 0, ∃ δ > 0, ∀ ⦃x : α⦄, x ∈ s → dist x a < δ → dist (f x) (f a) < ε | false |
Ultrafilter.mem_or_compl_mem | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} (f : Ultrafilter α) (s : Set α), s ∈ f ∨ sᶜ ∈ f | true |
MeasureTheory.Measure.instIsLocallyFiniteMeasureForallVolumeOfSigmaFinite | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} [inst : Fintype ι] {X : ι → Type u_4} [inst_1 : (i : ι) → TopologicalSpace (X i)]
[inst_2 : (i : ι) → MeasureTheory.MeasureSpace (X i)] [∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume]
[∀ (i : ι), MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume],
MeasureTheory.IsLocallyFinite... | true |
Std.DTreeMap.Internal.Impl.WF.below.empty | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : α → Type v}, Std.DTreeMap.Internal.Impl.WF.below ⋯ | true |
DifferentiableWithinAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (fun y => f... | true |
ConjRootClass.mk_def | Mathlib.FieldTheory.Minpoly.ConjRootClass | ∀ (K : Type u_1) {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {x : L},
⟦x⟧ = ConjRootClass.mk K x | true |
Int32.minValue_le._simp_1 | Init.Data.SInt.Lemmas | ∀ (a : Int32), (Int32.minValue ≤ a) = True | false |
Function.Bijective.finset_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid M]
(e : ι → κ), Function.Bijective e → ∀ (f : ι → M) (g : κ → M), (∀ (x : ι), f x = g (e x)) → ∑ x, f x = ∑ x, g x | true |
Aesop.newNodeEmoji | Aesop.Tracing | String | true |
HomologicalComplex.XIsoOfEq_hom_comp_d | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ p₂ : ι}
(h : p₁ = p₂) (p₃ : ι), CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).hom (K.d p₂ p₃) = K.d p₁ p₃ | true |
_private.Mathlib.CategoryTheory.Abelian.Injective.Dimension.0.CategoryTheory.injectiveDimension_lt_iff._simp_1_1 | Mathlib.CategoryTheory.Abelian.Injective.Dimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | false |
Aesop.SafeRuleResult | Aesop.Search.Expansion | Type | true |
IsTopologicalAddGroup.rightUniformSpace._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G],
Filter.Tendsto Prod.swap (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) | false |
Vector.swap_comm | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (hi : i < n) (hj : j < n), xs.swap i j hi hj = xs.swap j i hj hi | true |
HasFDerivAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f : 𝕜 → F}
{f' : F} (x : 𝕜) {l : F → E} {l' : F →L[𝕜] E} {y : F},
HasFDerivAt l l' y → HasDerivAt f f' x → y = f... | true |
CategoryTheory.Functor.mapCommMonCompIso._proof_6 | 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] {D : Type u_6} [inst_3 : CategoryTheory.Category.{u_5, u_6} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] {E : Type u_... | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.both.removeNegAssignment = Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.variance_fun_id_gaussianReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | false |
Lean.JsonRpc.MessageMetaData.responseError.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageMetaData → Sort u} →
(t : Lean.JsonRpc.MessageMetaData) →
t.ctorIdx = 3 →
((id : Lean.JsonRpc.RequestID) →
(code : Lean.JsonRpc.ErrorCode) →
(message : String) →
(data? : Option Lean.Json) → motive (Lean.JsonRpc.MessageMetaData.responseError ... | false |
Lean.Meta.Grind.SplitSource._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.SplitSource | false |
CategoryTheory.Comma.coconeOfPreserves_ι_app_left | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {A : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃}
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T}
(F : Categ... | true |
_private.Init.Data.Char.Ordinal.0.Char.succ?_eq._simp_1_4 | Init.Data.Char.Ordinal | ∀ {a b : UInt32}, (a = a + b) = (b = 0) | false |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.mkCasesHint | Lean.Elab.Tactic.Split | Lean.Expr → Lean.MessageData | true |
PointedCone.dual_zero | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R}, PointedCone.dual p 0 = ⊤ | true |
Antitone.partMap | Mathlib.Order.Part | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] {f : β → γ} {g : α → Part β},
Antitone g → Antitone fun x => Part.map f (g x) | true |
CategoryTheory.Subobject.Classifier.ofIso_χ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (𝒞 : CategoryTheory.Subobject.Classifier C) {Ω₀ Ω : C}
(eΩ : 𝒞.Ω ≅ Ω) (eΩ₀ : 𝒞.Ω₀ ≅ Ω₀) (from' : (C_1 : C) → C_1 ⟶ Ω₀) (t : Ω₀ ⟶ Ω)
(ht :
autoParam (t = CategoryTheory.CategoryStruct.comp eΩ₀.inv (CategoryTheory.CategoryStruct.comp 𝒞.truth eΩ.hom))
... | true |
Std.ExtDTreeMap.maxKey! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → [Inhabited α] → Std.ExtDTreeMap α β cmp → α | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.