name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MeasureTheory.Measure.snd_univ | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{ρ : MeasureTheory.Measure (α × β)}, ρ.snd Set.univ = ρ Set.univ | true |
Lean.Meta.ExtractLets.LocalDecl' | Lean.Meta.Tactic.Lets | Type | true |
ZMod.pow_totient | Mathlib.FieldTheory.Finite.Basic | ∀ {n : ℕ} (x : (ZMod n)ˣ), x ^ n.totient = 1 | true |
groupCohomology.mapShortComplexH2.eq_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u_1, u, u} k H}
{B : Rep.{u_1, u, u} k G} (f : G →* H) (φ : Rep.res f A ⟶ B),
groupCohomology.mapShortComplexH2 f φ =
{ τ₁ := groupCohomology.cochainsMap₁ f φ, τ₂ := groupCohomology.cochainsMap₂ f φ,
τ₃ := groupCohomolo... | true |
_private.Mathlib.Topology.Semicontinuity.Defs.0.upperHemicontinuousWithinAt_iff_frequently._simp_1_2 | Mathlib.Topology.Semicontinuity.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, (t ∈ nhdsSet s) = (s ⊆ interior t) | false |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.support_inf._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | false |
EMetric.diam_le_iff | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : PseudoEMetricSpace X] {d : ENNReal},
Metric.ediam s ≤ d ↔ ∀ x ∈ s, ∀ y ∈ s, edist x y ≤ d | true |
MonotoneOn.Ici | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
MonotoneOn f s → AntitoneOn (fun x => Set.Ici (f x)) s | true |
lie_eq_self_of_isAtom_of_ne_bot | Mathlib.Algebra.Lie.Abelian | ∀ {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] {N : LieSubmodule R L M}
{I : LieIdeal R L}, IsAtom N → ⁅I, N⁆ ≠ ⊥ → ⁅I, N⁆ = N | true |
Lean.Meta.MatcherApp.params | Lean.Meta.Match.MatcherApp.Basic | Lean.Meta.MatcherApp → Array Lean.Expr | true |
FreeAddMonoid.map_comp | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β),
FreeAddMonoid.map (g ∘ f) = (FreeAddMonoid.map g).comp (FreeAddMonoid.map f) | true |
_private.Mathlib.Logic.Equiv.Fintype.0.Function.Embedding.toEquivRange_symm_apply_self._simp_1_1 | Mathlib.Logic.Equiv.Fintype | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | false |
CategoryTheory.functorProdToProdFunctor_map | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(C : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {X Y : CategoryTheory.Functor A (B × C)} (α : X ⟶ Y),
(CategoryTheory.functorProdToProdFunctor A B C).map α =
CategoryTheory.Prod.mk... | true |
CategoryTheory.Sieve.arrows_ext | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
R.arrows = S.arrows → R = S | true |
GaloisConnection.map_isCofinal | Mathlib.Order.Cofinal | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : β → α} {g : α → β},
GaloisConnection f g → ∀ {s : Set α}, IsCofinal s → IsCofinal (g '' s) | true |
Std.IterM.Partial.casesOn | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.IterM.Partial m β → Sort u} →
(t : Std.IterM.Partial m β) → ((it : Std.IterM m β) → motive { it := it }) → motive t | false |
TrivSqZeroExt.algebra'._proof_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (S : Type u_3) (R : Type u_1) (M : Type u_2) [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] [inst_4 : Module S M] [inst_5 : Module R M] [inst_6 : Module Rᵐᵒᵖ M]
[inst_7 : SMulCommClass R Rᵐᵒᵖ M] [IsScalarTower S R M] [IsScalarTower S Rᵐᵒᵖ M] (s : S) (x : TrivSqZero... | false |
_private.Mathlib.Computability.AkraBazzi.AkraBazzi.0.AkraBazziRecurrence.termε | Mathlib.Computability.AkraBazzi.AkraBazzi | Lean.ParserDescr | true |
MvPolynomial.IsHomogeneous.finSuccEquiv_coeff_isHomogeneous | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_3} [inst : CommSemiring R] {N : ℕ} {φ : MvPolynomial (Fin (N + 1)) R} {n : ℕ},
φ.IsHomogeneous n → ∀ (i j : ℕ), i + j = n → (((MvPolynomial.finSuccEquiv R N) φ).coeff i).IsHomogeneous j | true |
Int.bmod_eq_neg | Init.Data.Int.DivMod.Lemmas | ∀ {n : ℕ} {m : ℤ}, 0 ≤ m → ↑n = 2 * m → m.bmod n = -m | true |
CategoryTheory.Limits.isCoequalizerEpiComp | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{c : CategoryTheory.Limits.Cofork f g} →
CategoryTheory.Limits.IsColimit c →
{W : C} →
(h : W ⟶ X) →
[hm : CategoryTheory.Epi h] →
have this :=... | true |
Mathlib.Tactic.withResetServerInfo.Result | Mathlib.Tactic.Basic | Type → Type | true |
ClosedSubmodule.instSemilatticeInf | Mathlib.Topology.Algebra.Module.ClosedSubmodule | {R : Type u_2} →
{M : Type u_3} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : TopologicalSpace M] → [inst_3 : Module R M] → SemilatticeInf (ClosedSubmodule R M) | true |
_private.Mathlib.NumberTheory.NumberField.CMField.0.NumberField.IsCMField.«_aux_Mathlib_NumberTheory_NumberField_CMField___delab_app__private_Mathlib_NumberTheory_NumberField_CMField_0_NumberField_IsCMField_termK⁺_1» | Mathlib.NumberTheory.NumberField.CMField | Lean.PrettyPrinter.Delaborator.Delab | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.isLittleO_exp_neg_mul_rpow_atTop._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.union_insert_right_equiv_insert_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
FiniteDimensional.exists_relation_sum_zero_pos_coefficient_of_finrank_succ_lt_card | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {L : Type u_1} [inst : Field L] [inst_1 : LinearOrder L] [IsStrictOrderedRing L] {W : Type v}
[inst_3 : AddCommGroup W] [inst_4 : Module L W] [FiniteDimensional L W] {t : Finset W},
Module.finrank L W + 1 < t.card → ∃ f, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, 0 < f x | true |
CategoryTheory.Limits.MonoFactorisation.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} {I : C} {m : I ⟶ Y}
{m_mono : CategoryTheory.Mono m} {e : X ⟶ I}
{fac : autoParam (CategoryTheory.CategoryStruct.comp e m = f) CategoryTheory.Limits.MonoFactorisation.fac._autoParam}
{I_1 : C} {m_1 : I_1 ⟶ Y} {m_mono_1 : CategoryTheory... | true |
Derivation.instLieAlgebra._proof_1 | Mathlib.RingTheory.Derivation.Lie | ∀ {R : Type u_2} [inst : CommRing R] {A : Type u_1} [inst_1 : CommRing A] [inst_2 : Algebra R A] (r : R)
(d e : Derivation R A A), ⁅d, r • e⁆ = r • ⁅d, e⁆ | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.checkDisjunctStatus | Lean.Meta.Tactic.Grind.Split | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Meta.Grind.SplitStatus | true |
TensorProduct.addMonoid._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (a : TensorProduct R M N), 0 + a = a | false |
Nat.SOM.Mon.denote | Init.Data.Nat.SOM | Nat.Linear.Context → Nat.SOM.Mon → ℕ | true |
WeierstrassCurve.natDegree_ΨSq_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [NoZeroDivisors R] {n : ℤ},
1 < n.natAbs → ↑n ≠ 0 → 0 < (W.ΨSq n).natDegree | true |
CategoryTheory.Functor.CoreMonoidal.mk'._auto_1 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
Lean.Compiler.LCNF.AlphaEqv.eqvLetValue | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.AlphaEqv.EqvM Bool | true |
SSet.Subcomplex.preimage._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (A : X.Subcomplex) (p : Y ⟶ X) {U V : SimplexCategoryᵒᵖ} (f : U ⟶ V),
p.app U ⁻¹' (X.map f ⁻¹' A.obj V) ⊆ Y.map f ⁻¹' (p.app V ⁻¹' A.obj V) | false |
Lean.MethodSpecsAttrData.privateSpecs | Lean.Meta.MethodSpecs | Lean.MethodSpecsAttrData → Bool | true |
Lean.Elab.Term.MVarErrorKind.noConfusionType | Lean.Elab.Term.TermElabM | Sort u → Lean.Elab.Term.MVarErrorKind → Lean.Elab.Term.MVarErrorKind → Sort u | false |
Lean.MetavarContext.setMVarType | Lean.MetavarContext | Lean.MetavarContext → Lean.MVarId → Lean.Expr → Lean.MetavarContext | true |
Polynomial.eval₂_X_pow | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S) {n : ℕ},
Polynomial.eval₂ f x (Polynomial.X ^ n) = x ^ n | true |
SimpleGraph.maxDegree_bot_eq_zero | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} [inst : Fintype V], ⊥.maxDegree = 0 | true |
mdifferentiableAt_extChartAt | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I 1 M] {x y : M},
y ∈ (ch... | true |
Bialgebra.counitBialgHom_self | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_1} [inst : CommSemiring R], Bialgebra.counitBialgHom R R = BialgHom.id R R | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_convex._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a b : α} [AddRightMono α],
(|a| < b) = (-b < a ∧ a < b) | false |
LieAlgebra.isSolvableBot | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L], LieAlgebra.IsSolvable ↥⊥ | true |
Std.DHashMap.Raw.mem_insertMany_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type w}
[inst_2 : ForIn Id ρ ((a : α) × β a)] [EquivBEq α] [LawfulHashable α],
m.WF → ∀ {l : ρ} {k : α}, k ∈ m → k ∈ m.insertMany l | true |
AddSubmonoid.instInhabited.eq_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M], AddSubmonoid.instInhabited = { default := ⊥ } | true |
Matroid.map_isBase_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} (M : Matroid α) (f : α → β) (hf : Set.InjOn f M.E) {B : Set β},
(M.map f hf).IsBase B = ∃ B₀, M.IsBase B₀ ∧ B = f '' B₀ | false |
CategoryTheory.Limits.IsLimit.ofExistsUnique | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
(∀ (s : CategoryTheory.Limits.Cone F),
∃! l, ∀ (j : J), Category... | true |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof} →
t = t' → Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.noConfusionType P t t' | false |
Set.singletonAddMonoidHom.eq_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddZeroClass α],
Set.singletonAddMonoidHom = { toFun := Set.singletonAddHom.toFun, map_zero' := ⋯, map_add' := ⋯ } | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_neg_of_ne_intMin._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, ¬w = 0 → ¬0 < w → False | false |
Std.Tactic.BVDecide.BVExpr.bitblast.BVVar.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var | {width : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.BVVar width → Sort u} →
((ident : ℕ) → motive { ident := ident }) → (t : Std.Tactic.BVDecide.BVExpr.bitblast.BVVar width) → motive t | false |
_private.Mathlib.Order.Hom.Basic.0.OrderIso.prodAssoc._simp_4 | Mathlib.Order.Hom.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
CategoryTheory.Join.opEquiv | Mathlib.CategoryTheory.Join.Opposites | (C : Type u₁) →
(D : Type u₂) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → (CategoryTheory.Join C D)ᵒᵖ ≌ CategoryTheory.Join Dᵒᵖ Cᵒᵖ | true |
CategoryTheory.Functor.mapAddMonIdIso._proof_7 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : CategoryTheory.AddMon C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id C).mapAddMon.map f)
((fun X =>
CategoryTheory.AddMon.mkIso (CategoryTheory.Iso.ref... | false |
LawfulBifunctor.casesOn | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} →
[inst : Bifunctor F] →
{motive : LawfulBifunctor F → Sort u} →
(t : LawfulBifunctor F) →
((id_bimap : ∀ {α : Type u₀} {β : Type u₁} (x : F α β), bimap id id x = x) →
(bimap_bimap :
∀ {α₀ α₁ α₂ : Type u₀} {β₀ β₁ β₂ : Type u₁} (f : α₀ → α... | false |
Std.IteratorLoop.forIn | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{n : Type x → Type x'} →
[self : Std.IteratorLoop α m n] →
((γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ) →
(γ : Type x) →
(plausible_forInStep : β → γ → Fo... | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processConstApprox.go._unsafe_rec | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MVarId → Lean.MetavarDecl → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool | false |
Subalgebra.toSemiring | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → (S : Subalgebra R A) → Semiring ↥S | true |
SeparationQuotient.instRing._proof_9 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [IsTopologicalRing R], ContinuousNeg R | false |
MeasureTheory.integral_eq_integral_pos_part_sub_integral_neg_part | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
MeasureTheory.Integrable f μ → ∫ (a : α), f a ∂μ = ∫ (a : α), ↑(f a).toNNReal ∂μ - ∫ (a : α), ↑(-f a).toNNReal ∂μ | true |
LeanSearchClient.LoogleResult.failure.injEq | LeanSearchClient.LoogleSyntax | ∀ (error : String) (suggestions : Option (List String)) (error_1 : String) (suggestions_1 : Option (List String)),
(LeanSearchClient.LoogleResult.failure error suggestions =
LeanSearchClient.LoogleResult.failure error_1 suggestions_1) =
(error = error_1 ∧ suggestions = suggestions_1) | true |
Lean.Elab.Info.lctx | Lean.Server.InfoUtils | Lean.Elab.Info → Lean.LocalContext | true |
Lean.Parser.compileParserDescr | Lean.Parser.Extension | Lean.Parser.ParserCategories → Lean.ParserDescr → Lean.ImportM Lean.Parser.Parser | true |
subsingleton_of_disjoint_isClosed_iUnion_eq_univ | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {ι : Type u_1} [inst : TopologicalSpace α] [PreconnectedSpace α] {s : ι → Set α},
(∀ (i : ι), (s i).Nonempty) →
Pairwise (Function.onFun Disjoint s) →
∀ [Finite ι], (∀ (i : ι), IsClosed (s i)) → ⋃ i, s i = Set.univ → Subsingleton ι | true |
Matrix.submatrix_single_equiv | Mathlib.Data.Matrix.Basis | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_7} [inst : DecidableEq l]
[inst_1 : DecidableEq m] [inst_2 : DecidableEq n] [inst_3 : DecidableEq o] [inst_4 : Zero α] (f : l ≃ n) (g : m ≃ o)
(i : n) (j : o) (r : α), (Matrix.single i j r).submatrix ⇑f ⇑g = Matrix.single (f.symm i) (g.symm j... | true |
Mathlib.Tactic.ByContra._aux_Mathlib_Tactic_ByContra___macroRules_Mathlib_Tactic_ByContra_byContra!_1 | Mathlib.Tactic.ByContra | Lean.Macro | false |
_private.Mathlib.Data.Finset.Card.0.Finset.card_inter._proof_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∩ t).card = s.card + t.card - (s ∪ t).card | false |
Finsupp.DegLex.wellFounded | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Trichotomous r],
WellFounded (Function.swap r) →
∀ {s : ℕ → ℕ → Prop}, WellFounded s → (∀ ⦃n : ℕ⦄, ¬s n 0) → WellFounded (Finsupp.DegLex r s) | true |
ModularGroup.three_lt_four_mul_im_sq_of_mem_fdo | Mathlib.NumberTheory.Modular | ∀ {z : UpperHalfPlane}, z ∈ ModularGroup.fdo → 3 < 4 * z.im ^ 2 | true |
Submodule.map₂_le | Mathlib.Algebra.Module.Submodule.Bilinear | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] {f : M →ₗ[R] N →ₗ[R] P} {p : Submodule R M} {q : Submodule R N} {r : Submodule R P}... | true |
FunctionField.FqtInfty.instField._proof_10 | Mathlib.NumberTheory.FunctionField | ∀ (Fq : Type u_1) [inst : Field Fq] [inst_1 : DecidableEq (RatFunc Fq)],
autoParam (∀ (x : FunctionField.FqtInfty Fq), FunctionField.FqtInfty.instField._aux_8 Fq 0 x = 0)
AddMonoid.nsmul_zero._autoParam | false |
List.isSome_findSome? | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {xs : List α} {f : α → Option β},
(List.findSome? f xs).isSome = xs.any fun x => (f x).isSome | true |
sub_nonpos | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, a - b ≤ 0 ↔ a ≤ b | true |
List.lookmap.go.eq_def | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} (f : α → Option α) (x : List α) (x_1 : Array α),
List.lookmap.go f x x_1 =
match x, x_1 with
| [], acc => acc.toList
| a :: l, acc =>
match f a with
| some b => acc.toListAppend (b :: l)
| none => List.lookmap.go f l (acc.push a) | true |
ISize.pow._unsafe_rec | Init.Data.SInt.Basic | ISize → ℕ → ISize | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.einfsep_ne_top._simp_1_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a ≠ ⊤) = (a < ⊤) | false |
Algebra.Extension.Hom.sub._proof_6 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Extension R S} {R' : Type u_5} {S' : Type u_6} [inst_3 : CommRing R'] [inst_4 : CommRing S']
[inst_5 : Algebra R' S'] {P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S']
[inst_8... | false |
QuaternionAlgebra.imI_coe | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} (x : R) [inst : Zero R], (↑x).imI = 0 | true |
CategoryTheory.ReflQuiv.forget_forgetToQuiv | Mathlib.CategoryTheory.Category.ReflQuiv | CategoryTheory.ReflQuiv.forget.comp CategoryTheory.ReflQuiv.forgetToQuiv = CategoryTheory.Quiv.forget | true |
AkraBazziRecurrence.differentiableOn_one_add_smoothingFn | Mathlib.Computability.AkraBazzi.SumTransform | DifferentiableOn ℝ (fun z => 1 + AkraBazziRecurrence.smoothingFn z) (Set.Ioi 1) | true |
_private.Batteries.Data.String.Legacy.0.String.utf8ByteSize'.go.match_1 | Batteries.Data.String.Legacy | (motive : List Char → Sort u_1) →
(x : List Char) → (Unit → motive []) → ((c : Char) → (cs : List Char) → motive (c :: cs)) → motive x | false |
CategoryTheory.Functor.Monoidal.whiskerRight_η_ε_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (T : D) {Z : D}
(h :
CategoryTheory.MonoidalC... | true |
Batteries.DList.toList_empty | Batteries.Data.DList.Lemmas | ∀ {α : Type u_1}, Batteries.DList.empty.toList = [] | true |
List.length_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (f : α → α) (a : α) (n : ℕ), (List.iterate f a n).length = n | true |
CategoryTheory.Functor.mapMonNatIso_hom_app_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F F' : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [inst_5 : F'.LaxMonoidal] (e : F ≅ F')
[ins... | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.processConstructor.match_7 | Lean.Meta.Match.Match | (motive : Option (Array Lean.Meta.CasesSubgoal) → Sort u_1) →
(subgoals? : Option (Array Lean.Meta.CasesSubgoal)) →
((subgoals : Array Lean.Meta.CasesSubgoal) → motive (some subgoals)) →
((x : Option (Array Lean.Meta.CasesSubgoal)) → motive x) → motive subgoals? | false |
Lean.Environment.Replay.State.env | Lean.Replay | Lean.Environment.Replay.State → Lean.Environment | true |
CategoryTheory.MonoidalCategory.tensorMonoidal | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → (CategoryTheory.MonoidalCategory.tensor C).Monoidal | true |
Real.HolderConjugate.conjugate_eq | Mathlib.Data.Real.ConjExponents | ∀ {p q : ℝ}, p.HolderConjugate q → q = p / (p - 1) | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isValidForSlice._proof_1_1 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : String.Slice} {pos : String.Pos.Raw},
pat.utf8ByteSize ≤ pos.byteIdx → ¬pos.byteIdx = pos.byteIdx - pat.utf8ByteSize + pat.utf8ByteSize → False | false |
Lean.Grind.AC.instLawfulBEqSeq | Init.Grind.AC | LawfulBEq Lean.Grind.AC.Seq | true |
Lean.Compiler.LCNF.CompilerM.Context.phase | Lean.Compiler.LCNF.CompilerM | Lean.Compiler.LCNF.CompilerM.Context → Lean.Compiler.LCNF.Phase | true |
Submonoid.leftInv_eq_inv | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : Group M] (S : Submonoid M), S.leftInv = S⁻¹ | true |
_private.Mathlib.Analysis.Convolution.0.MeasureTheory.convolution_integrand_bound_right_of_le_of_subset._simp_1_1 | Mathlib.Analysis.Convolution | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (a ≤ a) = True | false |
Lean.Firefox.instToJsonResourceTable | Lean.Util.Profiler | Lean.ToJson Lean.Firefox.ResourceTable | true |
Inseparable.pow | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_6} [inst : Monoid M] [inst_1 : TopologicalSpace M] [ContinuousMul M] {a b : M},
Inseparable a b → ∀ (n : ℕ), Inseparable (a ^ n) (b ^ n) | true |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhssAndAbstract.go.match_3.eq_1 | Lean.Meta.Tactic.Grind.MatchCond | ∀ (motive : Lean.Expr × Option Lean.Expr → Sort u_1) (lhs : Lean.Expr) (α? : Option Lean.Expr)
(h_1 : (lhs : Lean.Expr) → (α? : Option Lean.Expr) → motive (lhs, α?)),
(match (lhs, α?) with
| (lhs, α?) => h_1 lhs α?) =
h_1 lhs α? | true |
_private.Lean.Compiler.LCNF.CSE.0.Lean.Compiler.LCNF.Code.cse.go.match_5 | Lean.Compiler.LCNF.CSE | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.C... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.