name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
String.Slice.Pattern.Model.CharPred.Decidable.instPatternModelForallCharPropOfDecidablePred | Init.Data.String.Lemmas.Pattern.Pred | {p : Char → Prop} → [DecidablePred p] → String.Slice.Pattern.Model.PatternModel p | null | true |
TopModuleCat.cokerπ._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N),
Continuous (↑(TopModuleCat.Hom.hom φ)).range.mkQ.toFun | null | false |
Subarray.size_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
Std.Slice.size (Std.Roo.Sliceable.mkSlice xs (lo<...hi)) = min hi (Std.Slice.size xs) - (lo + 1) | null | true |
CountableInterFilter | Mathlib.Order.Filter.CountableInter | {α : Type u_2} → Filter α → Prop | A filter `l` has the countable intersection property if for any countable collection
of sets `s ∈ l` their intersection belongs to `l` as well. | true |
StrongDual.coe_toWeakDual | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | ∀ {𝕜 : Type u_2} {E : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E]
(x' : StrongDual 𝕜 E), ⇑(StrongDual.toWeakDual x') = ⇑x' | null | true |
RBTree.RBNode.reverse_reverse | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (t : RBTree.RBNode α), t.reverse.reverse = t | null | true |
Std.DTreeMap.Internal.Impl.Const.toArray_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
{f : α → β → Option γ} (h : t.WF),
Std.DTreeMap.Internal.Impl.Const.toArray (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl =
Array.filterMap (fun p => Option.map (fun x => (p.1, x)) (f p.1 p.2)) (Std.DTre... | null | true |
Module.Basis.instMulAction | Mathlib.LinearAlgebra.Basis.SMul | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{G : Type u_5} →
[inst_3 : Group G] →
[inst_4 : DistribMulAction G M] → [SMulCommClass G R M] → MulAction G (Module.Basis ... | null | true |
DomAddAct.instT3Space | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M] [T3Space M], T3Space Mᵈᵃᵃ | null | true |
AddSubgroup.add | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : AddGroup G] → (H : AddSubgroup G) → Add ↥H | An `AddSubgroup` of an `AddGroup` inherits an addition. | true |
ClosedSubmodule.mapEquiv_inf_eq | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module R M] [inst_4 : AddCommMonoid N] [inst_5 : TopologicalSpace N]
[inst_6 : Module R N] (f : M ≃L[R] N) {s t : ClosedSubmodule R M},
(ClosedSubmodule.mapEquiv f) (s ⊓ t) = (Clos... | null | true |
Lean.Lsp.SymbolKind.null.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.null = 1 | null | true |
CategoryTheory.Limits.cokernel.mapIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {X' Y' : C} (f' : X' ⟶ Y')
[inst_3 : CategoryTheory.Limits.HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y')
(w : CategoryTheory.CategoryS... | null | false |
adaptationNoteTermElab | Mathlib.Tactic.AdaptationNote | Lean.Elab.Term.TermElab | Elaborator for adaptation notes. | true |
CategoryTheory.monadicCreatesLimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(R : CategoryTheory.Functor D C) →
[CategoryTheory.MonadicRightAdjoint R] → CategoryTheory.CreatesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} R | Any monadic functor creates limits. | true |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_5 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
a ≤ ⟨((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2), ⋯⟩ | null | false |
SmoothBumpFunction.continuous | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c) [inst_5 : FiniteDimensional ℝ E] [T2Space M] [IsManifold I (↑... | null | true |
HasDerivWithinAt.star | Mathlib.Analysis.Calculus.Deriv.Star | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {F : Type v} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace 𝕜 F] [inst_4 : StarAddMonoid F] [StarModule 𝕜 F] [ContinuousStar F] {f : 𝕜 → F} {f' : F} {x : 𝕜}
[TrivialStar 𝕜] {s : Set 𝕜}, HasDerivWithinAt f f' s x → HasDerivWithin... | null | true |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_indicator_const_iff_forall_eventually._simp_1_1 | Mathlib.Topology.IndicatorConstPointwise | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {x y : X}, ({x}ᶜ ∈ nhds y) = (y ≠ x) | null | false |
CategoryTheory.Functor.CoconeTypes.IsColimit.isColimitCore._proof_3 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {F : CategoryTheory.Functor J (Type u_2)}
{c : F.CoconeTypes} (hc : c.IsColimit) (c' : F.CoconeTypes) (j : J), hc.desc c' ∘ c.ι j = c'.ι j | null | false |
Finset.sub_subset_iff | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Sub α] {s t u : Finset α}, s - t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x - y ∈ u | null | true |
_private.Init.Grind.FieldNormNum.0.Lean.Grind.Field.NormNum.ofRat_div'._proof_1_2 | Init.Grind.FieldNormNum | ∀ {b : ℚ}, ¬0 ≤ b.num → ¬b.num ≤ 0 → False | null | false |
_private.Mathlib.Order.Compare.0.Ordering.Compares.le_total.match_1_1 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (motive : (x : Ordering) → x.Compares a b → Prop) (x : Ordering)
(x_1 : x.Compares a b),
(∀ (h : Ordering.lt.Compares a b), motive Ordering.lt h) →
(∀ (h : Ordering.eq.Compares a b), motive Ordering.eq h) →
(∀ (h : Ordering.gt.Compares a b), motive Ordering.g... | null | false |
Fin.preimage_rev_Icc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.rev ⁻¹' Set.Icc i j = Set.Icc j.rev i.rev | null | true |
CategoryTheory.Limits.reflectsLimit_of_natIso | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J C)
{F G : CategoryTheory.Functor C D} (h : F ≅ G) [CategoryTheory.Limits.ReflectsLimit K F],
CategoryTheor... | Transfer reflection of a limit along a natural isomorphism in the functor. | true |
BitVec.cons_induction | Init.Data.BitVec.Bootstrap | ∀ {motive : (w : ℕ) → BitVec w → Prop},
motive 0 BitVec.nil →
(∀ {w : ℕ} (b : Bool) (bv : BitVec w), motive w bv → motive (w + 1) (BitVec.cons b bv)) →
∀ {w : ℕ} (x : BitVec w), motive w x | null | true |
instHasExactLimitsOfShapeDiscreteAddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | ∀ {J : Type u}, CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete J) AddCommGrpCat | null | true |
_private.Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits.0.ProfiniteGrp.toLimitFun_continuous._simp_1_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
ContinuousLinearMapWOT.postcompCLM._proof_3 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_4} {𝕜₂ : Type u_5} {𝕜₃ : Type u_6} {E : Type u_2} {F : Type u_1} {G : Type u_3} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : To... | null | false |
CategoryTheory.Limits.Types.coendRel | Mathlib.CategoryTheory.Limits.Types.End | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
(F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max w u)))) →
(j : J) × (F.obj (Opposite.op j)).obj j → (j : J) × (F.obj (Opposite.op j)).obj j → Prop | The relation on the sigma type `(W : J) × (F.obj (op W)).obj W` used to construct explicit
coends in `Type`. Two terms `⟨j, x⟩` and `⟨j', x'⟩` are related if and only if there is a
morphism `f : j ⟶ j'` in `J` and an element `y : (F.obj (op j')).obj j` such that
`(F.map f.op).app j y = x` and `(F.obj _).map f y = x'`, ... | true |
Lean.Meta.Grind.Arith.CommRing.Semiring.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (id : ℕ) (type : Lean.Expr) (u : Lean.Level) (semiringInst : Lean.Expr)
(addFn? mulFn? powFn? natCastFn? : Option Lean.Expr)
(denote : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.SemiringExpr)
(vars : Lean.PArray Lean.Expr) (varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing... | null | true |
CategoryTheory.Limits.hasColimit_unop_of_hasLimit | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) [CategoryTheory.Limits.HasLimit F], CategoryTheory.Limits.HasColimit F.unop | null | true |
Lean.Grind.AddCommGroup.neg_sub | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] (a b : M), -(a - b) = b - a | null | true |
OreLocalization.add_smul | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddCommMonoid X] [inst_3 : Module R X] (y z : OreLocalization S R) (x : OreLocalization S X),
(y + z) • x = y • x + z • x | null | true |
Dense.ciSup | Mathlib.Topology.Order.IsLUB | ∀ {γ : Type u_2} {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLattice α]
[ClosedIicTopology α] {f : γ → α} [inst_3 : TopologicalSpace γ] {S : Set γ},
Dense S → Continuous f → BddAbove (Set.range f) → ⨆ s, f ↑s = ⨆ i, f i | The supremum of a bounded above, continuous function on a dense set is equal to the supremum on
the universe. | true |
Polynomial.instCharP | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : ℕ) [h : CharP R p], CharP (Polynomial R) p | null | true |
String.Slice.find?_char_eq_find?_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.find? c = s.find? fun x => x == c | null | true |
Part.Fix.exists_fix_le_approx | Mathlib.Control.LawfulFix | ∀ {α : Type u_1} {β : α → Type u_2} (f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)) (x : α),
∃ i, Part.fix (⇑f) x ≤ Part.Fix.approx (⇑f) i x | null | true |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.recOn | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
motive CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.unit →
((a : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C... | null | false |
Submodule.smithNormalForm._proof_4 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R], InvariantBasisNumber R | null | false |
MeasureTheory.integrableOn_singleton._auto_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax | null | false |
Lean.Server.ILeanMap | Lean.Server.References | Type | Paths and module references for every module name. Loaded from `.ilean` files. | true |
alternatingGroup.isCyclic_of_card_le_three | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], Nat.card α ≤ 3 → IsCyclic ↥(alternatingGroup α) | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.cooper_unsat'_helper | Init.Data.Int.Linear | ∀ {a b d c k x : ℤ}, d > 0 → x = k * d + c → a ≤ x → x ≤ b → ¬b < Int.Internal.Linear.cdiv (a - c) d * d + c | null | true |
RatFunc.aeval_X_left_eq_algebraMap | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] (p : Polynomial K),
(Polynomial.aeval RatFunc.X) p = (algebraMap (Polynomial K) (RatFunc K)) p | null | true |
ContinuousLinearMap.inCoordinates.congr_simp | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → AddCommMonoid (E x)]
[inst_1 : NormedAddCommGroup F] [inst_2 : TopologicalSpace B] [inst_3 : (x : B) → TopologicalSpace (E x)]
{𝕜₁ : Type u_5} {𝕜₂ : Type u_6} [inst_4 : NontriviallyNormedField 𝕜₁] [inst_5 : NontriviallyNormedField 𝕜₂]
{σ : �... | null | true |
Computation.map_congr | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} {s1 s2 : Computation α} {f : α → β},
s1.Equiv s2 → (Computation.map f s1).Equiv (Computation.map f s2) | null | true |
Std.IterM.DefaultConsumers.forIn'.wf._unary._proof_1 | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {m : Type u_1 → Type u_3} {α β : Type u_1} [inst : Std.Iterator α m β] (γ : Type u_2)
(PlausibleForInStep : β → γ → ForInStep γ → Prop) (wf : Std.IteratorLoop.WellFounded α m PlausibleForInStep)
(P : β → Prop),
WellFounded
(invImage (fun x => PSigma.casesOn x fun it init => PSigma.casesOn init fun init hP =... | null | false |
ENNReal.sInf_add | Mathlib.Basic.ENNReal.Operations | ∀ {a : ENNReal} {s : Set ENNReal}, sInf s + a = ⨅ b ∈ s, b + a | null | true |
CategoryTheory.Kleisli.Hom.mk.inj | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {T : CategoryTheory.Monad C} {c c' : CategoryTheory.Kleisli T}
{of of_1 : c.of ⟶ T.obj c'.of}, { of := of } = { of := of_1 } → of = of_1 | null | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_6 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x x_1 : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))) (x_2 x_3 : Cᵒᵖ) (x_4 : x_2 ⟶... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Hom.0.NonUnitalStarAlgHom.toOrderEmbedding._proof_1 | Mathlib.Analysis.CStarAlgebra.Hom | ∀ {A : Type u_2} {B : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A]
[inst_3 : NonUnitalCStarAlgebra B] [inst_4 : PartialOrder B] [StarOrderedRing B] (φ : A →⋆ₙₐ[ℂ] B)
(hφ : Function.Injective ⇑φ) {a b : A}, { toFun := ⇑φ, inj' := hφ } a ≤ { toFun := ⇑φ, inj' := hφ } b ↔ a ... | null | false |
Lean.Lsp.Range.mk.injEq | Lean.Data.Lsp.BasicAux | ∀ (start «end» start_1 end_1 : Lean.Lsp.Position),
({ start := start, «end» := «end» } = { start := start_1, «end» := end_1 }) = (start = start_1 ∧ «end» = end_1) | null | true |
Lean.Parser.ModuleParserState.mk.sizeOf_spec | Lean.Parser.Module | ∀ (pos : String.Pos.Raw) (recovering hasLeading : Bool),
sizeOf { pos := pos, recovering := recovering, hasLeading := hasLeading } =
1 + sizeOf pos + sizeOf recovering + sizeOf hasLeading | null | true |
Aesop.RuleApplication.casesOn | Aesop.RuleTac.Basic | {motive : Aesop.RuleApplication → Sort u} →
(t : Aesop.RuleApplication) →
((goals : Array Aesop.Subgoal) →
(postState : Lean.Meta.SavedState) →
(scriptSteps? : Option (Array Aesop.Script.LazyStep)) →
(successProbability? : Option Aesop.Percent) →
motive
... | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_measurableSet | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α} (n : ℕ),
MeasurableSet (MeasureTheory.SignedMeasure.restrictNonposSeq✝ s i n) | null | true |
Std.PRange.Least?.rec | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
((least? : Option α) → motive { least? := least? }) → (t : Std.PRange.Least? α) → motive t | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.isIso_iff_finrank_eq._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {R S : CommRingCat} (f : R ⟶ S),
AlgebraicGeometry.IsFinite (AlgebraicGeometry.Spec.map f) = (CommRingCat.Hom.hom f).Finite | null | false |
Lean.HasConstCache._sizeOf_1 | Lean.Util.HasConstCache | {declNames : Array Lean.Name} → Lean.HasConstCache declNames → ℕ | null | false |
_private.Mathlib.Order.Bounds.Basic.0.lowerBounds_le_upperBounds_of_nonempty_inter.match_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} {s s' : Set α} (motive : (s ∩ s').Nonempty → Prop) (h : (s ∩ s').Nonempty),
(∀ (x : α) (hx : x ∈ s) (hx' : x ∈ s'), motive ⋯) → motive h | null | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.Internal.memcmpSlice._proof_1 | Init.Data.String.Pattern.Basic | ∀ (lhs rhs : String.Slice) (lstart rstart len : String.Pos.Raw),
len.offsetBy lstart ≤ lhs.rawEndPos → len.offsetBy (lstart.offsetBy lhs.startInclusive.offset) ≤ lhs.str.rawEndPos | null | false |
AddGroupSeminorm.toSeminormedAddGroup._proof_3 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x x_1 : E), f (-x + x_1) = f (-x + x_1) | null | false |
SimplexCategory.rev_map_σ | Mathlib.AlgebraicTopology.SimplexCategory.Rev | ∀ {n : ℕ} (i : Fin (n + 1)), SimplexCategory.rev.map (SimplexCategory.σ i) = SimplexCategory.σ i.rev | null | true |
BitVec.getElem_concat_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {b : Bool} {x : BitVec w} {i : ℕ} (h : i + 1 < w + 1), (x.concat b)[i + 1] = x[i] | null | true |
IsTrans.recOn | Mathlib.Order.Defs.Unbundled | {α : Sort u_1} →
{r : α → α → Prop} →
{motive : IsTrans α r → Sort u} →
(t : IsTrans α r) → ((trans : ∀ (a b c : α), r a b → r b c → r a c) → motive ⋯) → motive t | null | false |
Std.WP._aux_Std_WP_Triple_Basic___macroRules_Std_WP_tripleExceptPost_1 | Std.WP.Triple.Basic | Lean.Macro | null | false |
CategoryTheory.Functor.toPseudofunctor'_mapComp | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {I : Type u_1} {B : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} I] [inst_1 : CategoryTheory.Bicategory B]
[inst_2 : CategoryTheory.Bicategory.Strict B] (F : CategoryTheory.Functor I B)
{a b c : CategoryTheory.LocallyDiscrete I} (f : a ⟶ b) (g : b ⟶ c),
F.toPseudofunctor'.mapComp f g = CategoryTheory.eq... | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg.0.Matrix.IsTotallyNonneg.transpose._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (A : Matrix m n α) (r : l → m) (c : o → n),
A.transpose.submatrix c r = (A.submatrix r c).transpose | null | false |
tensorKaehlerQuotKerSqEquiv._proof_16 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
IsScalarTower P S (TensorProduct (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S Ω[P ⧸ RingHom.ker (algebraMap P S) ^ 2⁄R]) | null | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.mkInfoTree | Lean.Elab.Command | Lean.Name → Lean.Syntax → Lean.PersistentArray Lean.Elab.InfoTree → Lean.Elab.Command.CommandElabM Lean.Elab.InfoTree | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction.0._proof_12 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | { len := 0 }.len ≤ 2 | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt64.reduceLT._regBuiltin.UInt64.reduceLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.160 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Nat.eq_one_of_mul_eq_one_right | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, m * n = 1 → m = 1 | null | true |
CategoryTheory.Injective.mk | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : C},
(∀ {X Y : C} (g : X ⟶ J) (f : X ⟶ Y) [CategoryTheory.Mono f], ∃ h, CategoryTheory.CategoryStruct.comp f h = g) →
CategoryTheory.Injective J | null | true |
Set.isScalarTower'' | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SMul α β] [inst_1 : SMul α γ] [inst_2 : SMul β γ]
[IsScalarTower α β γ], IsScalarTower (Set α) (Set β) (Set γ) | null | true |
Subfield.isTotallyReal_bot | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ (K : Type u_2) [inst : Field K] [CharZero K], NumberField.IsTotallyReal ↥⊥ | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.card_of_cycleType_singleton._proof_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {n : ℕ}, 2 ≤ n → ¬n = 0 | null | false |
_private.Mathlib.Lean.Meta.Simp.0.Lean.Meta.simpEq.match_1 | Mathlib.Lean.Meta.Simp | (motive : Option Lean.Expr → Sort u_1) →
(lhspf? : Option Lean.Expr) →
((lhspf : Lean.Expr) → motive (some lhspf)) → ((x : Option Lean.Expr) → motive x) → motive lhspf? | null | false |
HNNExtension.lift | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
{φ : ↥A ≃* ↥B} →
{H : Type u_2} →
[inst_1 : Group H] →
(f : G →* H) → (x : H) → (∀ (a : ↥A), x * f ↑a = f ↑(φ a) * x) → HNNExtension G A B φ →* H | Define a function `HNNExtension G A B φ →* H`, by defining it on `G` and `t` | true |
CategoryTheory.kernelCokernelCompSequence.isColimit._simp_1 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {Z : C} {f g : X ⊞ Y ⟶ Z},
(f = g) =
(CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl f =
CategoryTheory.CategoryStruct.c... | null | false |
Fin.preimage_natAdd_Ioi_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.natAdd m ⁻¹' Set.Ioi (Fin.natAdd m i) = Set.Ioi i | null | true |
CategoryTheory.ChosenPullbacksAlong.pullbackCone | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y Z X : C} →
(f : Y ⟶ X) → (g : Z ⟶ X) → [CategoryTheory.ChosenPullbacksAlong g] → CategoryTheory.Limits.PullbackCone f g | The canonical pullback cone from the data of a chosen pullback of `f` along `g`. | true |
mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Mul α] {s : Set α} {x : α} (a : α), x ∈ s → a * x ∈ a • s | null | true |
CategoryTheory.Limits.HasLimitsOfSize.has_limits_of_shape._autoParam | Mathlib.CategoryTheory.Limits.HasLimits | Lean.Syntax | null | false |
CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.isNormalEpiCategory | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
[∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso (CategoryTheory.Abelian.coimageImageComparison f)]
[CategoryTheory.Limits.Ha... | A category with finite products in which coimage-image comparisons are all isomorphisms
is a normal epi category.
| true |
Lean.Meta.GeneralizeArg._sizeOf_inst | Lean.Meta.Tactic.Generalize | SizeOf Lean.Meta.GeneralizeArg | null | false |
codisjoint_himp_self_left | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], Codisjoint (x ⇨ y) x | null | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.Code.toImpure.match_1 | Lean.Compiler.LCNF.ToImpure | (motive : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure × Bool → Sort u_1) →
(x : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure × Bool) →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) → (keep : Bool) → motive (p, keep)) → motive x | null | false |
Preord | Mathlib.Order.Category.Preord | Type (u_1 + 1) | The category of preorders. | true |
DifferentiableAt.fun_add_iff_left | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{x : E}, DifferentiableAt 𝕜 g x → (DifferentiableAt 𝕜 (fun i => f i + g i) x ↔ DifferentiableAt ... | Eta-expanded form of `DifferentiableAt.add_iff_left` | true |
_private.Mathlib.Probability.Process.Predictable.0.MeasureTheory.IsStronglyPredictable.of_measurable_add_one.match_1_12 | Mathlib.Probability.Process.Predictable | ∀ {Ω : Type u_1} (motive : ℕ × Ω → Prop) (h : ℕ × Ω), (∀ (n : ℕ) (ω : Ω), motive (n, ω)) → motive h | null | false |
Lean.Elab.Tactic.Grind.replaceMainGoal | Lean.Elab.Tactic.Grind.Basic | List Lean.Meta.Grind.Goal → Lean.Elab.Tactic.Grind.GrindTacticM Unit | null | true |
Lean.PersistentArray.toList | Lean.Data.PersistentArray | {α : Type u} → Lean.PersistentArray α → List α | null | true |
IsAlgClosed.roots_eq_zero_iff_degree_nonpos | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, p.roots = 0 ↔ p.degree ≤ 0 | null | true |
MonoidAlgebra.map_one | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Monoid M]
(f : R →+* S), MonoidAlgebra.map (↑f) 1 = 1 | null | true |
PMF.mem_support_ofFintype_iff | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} [inst : Fintype α] {f : α → ENNReal} (h : ∑ a, f a = 1) (a : α),
a ∈ (PMF.ofFintype f h).support ↔ f a ≠ 0 | null | true |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.aux_bdd._simp_1_4 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, (n ∈ p.support) = (p.coeff n ≠ 0) | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ensureArgType | Lean.Elab.App | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Elab.TermElabM Lean.Expr | null | true |
String.Slice.Pos.revSkipWhile_cast | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.BackwardPattern pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s t : String.Slice} (hst : s.copy = t.copy) {pos : s.Pos},
(pos.cast hst).revSkipWhile pat = (pos.revSkipWhile pat).cast hst | null | true |
CharZero.neg_eq_self_iff | Mathlib.Algebra.Ring.CharZero | ∀ {R : Type u_2} [inst : NonAssocRing R] [NoZeroDivisors R] [CharZero R] {a : R}, -a = a ↔ a = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.