name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S T : Set X},
(S ∈ Filter.codiscreteWithin T) = ∀ x ∈ T, Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal (T \ S)) | null | false |
Std.Tactic.BVDecide.BVExpr.bin._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} →
Std.Tactic.BVDecide.BVExpr w →
Std.Tactic.BVDecide.BVBinOp → Std.Tactic.BVDecide.BVExpr w → Std.Tactic.BVDecide.BVExpr w | null | false |
SSet.relativeCellComplexOfMono.l | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {X Y : SSet} →
(i : X ⟶ Y) →
(d : ℕ) → SSet.relativeCellComplexOfMono.sigmaBoundary i d ⟶ SSet.relativeCellComplexOfMono.sigmaStdSimplex i d | the left morphism of the pushout square `isPushout i d`: this is
the coproduct of copies of the boundary inclusion `∂Δ[d] ⟶ Δ[d]` indexed
by the nondegenerate `d`-simplices of `Y` not in the range of `i`. | true |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.termExt_iff_1 | Mathlib.Analysis.InnerProductSpace.Defs | Lean.ParserDescr | null | true |
Matrix.Commute.zpow_right | Mathlib.LinearAlgebra.Matrix.ZPow | ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
{A B : Matrix n' n' R}, Commute A B → ∀ (m : ℤ), Commute A (B ^ m) | null | true |
WithTop.not_isMin_bot | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] [Nonempty α], ¬IsMin ⊤ | null | true |
CategoryTheory.Discrete.costructuredArrowEquivalenceOfUnique._proof_9 | Mathlib.CategoryTheory.Discrete.StructuredArrow | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {T : Type u_2}
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) (t : T) [inst_1 : Subsingleton T]
{X Y : CategoryTheory.CostructuredArrow F { as := t }} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (Categ... | null | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.flexibleLinter.match_10 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.Syntax → Sort u_1) →
(suggestion? : Option Lean.Syntax) →
((suggStx : Lean.Syntax) → motive (some suggStx)) → ((x : Option Lean.Syntax) → motive x) → motive suggestion? | null | false |
_private.Mathlib.Algebra.Group.ForwardDiff.0.fwdDiff_iter_pow_eq_zero_of_lt._proof_1_3 | Mathlib.Algebra.Group.ForwardDiff | ∀ (n : ℕ) {j : ℕ}, j < n + 1 → ∀ i < j, i < n | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
UniformSpace.ofCoreEq_toCore | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α) (t : TopologicalSpace α) (h : t = u.toCore.toTopologicalSpace),
UniformSpace.ofCoreEq u.toCore t h = u | null | true |
_private.Mathlib.RingTheory.Valuation.LocalSubring.0.Ideal.image_subset_nonunits_valuationSubring.match_1_1 | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_1} [inst : Field K] {A : Subring K} (I : Ideal ↥A) (motive : (∃ M, M.IsMaximal ∧ I ≤ M) → Prop)
(x : ∃ M, M.IsMaximal ∧ I ≤ M), (∀ (M : Ideal ↥A) (hM : M.IsMaximal) (le : I ≤ M), motive ⋯) → motive x | null | false |
Prod.instMonoid._proof_2 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (a : M × N), a * 1 = a | null | false |
CategoryTheory.MarkovCategory.discard_natural_assoc | Mathlib.CategoryTheory.MarkovCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MarkovCategory C] {X Y : C} (f : X ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp Catego... | Process then discard equals discard directly. | true |
Lean.Server.FileWorker.DiagnosticsState._sizeOf_1 | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.DiagnosticsState → ℕ | null | false |
Vector.find?_eq_none | Init.Data.Vector.Find | ∀ {α : Type} {p : α → Bool} {n : ℕ} {l : Vector α n}, Vector.find? p l = none ↔ ∀ x ∈ l, ¬p x = true | null | true |
MeasureTheory.VectorMeasure.restrict_union_add_inter | Mathlib.MeasureTheory.VectorMeasure.Operations | ∀ {α : Type u_1} {mα : MeasurableSpace α} {M : Type u_4} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
[T2Space M] [inst_3 : ContinuousAdd M] {v : MeasureTheory.VectorMeasure α M} {s t : Set α},
MeasurableSet s → MeasurableSet t → v.restrict (s ∪ t) + v.restrict (s ∩ t) = v.restrict s + v.restrict t | null | true |
ite_and | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} (P Q : Prop) [inst : Decidable P] (a b : α) [inst_1 : Decidable Q],
(if P ∧ Q then a else b) = if P then if Q then a else b else b | null | true |
StandardEtalePair.equivAwayAdjoinRoot._proof_8 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
(P.lift ((algebraMap (AdjoinRoot P.f) (Localization.Away ((AdjoinRoot.mk P.f) P.g))) (AdjoinRoot.root P.f)) ⋯).comp
(IsLocalization.Away.liftAlgHom ((AdjoinRoot.mk P.f) P.g) ⋯) =
AlgHom.id R (Localization.Away ((AdjoinRoot.mk P.f) P.g)) | null | false |
_private.Lean.Elab.ErrorUtils.0.List.toOxford._f | Lean.Elab.ErrorUtils | {α : Type u_1} → [Append α] → [Lean.HasOxfordStrings✝ α] → (x : List α) → List.below x → α | null | false |
MonoidHom.mem_ker._simp_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {M : Type u_6} [inst_1 : MulOneClass M] {f : G →* M} {x : G}, (x ∈ f.ker) = (f x = 1) | null | false |
LinearMap.map_eq_zero_iff._simp_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
(f : M →ₛₗ[σ] M₃), Function.Injective ⇑f → ∀ {x : M}, (f x = 0) = (x = 0) | null | false |
Digraph.sdiff | Mathlib.Combinatorics.Digraph.Basic | {V : Type u_2} → SDiff (Digraph V) | The difference of two digraphs `x \ y` has the edges of `x` with the edges of `y` removed. | true |
Computability.Encoding._sizeOf_inst | Mathlib.Computability.Encoding | (α : Type u) → (Γ : Type v) → [SizeOf α] → [SizeOf Γ] → SizeOf (Computability.Encoding α Γ) | null | false |
ConvexOn.isMinOn_of_leftDeriv_eq_zero | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x : ℝ}, ConvexOn ℝ S f → x ∈ interior S → derivWithin f (Set.Iio x) x = 0 → IsMinOn f S x | null | true |
Std.HashSet.Equiv.congr_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α}, m₁.Equiv m₂ → (m₃.Equiv m₁ ↔ m₃.Equiv m₂) | null | true |
Lean.Linter.linter.unusedVariables.analyzeTactics | Lean.Linter.UnusedVariables | Lean.Option Bool | Enables linting variables defined in tactic blocks, may be expensive for complex proofs | true |
Polynomial.degree_wronskian_lt_add | Mathlib.RingTheory.Polynomial.Wronskian | ∀ {R : Type u_1} [inst : CommRing R] {a b : Polynomial R}, a ≠ 0 → b ≠ 0 → (a.wronskian b).degree < a.degree + b.degree | Degree of `W(a,b)` is strictly less than the sum of degrees of `a` and `b` (both nonzero). | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toArray_rcc_succ_right_eq_append_map._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...=n).toArray = (m...=n).toList.toArray | null | false |
RingCon.mk.injEq | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (toCon : Con R)
(add' : ∀ {w x y z : R}, toCon.toSetoid w x → toCon.toSetoid y z → toCon.toSetoid (w + y) (x + z)) (toCon_1 : Con R)
(add'_1 : ∀ {w x y z : R}, toCon_1.toSetoid w x → toCon_1.toSetoid y z → toCon_1.toSetoid (w + y) (x + z)),
({ toCon := toCon, add' ... | null | true |
PositiveLinearMap.preGNS_norm_def' | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : PartialOrder A] [inst_2 : Module ℂ A] [inst_3 : StarRing A]
[inst_4 : StarOrderedRing A] [inst_5 : SelfAdjointDecompose A] [inst_6 : StarModule ℂ A]
[inst_7 : IsScalarTower ℂ A A] (f : A →ₚ[ℂ] ℂ) (a : f.PreGNS), ‖a‖ = √‖f (star (f.ofPreGNS a) * f.ofPreGNS a)‖ | null | true |
AddSubsemigroup.instCompleteLattice._proof_8 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] (a b c : AddSubsemigroup M), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
tendsto_norm_inv_mul_self_nhdsNE | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : NormedGroup E] (a : E),
Filter.Tendsto (fun x => ‖x⁻¹ * a‖) (nhdsWithin a {a}ᶜ) (nhdsWithin 0 (Set.Ioi 0)) | null | true |
NonemptyInterval.toDualProdHom | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → NonemptyInterval α ↪o αᵒᵈ × α | `toDualProd` as an order embedding. | true |
Lean.Compiler.LCNF.ExtractClosed.extractFVar._unsafe_rec | Lean.Compiler.LCNF.ExtractClosed | Lean.FVarId → Lean.Compiler.LCNF.ExtractClosed.ExtractM Unit | null | false |
CategoryTheory.leftAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y] {f : X ⟶ Y} {g : ᘁX ⟶ Z},
CategoryTheory.CategoryStruct.comp (ᘁf) g =
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
HomologicalComplex.instHasFilteredColimitsOfSize | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C],
CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', max t v, max (max t u) v} (HomologicalComplex C c) | null | true |
ImportGraph.System.FilePath.Modules.root._default | ImportGraph.Util.Modules | Lean.Name | null | false |
Lean.Lsp.DependencyBuildMode.never.sizeOf_spec | Lean.Data.Lsp.Extra | sizeOf Lean.Lsp.DependencyBuildMode.never = 1 | null | true |
LinearMap.tensorProduct._proof_5 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid N]
[inst_6 : Module R N], IsScalarTower R A (TensorProduct R A M →ₗ[A] TensorProduct R A N) | null | false |
Std.Broadcast.noConfusion | Std.Sync.Broadcast | {P : Sort u} →
{α : Type} →
{t : Std.Broadcast α} →
{α' : Type} → {t' : Std.Broadcast α'} → α = α' → t ≍ t' → Std.Broadcast.noConfusionType P t t' | null | false |
UInt64.sub_eq_add_neg | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a - b = a + -b | null | true |
Mathlib.Meta.FunProp.MorApplication.ctorIdx | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.MorApplication → ℕ | null | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ}
[inst_4 : n.AtLeastTwo], (0 < OfNat.ofNat n) = True | null | false |
Submodule._aux_Mathlib_Analysis_InnerProductSpace_Orthogonal___unexpand_Submodule_IsOrtho_1 | Mathlib.Analysis.InnerProductSpace.Orthogonal | Lean.PrettyPrinter.Unexpander | null | false |
Lean.Meta.Sym.State.inferType._default | Lean.Meta.Sym.SymM | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Expr | null | false |
Matroid.cRk_closure_congr | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {X Y : Set α} [M.InvariantCardinalRank], M.closure X = M.closure Y → M.cRk X = M.cRk Y | null | true |
Nat.dfold_add._auto_5 | Init.Data.Nat.Fold | Lean.Syntax | null | false |
Lean.Json.json_ | Lean.Data.Json.Elab | Lean.ParserDescr | Json string syntax. | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.mk.injEq | Lean.Compiler.LCNF.ExplicitRC | ∀ (liveVars liveVars_1 : Lean.Compiler.LCNF.LiveVars✝),
({ liveVars := liveVars } = { liveVars := liveVars_1 }) = (liveVars = liveVars_1) | null | true |
Fintype.toOrderBot._proof_1 | Mathlib.Data.Fintype.Order | ∀ (α : Type u_1) [inst : Fintype α] (a : α), ∃ x, x ∈ Finset.univ | null | false |
mem_const_vsub_affineSegment | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P),
p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y | null | true |
IO.CancelToken.noConfusion | Init.System.CancelToken | {P : Sort u} → {t t' : IO.CancelToken} → t = t' → IO.CancelToken.noConfusionType P t t' | null | false |
TopologicalSpace.OpenNhdsOf.instDistribLattice._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} (a b : TopologicalSpace.OpenNhdsOf x),
a ≤ { toOpens := a.toOpens ⊔ b.toOpens, mem' := ⋯ } | null | false |
QuadraticMap.linMulLin.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A]
[inst_6 : IsScalarTower R A A] (f f_1 : M →ₗ[R] A),
f = f_1 → ∀ (g g_1 : M →ₗ[R] A), g = g_1 → Quadrat... | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (lowerBound : α),
Std.DTreeMap.Internal.Impl.pruneLE✝ Std.DTreeMap.Internal.Impl.leaf lowerBound = Std.DTreeMap.Internal.Impl.leaf | null | true |
SimpleGraph.Walk.darts_dropUntil_suffix_darts | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v w u : V} [inst : DecidableEq V] (p : G.Walk v w) (h : u ∈ p.support),
(p.dropUntil u h).darts <:+ p.darts | null | true |
_private.Lean.Meta.NatTable.0.Lean.mkNatLookupTable.go._unary._proof_7 | Lean.Meta.NatTable | ∀ (es : Array Lean.Expr) (start stop : ℕ) (hstart : start < stop) (hstop : stop ≤ es.size) (h : ¬start + 1 = stop),
(invImage
(fun x =>
PSigma.casesOn x fun start stop =>
PSigma.casesOn stop fun stop hstart => PSigma.casesOn hstart fun hstart hstop => (stop, stop - start))
Prod.i... | null | false |
Std.DTreeMap.Const.contains_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{f : Option β → Option β},
(Std.DTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).isSome else t.contains k' | null | true |
CategoryTheory.Linear.oppositeCategory._proof_1 | Mathlib.CategoryTheory.Linear.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (x x_1 : Cᵒᵖ)
(x_2 x_3 : x ⟶ x_1),
(CategoryTheory.opEquiv x x_1).toFun (x_2 + x_3) = (CategoryTheory.opEquiv x x_1).toFun (x_2 + x_3) | null | false |
SetRel.IsCover.anti | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {U : SetRel X X} {s t N : Set X}, s ⊆ t → U.IsCover t N → U.IsCover s N | null | true |
_private.Mathlib.RingTheory.Etale.Field.0.Algebra.FormallyEtale.of_isSeparable._simp_1_1 | Mathlib.RingTheory.Etale.Field | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
Filter.Eventually.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∀ᶠ (x : α) in f, q x | null | true |
Set.cardinalMk_Iic | Mathlib.Order.Interval.Set.Card | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Cardinal.mk ↑(Set.Iic a) = ↑(Finset.Iic a).card | null | true |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_6 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ | null | false |
real_inner_div_norm_mul_norm_eq_neg_one_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
inner ℝ x y / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x | The inner product of two vectors, divided by the product of their
norms, has value -1 if and only if they are nonzero and one is
a negative multiple of the other. | true |
PFunctor.M.dest_mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : ↑F F.M), (PFunctor.M.mk x).dest = x | null | true |
Lean.SubExpr.Pos.pushNthBindingDomain | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof? | Lean.Meta.Tactic.Grind.Split | Lean.MVarId → Lean.MetaM (Option Lean.Expr) | Given a `mvarId` associated with a subgoal created by `splitCore`, inspects the
proof term assigned to `mvarId` and tries to extract the proof of `False` that does not
depend on hypotheses introduced in the subgoal.
For example: suppose the subgoal is of the form `p → q → False` where `p` and `q` are new
hypotheses int... | true |
Std.ExtTreeMap.maxKey_eq_iff_mem_and_forall | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {he : t ≠ ∅} {km : α}, t.maxKey he = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | null | true |
AlgebraNorm.algebraNormClass | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} [inst : SeminormedCommRing R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S],
AlgebraNormClass (AlgebraNorm R S) R S | null | true |
Lean.Compiler.LCNF.ToMonoM.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ToMono | ∀ (typeParams : Lean.FVarIdHashSet), sizeOf { typeParams := typeParams } = 1 + sizeOf typeParams | null | true |
LieAlgebra.hasTrivialRadical_iff | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.HasTrivialRadical R L ↔ LieAlgebra.radical R L = ⊥ | null | true |
IsSelfAdjoint.cfc_arg | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u : A), IsSelfAdjoint (cfc (Complex.ofReal ∘ Complex.arg) u) | null | true |
ContinuousMap.id._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ (α : Type u_1) [inst : TopologicalSpace α], Continuous id | null | false |
CategoryTheory.CardinalDirectedPoset.functorOfPredicateSet | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | {κ : Cardinal.{u}} →
[inst : Fact κ.IsRegular] →
{J : CategoryTheory.CardinalDirectedPoset κ} →
(P : Set ↑J.obj → Prop) →
[∀ (S : Subtype P), CategoryTheory.IsCardinalFiltered (↑↑S) κ] →
CategoryTheory.Functor (Subtype P) (CategoryTheory.CardinalDirectedPoset κ) | Given a predicate `P : Set J.obj → Prop` on the underlying type
of `J : CardinalDirectedPoset κ` such that all the subsets satisfying `P`
are `κ`-filtered, this is the functor `Subtype P ⥤ CardinalDirectedPoset κ`
which sends a subset `S` of `J` satisfying `P` to the induced
partially ordered type `J`, as an object in ... | true |
Fin.tail_vecCons | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} (x : α) (t : Fin n → α), Fin.tail (Matrix.vecCons x t) = t | null | true |
WittVector.IsocrystalHom.mk.inj | Mathlib.RingTheory.WittVector.Isocrystal | ∀ {p : ℕ} {inst : Fact (Nat.Prime p)} {k : Type u_1} {inst_1 : CommRing k} {inst_2 : CharP k p}
{inst_3 : PerfectRing k p} {V : Type u_2} {inst_4 : AddCommGroup V} {inst_5 : WittVector.Isocrystal p k V}
{V₂ : Type u_3} {inst_6 : AddCommGroup V₂} {inst_7 : WittVector.Isocrystal p k V₂}
{toLinearMap : V →ₗ[Fraction... | null | true |
DirectLimit.instGroupWithZero._proof_16 | 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 : Nonempty ι]
[inst_5 : (... | null | false |
Lean.Meta.LazyDiscrTree.MatchResult.push | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.MatchResult α → ℕ → Array α → Lean.Meta.LazyDiscrTree.MatchResult α | null | true |
Std.DHashMap.Internal.Raw₀.getKey_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : (a : α) → β a → Bool} {k : α} (h : (↑m).WF)
{h' : (Std.DHashMap.Internal.Raw₀.filter f m).contains k = true},
(Std.DHashMap.Internal.Raw₀.filter f m).get... | null | true |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rintroContinue.loop._unsafe_rec | Lean.Elab.Tactic.RCases | {α : Type} →
Lean.Syntax →
Lean.TSyntaxArray `rintroPat →
Option Lean.Term →
(Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α) →
ℕ → Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.upShadow) = ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t | null | false |
CentroidHom.toEndRingHom_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ (α : Type u_5) [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), (CentroidHom.toEndRingHom α) f = f.toEnd | null | true |
AddSubgroup.exists_finite_of_isAddFG | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [IsAddFG ↥H], ∃ S, S.Finite ∧ AddSubgroup.closure S = H | null | true |
IntermediateField.eq_of_le_of_finrank_eq | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
[FiniteDimensional K ↥E], F ≤ E → Module.finrank K ↥F = Module.finrank K ↥E → F = E | If `F ≤ E` are two intermediate fields of `L / K` such that `[F : K] = [E : K]` are finite,
then `F = E`. | true |
HomotopicalAlgebra.instHasTwoOutOfThreePropertyFullSubcategoryWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{P : CategoryTheory.ObjectProperty C} [(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences P.FullSubcategory).HasTwoOutOfThreeProperty | null | true |
Lean.Grind.ISize.natCast | Init.GrindInstances.Ring.SInt | NatCast ISize | null | true |
CategoryTheory.SingleFunctors.shiftIso_zero_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (a : A) (X : C),
(F.shiftIso 0 a a ⋯).hom.app X = (CategoryTheory.shi... | null | true |
LieModule.maxTrivEquiv._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} {N : Type u_4} [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]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[ins... | null | false |
Finsupp.comapDomain_inl_sumElim | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Zero γ] (f : α →₀ γ) (g : β →₀ γ),
Finsupp.comapDomain Sum.inl (f.sumElim g) ⋯ = f | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_eq_getKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Lean.Compiler.IR.Checker.0.Lean.IR.Checker.checkExpr.match_4 | Lean.Compiler.IR.Checker | (motive : Lean.IR.Expr → Sort u_1) →
(e : Lean.IR.Expr) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.pap f ys)) →
((x : Lean.IR.VarId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ap x ys)) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.fap ... | null | false |
Set.vsub_iUnion | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_3} [inst : VSub α β] (s : Set β) (t : ι → Set β),
s -ᵥ ⋃ i, t i = ⋃ i, s -ᵥ t i | null | true |
WithTop.forall_ne_top | Mathlib.Order.WithBot | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), x ≠ ⊤ → p x) ↔ ∀ (x : α), p ↑x | null | true |
CategoryTheory.Limits.coneOfConeCurry_pt | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) {D : CategoryTheory.Limits.DiagramOfCones (CategoryTheory.Functor.curry.obj G)}
(Q : (... | null | true |
CategoryTheory.MonoidalPreadditive.instAdditiveFunctorFlipCurriedTensor | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C],
(CategoryTheory.MonoidalCategory.curriedTensor C).flip.Additive | null | true |
ExistsContDiffBumpBase.y_eq_one_of_mem_closedBall | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] {D : ℝ} {x : E},
0 < D → x ∈ Metric.closedBall 0 (1 - D) → ExistsContDiffBumpBase.y D x = 1 | null | true |
ModuleCat.ExtendRestrictScalarsAdj.Counit.map._proof_3 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {Y : ModuleCat S} (r : R)
(s : S),
{ toFun := fun y => (r • s) • y, map_add' := ⋯, map_smul' := ⋯ } =
(RingHom.id R) r • { toFun := fun y => s • y, map_add' := ⋯, map_smul' := ⋯ } | null | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_2 | Mathlib.RingTheory.Support | ∀ {A : Type u_1} {B : outParam (Type u_2)} {inst : Membership B A} {inst_1 : LE A} [self : IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.