name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
SSet.Subcomplex.Pairing.instIsWellFoundedElemNIIAncestralRel | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [P.IsRegular], IsWellFounded (↑P.II) P.AncestralRel | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (d : Turing.Dir) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_modify._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Lean.Elab.Term.elabDepArrow._regBuiltin.Lean.Elab.Term.elabDepArrow.docString_3 | Lean.Elab.Binders | IO Unit | false |
Subalgebra.ofRestrictScalars._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Tower | ∀ (R : Type u_1) {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A]
(U : Subalgebra S A), IsScalarTower R S ↥U | false |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} {bv : BitVec w} {w_1 : ℕ} {bv_1 : BitVec w_1},
{ w := w, bv := bv } = { w := w_1, bv := bv_1 } → w = w_1 ∧ bv ≍ bv_1 | true |
SimpleGraph.cliqueFree_of_card_lt | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ} [inst : Fintype α], Fintype.card α < n → G.CliqueFree n | true |
MvPowerSeries.subst_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S},
MvPowerSeries.HasSubst a → ∀ (s : σ), MvPowerSeries.subst a (MvPowerSeries.X s) = a s | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Definability.0.FirstOrder.Language.presburger.mul_not_definable._proof_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Definability | ∀ (k p : ℕ), p > 0 → ∀ (x : ℕ), x * x = max k p * max k p + p → x * x ≤ max k p * max k p → False | false |
have_body_congr_dep' | Init.SimpLemmas | ∀ {α : Sort u} {β : α → Sort v} (a : α) {f f' : (x : α) → β x}, (∀ (x : α), f x = f' x) → f a = f' a | true |
commGrpTypeEquivalenceCommGrp._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | ∀ (X : CategoryTheory.CommGrp (Type u_1)),
CategoryTheory.CategoryStruct.comp
(CommGrpTypeEquivalenceCommGrp.functor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.CommGrp (Type u_1)))).hom.app X))
((CategoryTheory.NatIso.ofComponents
(fun A =>
... | false |
CompactlyGeneratedSpace.isClosed | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactlyGeneratedSpace X] {s : Set X},
(∀ ⦃K : Set X⦄, IsCompact K → IsClosed (s ∩ K)) → IsClosed s | true |
Std.HashMap.mem_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {k : α},
k ∈ m.keys ↔ k ∈ m | true |
isInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X] [CompletelyRegularSpace X], Topology.IsInducing stoneCechUnit | true |
Lean.Doc.PostponedImport.name | Lean.Elab.DocString.Builtin.Postponed | Lean.Doc.PostponedImport → Lean.Name | true |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_13 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | false |
Lean.Doc.State._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.State | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.two_nsmul_eq_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {ψ θ : Real.Angle}, (2 • ψ = 2 • θ) = (ψ = θ ∨ ψ = θ + ↑Real.pi) | false |
Part.Fix.approx._unsafe_rec | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) | false |
CategoryTheory.GradedObject.mapTrifunctorMap_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | true |
FiniteDimensional.of_locallyCompactSpace | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {E : Type u_5} [inst_2 : AddCommGroup E]
[inst_3 : UniformSpace E] [T2Space E] [IsUniformAddGroup E] [inst_6 : Module 𝕜 E] [ContinuousSMul 𝕜 E]
[LocallyCompactSpace E], FiniteDimensional 𝕜 E | true |
ProjectiveSpectrum.ctorIdx | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
{inst : CommRing A} →
{inst_1 : SetLike σ A} →
{inst_2 : AddSubmonoidClass σ A} → {𝒜 : ℕ → σ} → {inst_3 : GradedRing 𝒜} → ProjectiveSpectrum 𝒜 → ℕ | false |
rTensor.inverse_apply | 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] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | true |
TopologicalSpace.NonemptyCompacts.instPartialOrder | Mathlib.Topology.Sets.Compacts | {α : Type u_1} → [inst : TopologicalSpace α] → PartialOrder (TopologicalSpace.NonemptyCompacts α) | true |
Lean.Expr.fvar.inj | Lean.Expr | ∀ {fvarId fvarId_1 : Lean.FVarId}, Lean.Expr.fvar fvarId = Lean.Expr.fvar fvarId_1 → fvarId = fvarId_1 | true |
OpenNormalAddSubgroup.toFiniteIndexNormalAddSubgroup._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [CompactSpace G] [ContinuousAdd G]
(H : OpenNormalAddSubgroup G), (↑H.toOpenAddSubgroup).FiniteIndex | false |
CategoryTheory.WithTerminal.comp.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C) (_X : C),
CategoryTheory.WithTerminal.comp = fun _f _g => PUnit.unit | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentInv._proof_2 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.Presentation... | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkGrindEqnParams | Lean.Elab.Tactic.Try | Array Lean.Name → Lean.MetaM (Array (Lean.TSyntax `Lean.Parser.Tactic.grindParam)) | true |
Subtype.restrict_def | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop), Subtype.restrict p f = f ∘ fun a => ↑a | true |
String.Pos.ofToSlice_comp_toSlice | Init.Data.String.Basic | ∀ {s : String}, String.Pos.ofToSlice ∘ String.Pos.toSlice = id | true |
Prod.mk_dvd_mk._simp_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Semigroup G₁] [inst_1 : Semigroup G₂] {x₁ y₁ : G₁} {x₂ y₂ : G₂},
((x₁, x₂) ∣ (y₁, y₂)) = (x₁ ∣ y₁ ∧ x₂ ∣ y₂) | false |
RelEmbedding.mul_apply | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (e₁ e₂ : r ↪r r) (x : α), (e₁ * e₂) x = e₁ (e₂ x) | true |
_private.Mathlib.Topology.Separation.Regular.0.regularSpace_TFAE.match_1_7 | Mathlib.Topology.Separation.Regular | ∀ (X : Type u_1) [inst : TopologicalSpace X]
(motive : (∀ (x : X), (nhds x).lift' closure = nhds x) → (x : X) → (x_1 : Set X) → x_1 ∈ nhds x → Prop)
(x : ∀ (x : X), (nhds x).lift' closure = nhds x) (x_1 : X) (x_2 : Set X) (x_3 : x_2 ∈ nhds x_1),
(∀ (H : ∀ (x : X), (nhds x).lift' closure = nhds x) (a : X) (s : Set... | false |
Int.natCast_le_zero._simp_1 | Init.Data.Int.LemmasAux | ∀ {n : ℕ}, (↑n ≤ 0) = (n = 0) | false |
Finset.one_le_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι} [MulLeftMono N],
(∀ i ∈ s, 1 ≤ f i) → 1 ≤ ∏ i ∈ s, f i | true |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_left | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → c * a ≤ c * b | true |
CategoryTheory.ComposableArrows.Precomp.map._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1), ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩ → i ≤ j | false |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.«_aux_Mathlib_Topology_Homotopy_Product___macroRules__private_Mathlib_Topology_Homotopy_Product_0_Path_Homotopic_term_⬝__1» | Mathlib.Topology.Homotopy.Product | Lean.Macro | false |
contDiffOn_of_analyticOn_of_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞}, AnalyticOn 𝕜 f s → ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → C... | true |
RootPairing.Hom.mk.injEq | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | true |
CochainComplex.HomComplex.coboundaries.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
CochainComplex.HomComplex.coboundaries K L n =
{ carrier := {α | ∃ m, ∃ (_ : m + 1 = n), ∃ β, CochainComplex.HomComplex.δ m n β = ↑α}, add_mem' := ⋯,
zero_mem' := ⋯, neg_mem... | true |
FreeAddGroup.reduceCyclically.reduce_flatten_replicate_succ | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α],
FreeAddGroup.IsReduced L →
∀ (n : ℕ),
FreeAddGroup.reduce (List.replicate (n + 1) L).flatten =
FreeAddGroup.reduceCyclically.conjugator L ++
(List.replicate (n + 1) (FreeAddGroup.reduceCyclically L)).flatten ++
FreeAd... | true |
SubMulAction.algebraMap_mem | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
(algebraMap R A) r ∈ 1 | true |
IsCauSeq | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_3} →
[inst : Field α] →
[inst_1 : LinearOrder α] → [IsStrictOrderedRing α] → {β : Type u_4} → [Ring β] → (β → α) → (ℕ → β) → Prop | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.type?._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.le_prod_iff._simp_1_1 | Mathlib.Order.Sublattice | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | false |
fderivWithin_csinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x | true |
Finsupp.equivFunOnFinite | Mathlib.Data.Finsupp.Defs | {α : Type u_1} → {M : Type u_4} → [inst : Zero M] → [Finite α] → (α →₀ M) ≃ (α → M) | true |
SimpleGraph.ConnectedComponent.map_mk | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G →g G') (v : V),
SimpleGraph.ConnectedComponent.map φ (G.connectedComponentMk v) = G'.connectedComponentMk (φ v) | true |
Set.bounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x1 x2 => x1 ≤ x2) s | true |
Std.Internal.List.length_le_length_insertListConst | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)},
l.length ≤ (Std.Internal.List.insertListConst l toInsert).length | true |
Path.target' | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (self : Path x y), self.toFun 1 = y | true |
LinearMap.toMatrixRight'_id | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} [inst_1 : Fintype m] [inst_2 : DecidableEq m],
LinearMap.toMatrixRight' LinearMap.id = 1 | true |
differentiableAt_of_isInvertible_fderiv | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : 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] {f : E → F} {x : E}, (fderiv 𝕜 f x).IsInvertible → DifferentiableAt 𝕜 f ... | true |
Std.DHashMap.Internal.Raw₀.equiv_iff_toList_perm_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m₁ m₂ : Std.DHashMap.Raw α β), m₁.Equiv m₂ ↔ m₁.toList.Perm m₂.toList | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n s : ℕ},
n + 1 ≤ (List.findIdxs p (head :: tail) s).length → n < (List.findIdxs p (head :: tail) s).length | false |
Polynomial.MonicDegreeEq.degree | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] [Nontrivial R] (p : Polynomial.MonicDegreeEq R n), (↑p).degree = ↑n | true |
Lean.Server.RequestCancellationToken._sizeOf_inst | Lean.Server.RequestCancellation | SizeOf Lean.Server.RequestCancellationToken | false |
DirectLimit.instGroup._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → Group (G i)] ... | false |
Nat.ceilRoot_eq_zero | Mathlib.Data.Nat.Factorization.Root | ∀ {a n : ℕ}, n.ceilRoot a = 0 ↔ n = 0 ∨ a = 0 | true |
HahnModule.instAddCommGroup._proof_12 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V]
(a b : HahnModule Γ R V), a + b = b + a | false |
AddSubgroupClass.subtype_injective | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_4} (H : S) [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G],
Function.Injective ⇑↑H | true |
FiberwiseLinear.openPartialHomeomorph._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_3} {B : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {U : Set B} (φ : B → F ≃L[𝕜] F),
∀ _x ∈ U ×ˢ Set.univ, (_x.1, (φ _x.1).symm _x.2) ∈ U ×ˢ Set.univ | false |
Lean.Elab.Term.precheckFun._regBuiltin.Lean.Elab.Term.precheckFun_1 | Lean.Elab.Binders | IO Unit | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.elim_nhds_subcover._simp_1_5 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | false |
ValuativeRel.supp._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R] {a b : R},
a ∈ {x | x ≤ᵥ 0} → b ∈ {x | x ≤ᵥ 0} → a + b ≤ᵥ 0 | false |
Std.ExtTreeSet.get?_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.get? km = some km | true |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_12 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (x₁ x₂ y₂ : ℕ), y₂ ≤ x₁ → y₂ ≤ x₂ → x₁ - y₂ = x₂ - y₂ → x₁ = x₂ | false |
HNNExtension.NormalWord.TransversalPair.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{t : HNNExtension.NormalWord.TransversalPair G A B} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{t' : HNNExtension.NormalWord.TransversalPair G' A' B'} →
... | false |
BitVec.getElem_eq_true_of_lt_of_le | Init.Data.BitVec.Lemmas | ∀ {w k : ℕ} {x : BitVec w} (hk' : k < w), x.toNat < 2 ^ (k + 1) → 2 ^ k ≤ x.toNat → x[k] = true | true |
Metric.ediam_image_le_iff | Mathlib.Topology.EMetricSpace.Diam | ∀ {α : Type u_1} {X : Type u_2} [inst : PseudoEMetricSpace X] {d : ENNReal} {f : α → X} {s : Set α},
Metric.ediam (f '' s) ≤ d ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) ≤ d | true |
Dense.exists_seq_strictAnti_tendsto_of_lt | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {s : Set α},
Dense s →
∀ {x y : α}, x < y → ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo x y ∩ s) ∧ Filter.Tendsto u Filter.atTop (nhds x) | true |
_private.Mathlib.Data.Quot.0.Quot.surjective_lift.match_1_1 | Mathlib.Data.Quot | ∀ {α : Sort u_1} {γ : Sort u_2} {f : α → γ} (y : γ) (motive : (∃ a, f a = y) → Prop) (x : ∃ a, f a = y),
(∀ (x : α) (hx : f x = y), motive ⋯) → motive x | false |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_6 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X), c • f x = f (c • x) | false |
Lean.Compiler.LCNF.Simp.State.simplified | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.State → Bool | true |
Real.one_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, 0 ≤ x → 1 ≤ Real.exp x | true |
ergodic_mul_left_of_denseRange_zpow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[SecondCountableTopology G] [BorelSpace G] {g : G},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure G) [MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [μ.IsMulLeftInvariant],
E... | true |
Language.map | Mathlib.Computability.Language | {α : Type u_1} → {β : Type u_2} → (α → β) → Language α →+* Language β | true |
Polynomial.iterate_derivative_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} (p q : Polynomial R),
(⇑Polynomial.derivative)^[n] (p * q) =
∑ k ∈ Finset.range n.succ, n.choose k • ((⇑Polynomial.derivative)^[n - k] p * (⇑Polynomial.derivative)^[k] q) | true |
Lean.Server.Test.Runner.Client.HighlightedSubexprInfo.ctorElim | Lean.Server.Test.Runner | {motive : Lean.Server.Test.Runner.Client.HighlightedSubexprInfo → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Server.Test.Runner.Client.HighlightedSubexprInfo) →
ctorIdx = t.ctorIdx → Lean.Server.Test.Runner.Client.HighlightedSubexprInfo.ctorElimType ctorIdx → motive t | false |
List.cyclicPermutations_of_ne_nil | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α),
l ≠ [] → l.cyclicPermutations = (List.zipWith (fun x1 x2 => x1 ++ x2) l.tails l.inits).dropLast | true |
IsCoprime.isRelPrime | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {a b : R}, IsCoprime a b → IsRelPrime a b | true |
Lean.Compiler.LCNF.Simp.instInhabitedFunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfo | Inhabited Lean.Compiler.LCNF.Simp.FunDeclInfo | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.CircleMap.0.eq_of_circleMap_eq._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | (Complex.I = 0) = False | false |
List.mem_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {as : List α}, x ∈ as.reverse ↔ x ∈ as | true |
Std.DTreeMap.Raw.WF.emptyc | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.WF | true |
finsum_eq_indicator_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M) (a : α),
∑ᶠ (_ : a ∈ s), f a = s.indicator f a | true |
_private.Mathlib.NumberTheory.Padics.PadicIntegers.0.PadicInt.coe_sum._simp_1_1 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (self : ↥(PadicInt.subring p)), ↑self = PadicInt.Coe.ringHom self | false |
Lean.Elab.Term.LetIdDeclView.binders | Lean.Elab.Binders | Lean.Elab.Term.LetIdDeclView → Array Lean.Syntax | true |
UpperSemicontinuousOn.add | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {γ : Type u_5} [inst_1 : AddCommMonoid γ]
[inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] [ContinuousAdd γ]
{f g : α → γ}, UpperSemicontinuousOn f s → UpperSemicontinuousOn g s → UpperSemicontinuousOn (fun z => ... | true |
_private.Init.Data.List.Pairwise.0.List.Pairwise.imp.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} (motive : (x : List α) → List.Pairwise R x → Prop) (x : List α)
(x_1 : List.Pairwise R x),
(∀ (a : Unit), motive [] ⋯) →
(∀ (a : α) (l : List α) (h₁ : ∀ a' ∈ l, R a a') (h₂ : List.Pairwise R l), motive (a :: l) ⋯) → motive x x_1 | false |
Lean.Name.MatchUpToIndexSuffix.suffixMatch.elim | Batteries.Lean.Meta.UnusedNames | {motive : Lean.Name.MatchUpToIndexSuffix → Sort u} →
(t : Lean.Name.MatchUpToIndexSuffix) →
t.ctorIdx = 2 → ((i : ℕ) → motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) → motive t | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodingStepAux.match_5 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((n : Lean.Name) → (i : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj n i struct)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : ... | false |
Stream'.Seq.update_cons_succ | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α) (n : ℕ),
(Stream'.Seq.cons hd tl).update (n + 1) f = Stream'.Seq.cons hd (tl.update n f) | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.denom_aux | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ (A B : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
↑(↑(A * B) 1 0) *
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) B)) ↑z =
↑(↑A 1 0) * ↑(↑B).det +
↑(↑B 1 0) *
UpperHalfPlane.denom
(Matrix.SpecialLinearGroup... | true |
Set.image_sub_const_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => x - a) '' Set.uIcc b c = Set.uIcc (b - a) (c - a) | true |
LibraryNote.continuity_lemma_statement | Mathlib.Topology.Continuous | Batteries.Util.LibraryNote | true |
FaithfulSMul.of_injective | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M' : Type u_1} {X : Type u_5} [inst : SMul M' X] {Y : Type u_6} [inst_1 : SMul M' Y] {F : Type u_8}
[inst_2 : FunLike F X Y] [FaithfulSMul M' X] [MulActionHomClass F M' X Y] (f : F),
Function.Injective ⇑f → FaithfulSMul M' Y | true |
szemeredi_regularity | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (G : SimpleGraph α) [inst_2 : DecidableRel G.Adj] {ε : ℝ}
{l : ℕ},
0 < ε →
l ≤ Fintype.card α →
∃ P, P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.