name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CStarMatrix.instNormedAddCommGroup._proof_12 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {A : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] {m : Type u_1}
{n : Type u_2} [inst_3 : Fintype m] [inst_4 : Fintype n] (x y : CStarMatrix m n A), dist x y = dist y x | null | false |
Lex.instCommGroup._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CommGroup α] (a b : Lex α), a * b = b * a | null | false |
MaximalFor.not_gt | Mathlib.Order.Minimal | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] {Q : ι → Prop} {f : ι → α} {i j : ι},
MaximalFor Q f i → Q j → ¬f i < f j | null | true |
CategoryTheory.MonoidalCategory.DayConvolution.hexagon_reverse | Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C]
[inst_4 : CategoryTheory.MonoidalCategory V] [inst_5 : CategoryTheory.BraidedCategory V]
(F G : CategoryT... | null | true |
Matrix.transposeRingEquiv._proof_2 | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_1) (α : Type u_2) [inst : AddCommMonoid α] (x y : Matrix m m α),
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun (x + y) =
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun x +
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun y | null | false |
RingCat.Colimits.instRingColimitType._proof_8 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(x : RingCat.Colimits.ColimitType F), 1 * x = x | null | false |
Batteries.Tactic.GeneralizeProofs.AContext.depth | Batteries.Tactic.GeneralizeProofs | Batteries.Tactic.GeneralizeProofs.AContext → ℕ | The recursion depth, for how many times `visit` is called from within `visitProof. | true |
_private.Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2.0.MeasureTheory.inner_condExpL2_eq_inner_fun._simp_1_2 | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection] (v : E), ↑(U.orthogonalProjectionOnto v) = U.starProjection v | null | false |
CategoryTheory.MonoidalCategory.tensorIso_def | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y X' Y' : C}
(f : X ≅ Y) (g : X' ≅ Y'),
CategoryTheory.MonoidalCategory.tensorIso f g =
CategoryTheory.MonoidalCategory.whiskerRightIso f X' ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso Y g | null | true |
Mathlib.Tactic.ITauto.Proof.intro | Mathlib.Tactic.ITauto | Lean.Name → Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof | `(p: (x: A) ⊢ B) ⊢ A → B` | true |
ENNReal.logOrderIso_symm | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLogExp | ENNReal.logOrderIso.symm = EReal.expOrderIso | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_left_ne._simp_1_4 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.expr | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetInfo✝ → Lean.Expr | null | true |
_private.Mathlib.NumberTheory.Harmonic.Bounds.0.harmonic_le_one_add_log._simp_1_3 | Mathlib.NumberTheory.Harmonic.Bounds | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | null | false |
Mathlib.Tactic.FieldSimp.DenomCondition.none.sizeOf_spec | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} {iM : Q(GroupWithZero «$M»)}, sizeOf Mathlib.Tactic.FieldSimp.DenomCondition.none = 1 | null | true |
CategoryTheory.Functor.Monoidal.ε_η._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
Array.count_pos_iff | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, 0 < Array.count a xs ↔ a ∈ xs | null | true |
CategoryTheory.Limits.Pi.ι_π_eq_id | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{β : Type w} [inst_2 : DecidableEq β] (f : β → C) [inst_3 : CategoryTheory.Limits.HasProduct f] (b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.ι f b) (CategoryTheory.Limits.Pi.π f b) =... | null | true |
Lean.Parser.ParserExtension.Entry.parser.sizeOf_spec | Lean.Parser.Extension | ∀ (catName declName : Lean.Name) (leading : Bool) (p : Lean.Parser.Parser) (prio : ℕ),
sizeOf (Lean.Parser.ParserExtension.Entry.parser catName declName leading p prio) =
1 + sizeOf catName + sizeOf declName + sizeOf leading + sizeOf p + sizeOf prio | null | true |
continuous_sup | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Max L] [ContinuousSup L], Continuous fun p => p.1 ⊔ p.2 | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.induct_roo_left._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ (a b : ℕ), b - a - 1 = 0 → ¬b ≤ a + 1 → False | null | false |
Lean.Meta.Grind.Clean.State.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.Clean.State → Sort u} →
((used : Lean.PHashSet Lean.Name) → (next : Lean.PHashMap Lean.Name ℕ) → motive { used := used, next := next }) →
(t : Lean.Meta.Grind.Clean.State) → motive t | null | false |
IsLocalization.Away.algebraMap_pow_isUnit | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x : R)
[IsLocalization.Away x S] (n : ℕ), IsUnit ((algebraMap R S) x ^ n) | null | true |
Filter.mem_prod_top | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {s : Set (α × β)}, s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f | null | true |
CategoryTheory.Mon.instSymmetricCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X Y Z : CategoryTheory.Mon C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStru... | null | false |
MonoidWithZeroHom.ValueGroup₀.mk | Mathlib.Algebra.GroupWithZero.Range | {A : Type u_1} →
{B : Type u_2} →
[inst : MonoidWithZero A] →
[inst_1 : CommGroupWithZero B] → (f : A →*₀ B) → [DecidablePred fun b => b = 0] → A → A → f.ValueGroup₀ | The map sending a pair of nonzero `r s : A` to the element `(v r)⁻¹ * (v s)`
of `ValueGroup₀ v`. | true |
uniformity_hasBasis_closed | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α], (uniformity α).HasBasis (fun V => V ∈ uniformity α ∧ IsClosed V) id | null | true |
instInhabitedRingInvo | Mathlib.RingTheory.RingInvo | (R : Type u_2) → [inst : CommRing R] → Inhabited (RingInvo R) | null | true |
_private.Std.Http.Data.Status.0.Std.Http.instReprStatus.repr.match_1 | Std.Http.Data.Status | (motive : Std.Http.Status → Sort u_1) →
(x : Std.Http.Status) →
(Unit → motive Std.Http.Status.continue) →
(Unit → motive Std.Http.Status.switchingProtocols) →
(Unit → motive Std.Http.Status.processing) →
(Unit → motive Std.Http.Status.earlyHints) →
(Unit → motive Std.Http.Stat... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core.0._regBuiltin.reduceIte.declare_5._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core.3740862664._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core | IO Unit | null | false |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_80 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | null | false |
Mathlib.Tactic.BicategoryCoherence.liftHom₂AssociatorHom | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
[inst_3 : Mathlib.Ta... | null | true |
List.replace_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {a b : α} [LawfulBEq α] {l : List α}, a ∉ l → l.replace a b = l | null | true |
Lean.Lsp.instFromJsonResolveSupport | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.ResolveSupport | null | true |
Lean.Elab.Term.LValResolution.projIdx | Lean.Elab.App | Lean.Name → ℕ → Lean.Elab.Term.LValResolution | Similar to `projFn`, but for extracting field indexed by `idx`. Works for one-constructor inductive types in general. | true |
pow_succ_pos._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀],
0 < a → ∀ (n : ℕ), (0 < a ^ (n + 1)) = True | null | false |
FirstOrder.Language.Substructure.map_strictMono_of_injective | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {f : L.Hom M N},
Function.Injective ⇑f → StrictMono (FirstOrder.Language.Substructure.map f) | null | true |
Std.Tactic.BVDecide.BVExpr.bin.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lhs : Std.Tactic.BVDecide.BVExpr w) (op : Std.Tactic.BVDecide.BVBinOp)
(rhs lhs_1 : Std.Tactic.BVDecide.BVExpr w) (op_1 : Std.Tactic.BVDecide.BVBinOp)
(rhs_1 : Std.Tactic.BVDecide.BVExpr w),
(lhs.bin op rhs = lhs_1.bin op_1 rhs_1) = (lhs = lhs_1 ∧ op = op_1 ∧ rhs = rhs_1) | null | true |
sdiff_inf_right_comm | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} [inst : GeneralizedBooleanAlgebra α] (x y z : α), x \ z ⊓ y = (x ⊓ y) \ z | See also `inf_sdiff_assoc`. | true |
ISize.toNatClampNeg_pos_iff | Init.Data.SInt.Lemmas | ∀ (n : ISize), 0 < n.toNatClampNeg ↔ 0 < n | null | true |
Int.fmod_eq_fmod_iff_fmod_sub_eq_zero | Init.Data.Int.DivMod.Lemmas | ∀ {m n k : ℤ}, m.fmod n = k.fmod n ↔ (m - k).fmod n = 0 | null | true |
_private.Lean.Elab.PreDefinition.WF.PackMutual.0.Lean.Elab.WF.packCalls.match_1 | Lean.Elab.PreDefinition.WF.PackMutual | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((fidx : ℕ) → motive (some fidx)) → ((x : Option ℕ) → motive x) → motive x | null | false |
CategoryTheory.ObjectProperty.IsTriangulated.rec | Mathlib.CategoryTheory.Triangulated.Subcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | null | false |
_private.Mathlib.ModelTheory.Types.0.FirstOrder.Language.Theory.CompleteType.typesWith_inf._simp_1_4 | Mathlib.ModelTheory.Types | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
Std.Tactic.BVDecide.BVLogicalExpr.eval_ite | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {d l r : Std.Tactic.BVDecide.BoolExpr Std.Tactic.BVDecide.BVPred},
Std.Tactic.BVDecide.BVLogicalExpr.eval assign (d.ite l r) =
bif Std.Tactic.BVDecide.BVLogicalExpr.eval assign d then Std.Tactic.BVDecide.BVLogicalExpr.eval assign l
else Std.Tactic.BVDecide.BV... | null | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.isReasonPhraseByte | Std.Http.Protocol.H1.Parser | UInt8 → Bool | Returns `true` if `c` is a valid reason-phrase byte (`HTAB / SP / VCHAR`, strict ASCII-only).
| true |
TProd.instMeasurableSpace._sunfold | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {δ : Type u_4} →
(X : δ → Type u_6) → [(i : δ) → MeasurableSpace (X i)] → (l : List δ) → MeasurableSpace (List.TProd X l) | null | false |
Set.functorToTypes._proof_4 | Mathlib.CategoryTheory.Types.Set | ∀ {X : Type u_1} {X_1 Y Z : Set X} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
(TypeCat.ofHom fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩) =
CategoryTheory.CategoryStruct.comp
(TypeCat.ofHom fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩)
(TypeCat.ofHom fun x =>
match x with
| ⟨x, ... | null | false |
CategoryTheory.Filtration.obj | Mathlib.CategoryTheory.Filtration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {I : Type u_1} → [inst_1 : CategoryTheory.Category.{u_2, u_1} I] → CategoryTheory.Filtration X I → I → C | The object at index `i` (domain of the mono into `X`). | true |
FinBoolAlg._sizeOf_inst | Mathlib.Order.Category.FinBoolAlg | SizeOf FinBoolAlg | null | false |
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor.recOn | Mathlib.Tactic.Linarith.Datatypes | {motive : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor → Sort u} →
(t : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor) →
((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) →
(transform : Lean.MVarId → List Lean.Expr → Lean.MetaM (List Mathlib.Tactic.Linarith.Branch)) →
... | null | false |
mdifferentiableWithinAt_congr_set' | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | If two sets coincide around a point (except possibly at a single point `y`), then it is
equivalent to be differentiable within one or the other set. | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.summand | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
ChainComplex C ℕ → (Δ : SimplexCategoryᵒᵖ) → CategoryTheory.SimplicialObject.Splitting.IndexSet Δ → C | In the definition of `(Γ₀.obj K).obj Δ` as a direct sum indexed by `A : Splitting.IndexSet Δ`,
the summand `summand K Δ A` is `K.X A.1.len`. | true |
MonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} {R : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R]
(f : k →+* R) (g : G →* R),
(∀ (x : k) (y : G), Commute (f x) (g y)) →
∀ (_a _b : MonoidAlgebra k G),
(MonoidAlgebra.liftNC ↑f ⇑g) (_a * _b) = (MonoidAlgebra.liftNC ↑f ⇑g) _a * (MonoidAlgebra.liftN... | null | false |
Std.TreeSet.min?_le_of_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k km : α}
(hc : t.contains k = true), t.min?.get ⋯ = km → (cmp km k).isLE = true | null | true |
OreLocalization.add_assoc | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] (x y z : OreLocalization S X), x + y + z = x + (y + z) | null | true |
Complex.exp_int_mul_two_pi_mul_I | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℤ), Complex.exp (↑n * (2 * ↑Real.pi * Complex.I)) = 1 | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR.match_1.eq_4 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size Std.DTreeMap.Internal.Impl.leaf.size → Sort u_3)
(size : ℕ) (rk : α) (rv : β rk) (size_1 : ℕ) (rlk : α) (rlv : β rlk) (l r : Std.DTreeMap.Internal.Impl α β)
... | null | true |
FunLike.compSemiring._proof_10 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α α] [inst_1 : Zero F] [inst_2 : Add F] [inst_3 : AddCommMonoid α]
[inst_4 : IsZeroApply F α α] [inst_5 : IsAddApply F α α] [inst_6 : SMul ℕ F] [inst_7 : IsSMulApply ℕ F α α] (n : ℕ)
(x : F), (n + 1) • x = n • x + x | null | false |
CategoryTheory.Cat.FreeRefl.instUnique._proof_3 | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ (V : Type u_1) [inst : CategoryTheory.ReflQuiver V] [inst_1 : Unique V] (a : CategoryTheory.Cat.FreeRefl V),
a = default | null | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_3 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
_private.Mathlib.Tactic.ClickSuggestions.ApplyAt.0.Mathlib.Tactic.ClickSuggestions.tacticSyntax | Mathlib.Tactic.ClickSuggestions.ApplyAt | Mathlib.Tactic.ClickSuggestions.ApplyAtLemma → Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Lean.TSyntax `tactic) | Return the `apply` tactic that performs the application. | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.posSemidef_tfae.match_1_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {h p1 : Prop} (motive : h ∧ p1 → Prop) (x : h ∧ p1), (∀ (h_1 : h) (t : p1), motive ⋯) → motive x | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₄_app_three._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬3 < 4 + 1 → False | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Bessel.0.Complex._aux_Mathlib_Analysis_SpecialFunctions_Bessel___unexpand_Complex_regularizedHGFun_1 | Mathlib.Analysis.SpecialFunctions.Bessel | Lean.PrettyPrinter.Unexpander | null | false |
_private.Lean.PrettyPrinter.Formatter.0.Lean.PrettyPrinter.Formatter.withMaybeTag.match_4 | Lean.PrettyPrinter.Formatter | (motive : Option String.Pos.Raw → Sort u_1) →
(pos? : Option String.Pos.Raw) →
((p : String.Pos.Raw) → motive (some p)) → ((x : Option String.Pos.Raw) → motive x) → motive pos? | null | false |
RelHom.swapEquiv._proof_2 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop}, Function.RightInverse RelHom.swap RelHom.swap | null | false |
_private.Mathlib.Geometry.Manifold.VectorField.Pullback.0.VectorField.mpullback_zero._simp_1_1 | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | null | false |
CategoryTheory.Functor.mapSquare._proof_6 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (X : CategoryTheory.Square C),
{ τ₁ := F.map (CategoryTheory.CategoryStruct.id X).τ₁, τ₂ := F.map (CategoryTheory.CategoryStruct.id X).τ₂,
τ₃ := F.map ... | null | false |
PartOrdEmb.hasForgetToPartOrd._proof_4 | Mathlib.Order.Category.PartOrdEmb | { obj := fun X => ↧↑X, map := fun {X Y} f => PartOrd.ofHom ↑(PartOrdEmb.Hom.hom f),
map_id := PartOrdEmb.hasForgetToPartOrd._proof_1, map_comp := @PartOrdEmb.hasForgetToPartOrd._proof_2 }.comp
(CategoryTheory.forget PartOrd) =
CategoryTheory.forget PartOrdEmb | null | false |
Filter.ker_surjective | Mathlib.Order.Filter.Ker | ∀ {α : Type u_2}, Function.Surjective Filter.ker | null | true |
MeasureTheory.Lp.smul_neg | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q r : ENNReal}
[hpqr : p.HolderTriple q r] [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : IsBoundedSMul 𝕜 E] (f : ↥(MeasureTheory.Lp 𝕜 p μ)) (g : ↥(MeasureTheory.Lp E q... | null | true |
ImportGraph.Lean.Import.FormatErrors.noConfusionType | ImportGraph.Imports.Pretty | Sort u → ImportGraph.Lean.Import.FormatErrors → ImportGraph.Lean.Import.FormatErrors → Sort u | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions.0.SimpleGraph.cycleGraph.bicoloring_of_even._simp_4 | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | ∀ {n : ℕ} {u v : Fin (n + 2)}, (SimpleGraph.cycleGraph (n + 2)).Adj u v = (u - v = 1 ∨ v - u = 1) | null | false |
Float.Model.UnpackedFloat.ofScientific | Init.Data.Float.Model.Unpacked.Operations.OfScientific | Float.Model.Format → ℕ → ℤ → Float.Model.UnpackedFloat | Computes `m * 10 ^ e`. | true |
Lean.Lsp.SymbolTag.deprecated | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolTag | null | true |
Con.subgroup_quotientGroupCon | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : H.Normal], (QuotientGroup.con H).subgroup = H | null | true |
WeierstrassCurve.map_preΨ₄ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} {S : Type s} [inst : CommRing R] [inst_1 : CommRing S] (W : WeierstrassCurve R) (f : R →+* S),
(W.map f).preΨ₄ = Polynomial.map f W.preΨ₄ | null | true |
nsmulBinRec.go_spec | Mathlib.Algebra.Group.Monoid | ∀ {M : Type u_2} [inst : AddSemigroup M] [inst_1 : Zero M] (k : ℕ) (m n : M),
nsmulBinRec.go (k + 1) m n = m + nsmulRec' (k + 1) n | null | true |
Std.TreeSet.insertMany_list_equiv_foldl | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) | null | true |
Plausible.Configuration.quiet | Plausible.Testable | Plausible.Configuration → Bool | Disable output.
| true |
CategoryTheory.ObjectProperty.antitone_rightOrthogonal | Mathlib.CategoryTheory.ObjectProperty.Orthogonal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
Antitone CategoryTheory.ObjectProperty.rightOrthogonal | null | true |
FixedPoints.instAlgebraSubtypeMemSubfieldSubfield | Mathlib.FieldTheory.Fixed | (M : Type u) →
[inst : Monoid M] →
(F : Type v) → [inst_1 : Field F] → [inst_2 : MulSemiringAction M F] → Algebra (↥(FixedPoints.subfield M F)) F | null | true |
Std.Internal.List.getValueD_filter_not_contains_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((_ : α) × β)} {l₂ : List α} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
l₂.contains k = true →
Std.Internal.List.getValueD k (List.filter (fun p => !l₂.contains p.fst) l₁) fallback = fallback | null | true |
Units.map._proof_4 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (x x_1 : Mˣ),
↑{ val := f ↑(x * x_1), inv := f (x * x_1).inv, val_inv := ⋯, inv_val := ⋯ } =
↑({ val := f ↑x, inv := f x.inv, val_inv := ⋯, inv_val := ⋯ } *
{ val := f ↑x_1, inv := f x_1.inv, val_inv := ⋯, inv_val := ⋯ }) | null | false |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_fin_orderEmbedding_get_eq._proof_1_5 | Mathlib.Data.List.NodupEquivFin | ∀ {α : Type u_1} {l l' : List α} (f : Fin l.length ↪o Fin l'.length) (ix : ℕ),
(OrderEmbedding.ofStrictMono (fun i => if h : i + 1 ≤ l.length then ↑(f ⟨i, ⋯⟩) else i + l'.length) ⋯) ix + 1 ≤
l'.length →
(OrderEmbedding.ofStrictMono (fun i => if h : i + 1 ≤ l.length then ↑(f ⟨i, ⋯⟩) else i + l'.length) ⋯) ix... | null | false |
DedekindCut.instCompleteLinearOrder._proof_7 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set (DedekindCut α)), IsLUB s (sSup s) | null | false |
CategoryTheory.Equivalence.unitIso_hom_app_comp_inverse_map_η_functor_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] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] {Z : C}
(h : e.in... | null | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.ctorElimType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} → ℕ → Sort (max 1 u) | null | false |
Std.DHashMap.getD_eq_fallback | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∉ m → m.getD a fallback = fallback | null | true |
AlgebraicGeometry.PresheafedSpace.isIso_of_components | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[CategoryTheory.IsIso f.base] [CategoryTheory.IsIso f.c], CategoryTheory.IsIso f | This could be used in conjunction with `CategoryTheory.NatIso.isIso_of_isIso_app`. | true |
Lean.Meta.Grind.SavedState | Lean.Meta.Tactic.Grind.Types | Type | Backtrackable state for the `GrindM` monad.
| true |
WithLp.toLp_zero | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V], WithLp.toLp p 0 = 0 | null | true |
HasCompactMulSupport.sup | Mathlib.Topology.Algebra.Order.Support | ∀ {X : Type u_1} {M : Type u_2} [inst : TopologicalSpace X] [inst_1 : One M] [inst_2 : SemilatticeSup M] {f g : X → M},
HasCompactMulSupport f → HasCompactMulSupport g → HasCompactMulSupport (f ⊔ g) | null | true |
IsLUB.exists_between_sub_self' | Mathlib.Algebra.Order.Group.Bounds | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {s : Set α} {a ε : α},
IsLUB s a → a ∉ s → 0 < ε → ∃ b ∈ s, a - ε < b ∧ b < a | null | true |
ImportGraph.Lake.instInhabitedBaseLibrary.default | ImportGraph.WorkspaceModel.Base | ImportGraph.Lake.BaseLibrary | null | true |
Lean.Meta.SparseCasesOnInfo.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive { indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insterestingCtors }) →
(t : Lean.Meta.SparseCasesOnInfo) → motiv... | null | false |
fderiv_tsum_apply | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [CompleteSpace F]
{u : α → ℝ} [inst_6 : NormedSpace 𝕜 F] {f : α → E → F} {x₀ : E},
Summable u →
... | null | true |
_private.Init.Data.Array.Find.0.Array.idxOf?.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (xs : Array α) (v : α), xs.idxOf? v = Option.map (fun x => ↑x) (xs.finIdxOf? v) | null | true |
DirectSum.decompose_of_mem_same | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike σ M]
[inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ] {x : M} {i : ι},
x ∈ ℳ i → ↑(((DirectSum.decompose ℳ) x) i) = x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.