name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LieAlgebra.e₇ | Mathlib.Algebra.Lie.SerreConstruction | (R : Type u) → [CommRing R] → Type u | true |
Unitization.inr_le_iff._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
EReal.instCommMonoidWithZero._proof_3 | Mathlib.Data.EReal.Inv | ∀ (x : EReal), npowRecAuto 0 x = 1 | false |
Subsemigroup.gc_map_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N),
GaloisConnection (Subsemigroup.map f) (Subsemigroup.comap f) | true |
Equiv.mulEquiv._proof_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Mul β] (x y : α), e.toFun (x * y) = e.toFun x * e.toFun y | false |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.isFractional_span_singleton.match_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(x : P) (motive : (∃ b, IsLocalization.IsInteger R (↑b • x)) → Prop) (x_1 : ∃ b, IsLocalization.IsInteger R (↑b • x)),
(∀ (a : ↥S) (ha : IsLocalization.IsInteger R (↑a • x)), motive ⋯) → motive x_1 | false |
_private.Mathlib.Analysis.Convex.Combination.0.Finset.centerMass_congr._proof_1_4 | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_2} {E : Type u_3} {ι : Type u_1} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
{t : Finset ι} {w : ι → R} {z : ι → E} [inst_3 : DecidableEq ι] {t' : Finset ι} {w' : ι → R} {z' : ι → E},
(∀ (i : ι), i ∈ t ∧ w i ≠ 0 ∨ i ∈ t' ∧ w' i ≠ 0 → i ∈ t ∩ t' ∧ w i = w' i ∧ z i = z' i) →
∀ x... | false |
CategoryTheory.ChosenPullbacksAlong.chosenPullbacksAlongFst._proof_11 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Y Z X : C} (f : Y ⟶ X) (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g]
(Q : CategoryTheory.Over (CategoryTheory.ChosenPullbacksAlong.pullbackObj f g)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id ((CategoryTheory... | false |
Nat.sub_eq_iff_eq_add | Init.Data.Nat.Basic | ∀ {b a c : ℕ}, b ≤ a → (a - b = c ↔ a = c + b) | true |
exists_nat_ge | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R] (x : R), ∃ n, x ≤ ↑n | true |
Lean.Elab.DefViewElabHeader.mk.sizeOf_spec | Lean.Elab.MutualDef | ∀ (toDefView : Lean.Elab.DefView) (toDefViewElabHeaderData : Lean.Elab.DefViewElabHeaderData)
(tacSnap? : Option (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot))
(bodySnap? : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot))),
sizeOf
{ toDefView := toDefView... | true |
UpperSet.coe_erase._simp_2 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), ↑s \ ↑(LowerSet.Iic a) = ↑(s.erase a) | false |
Order.idealOfCofinals.match_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : Preorder P] (p : P) {ι : Type u_2} [inst_1 : Encodable ι] (𝒟 : ι → Order.Cofinal P) (x : P)
(motive : x ∈ {x | ∃ n, x ≤ Order.sequenceOfCofinals p 𝒟 n} → Prop)
(x_1 : x ∈ {x | ∃ n, x ≤ Order.sequenceOfCofinals p 𝒟 n}),
(∀ (n : ℕ) (hn : x ≤ Order.sequenceOfCofinals p 𝒟 n), motive ⋯) → ... | false |
CommRingCat.limitCone | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J CommRingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] → CategoryTheory.Limits.Cone F | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.BigOperators.0.Set.mem_finset_prod.match_1_2 | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] (f : ι → Set α) (a : α)
(motive : (∃ g, ∃ (_ : ∀ {i : ι}, i ∈ ∅ → g i ∈ f i), 1 = a) → Prop)
(x : ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ ∅ → g i ∈ f i), 1 = a),
(∀ (w : ι → α) (w_1 : ∀ {i : ι}, i ∈ ∅ → w i ∈ f i) (hf : 1 = a), motive ⋯) → motive x | false |
MvPolynomial.instSmall | Mathlib.RingTheory.MvPolynomial.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [Small.{u, u_2} R] [Small.{u, u_1} σ],
Small.{u, max u_2 u_1} (MvPolynomial σ R) | true |
Int.add_emod_eq_add_emod_right | Init.Data.Int.DivMod.Bootstrap | ∀ {m n k : ℤ} (i : ℤ), m % n = k % n → (m + i) % n = (k + i) % n | true |
ENat.instMeasurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.Instances | MeasurableSingletonClass ℕ∞ | true |
Std.DHashMap.Raw.Const.getKey_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] [Inhabited α] {k k' : α} {f : Option β → Option β} (h : m.WF)
{hc : k' ∈ Std.DHashMap.Raw.Const.alter m k f},
(Std.DHashMap.Raw.Const.alter m k f).getKey k' hc = i... | true |
isCoatom_iff_ge_of_le | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : OrderTop α] {a : α},
IsCoatom a ↔ a ≠ ⊤ ∧ ∀ (b : α), b ≠ ⊤ → a ≤ b → b ≤ a | true |
Lean.Lsp.WorkspaceSymbolParams.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | String → Lean.Lsp.WorkspaceSymbolParams | false |
Std.Do.SPred.Tactic.Specialize.imp_pure | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {φ : Prop} {P Q R : Std.Do.SPred σs} [Std.Do.SPred.Tactic.PropAsSPredTautology φ Q],
φ → P ∧ (Q → R) ⊢ₛ P ∧ R | true |
DistLat._sizeOf_1 | Mathlib.Order.Category.DistLat | DistLat → ℕ | false |
CategoryTheory.Comonad.beckSplitEqualizer | Mathlib.CategoryTheory.Monad.Equalizer | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Comonad C} → (X : T.Coalgebra) → CategoryTheory.IsSplitEqualizer (T.map X.a) (T.δ.app X.A) X.a | true |
Int16.mul_two | Init.Data.SInt.Lemmas | ∀ {a : Int16}, a * 2 = a + a | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.F_neg_two._proof_1_3 | Mathlib.NumberTheory.LSeries.Nonvanishing | ¬-2 = 1 | false |
Lean.Elab.Tactic.Do.VCGen.Config.stepLimit | Std.Tactic.Do.Syntax | Lean.Elab.Tactic.Do.VCGen.Config → Option ℕ | true |
CategoryTheory.Limits.PushoutCocone.flipIsColimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.PushoutCocone g f),
CategoryTheory.CategoryStruct.comp t.inr ((fun s => ht.desc s.flip) s) = s.inl | false |
Lean.Widget.InteractiveGoals.recOn | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.InteractiveGoals → Sort u} →
(t : Lean.Widget.InteractiveGoals) →
((goals : Array Lean.Widget.InteractiveGoal) → motive { goals := goals }) → motive t | false |
Matrix.instLieAlgebraToLieAlgebra._proof_8 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x : Matrix.ToLieAlgebra R CM), 0 • x = 0 | false |
CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_hom_hom₃ | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (X : Cᵒᵖ),
(CategoryTheory.Pretriangulated.Opposite.contra... | true |
EReal.nhds_bot | Mathlib.Topology.Instances.EReal.Lemmas | nhds ⊥ = ⨅ a, ⨅ (_ : a ≠ ⊥), Filter.principal (Set.Iio a) | true |
Array.toArray_mkSlice_rci | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo : ℕ}, Std.Slice.toArray (Std.Rci.Sliceable.mkSlice xs lo...*) = xs.extract lo | true |
CategoryTheory.Triangulated.Octahedron'.triangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | true |
Nat.casesDiagOn_zero_succ | Batteries.Data.Nat.Lemmas | ∀ {motive : ℕ → ℕ → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : ℕ) → motive 0 (n + 1))
(succ_zero : (m : ℕ) → motive (m + 1) 0) (succ_succ : (m n : ℕ) → motive (m + 1) (n + 1)) (n : ℕ),
Nat.casesDiagOn 0 (n + 1) zero_zero zero_succ succ_zero succ_succ = zero_succ n | true |
String.toList_nonempty | Mathlib.Data.String.Basic | ∀ {s : String}, s ≠ "" → s.toList = String.Legacy.front s :: (String.Legacy.drop s 1).toList | true |
_private.Lean.PrettyPrinter.Basic.0.Lean.PrettyPrinter.runForNodeKind.match_1 | Lean.PrettyPrinter.Basic | {α : Type} →
(motive : List α → Sort u_1) →
(x : List α) → ((p : α) → (tail : List α) → motive (p :: tail)) → ((x : List α) → motive x) → motive x | false |
Nat.case_strong_induction_on | Mathlib.Data.Nat.Init | ∀ {p : ℕ → Prop} (a : ℕ), p 0 → (∀ (n : ℕ), (∀ m ≤ n, p m) → p (n + 1)) → p a | true |
Std.ExtHashMap.alter_eq_empty_iff._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
(m.alter k f = ∅) = ((m = ∅ ∨ m.size = 1 ∧ k ∈ m) ∧ f m[k]? = none) | false |
PowerSeries._aux_Mathlib_RingTheory_PowerSeries_Basic___unexpand_PowerSeries_1 | Mathlib.RingTheory.PowerSeries.Basic | Lean.PrettyPrinter.Unexpander | false |
_private.Init.Data.Ord.Basic.0.Ordering.then.match_1.eq_1 | Init.Data.Ord.Basic | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : (a : Ordering) → motive a),
(match Ordering.eq with
| Ordering.eq => h_1 ()
| a => h_2 a) =
h_1 () | true |
Mathlib.Tactic.BicategoryLike.MonadWhiskerLeft.rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MonadWhiskerLeft m → Sort u} →
([toMonadHorizontalComp : Mathlib.Tactic.BicategoryLike.MonadHorizontalComp m] →
(whiskerLeftM :
Mathlib.Tactic.BicategoryLike.Atom₁ →
Mathlib.Tactic.BicategoryLike.WhiskerLeft → m Mathlib.... | false |
ProbabilityTheory.lintegral_prod_eq_prod_lintegral_of_indepFun | Mathlib.Probability.Independence.Integration | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_3} (s : Finset ι)
(X : ι → Ω → ENNReal),
ProbabilityTheory.iIndepFun X μ →
(∀ (i : ι), Measurable (X i)) → ∫⁻ (ω : Ω), ∏ i ∈ s, X i ω ∂μ = ∏ i ∈ s, ∫⁻ (ω : Ω), X i ω ∂μ | true |
CategoryTheory.CosimplicialObject.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ}
{i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (X.δ i.castSucc) (X.σ j.succ) =
CategoryTheory.CategoryStruct.comp (X.σ j) (X.δ i) | true |
CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones | Mathlib.CategoryTheory.Limits.Types.Yoneda | (J : Type v) →
[inst : CategoryTheory.SmallCategory J] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(CategoryTheory.Functor.opHom J C).comp
((CategoryTheory.Functor.whiskeringLeft Jᵒᵖ Cᵒᵖ (Type v)).comp
(((CategoryTheory.Functor.whiskeringRight (CategoryTh... | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.trySubstVarsAndContradiction.match_1 | Lean.Meta.Match.SimpH | (motive : Lean.Meta.InjectionsResult → Sort u_1) →
(__do_lift : Lean.Meta.InjectionsResult) →
(Unit → motive Lean.Meta.InjectionsResult.solved) →
((mvarId' : Lean.MVarId) →
(remainingNames : List Lean.Name) →
(forbidden : Lean.FVarIdSet) →
motive (Lean.Meta.InjectionsResu... | false |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_weight._simp_1_1 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∉ f.support) = (f a = 0) | false |
Group.exponent_dvd_card | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Group G] [inst_1 : Fintype G], Monoid.exponent G ∣ Fintype.card G | true |
DistLat.noConfusion | Mathlib.Order.Category.DistLat | {P : Sort u} → {t t' : DistLat} → t = t' → DistLat.noConfusionType P t t' | false |
inhomogeneousCochains.d_eq | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (n : ℕ),
inhomogeneousCochains.d A n =
CategoryTheory.CategoryStruct.comp (Rep.freeLiftLEquiv k G (Fin n → G) A).toModuleIso.inv
(CategoryTheory.CategoryStruct.comp (((Rep.barComplex k G).linearYonedaObj k A).d n (n + 1))
... | true |
AddSubmonoid.smul_mem_pointwise_smul | Mathlib.Algebra.GroupWithZero.Submonoid.Pointwise | ∀ {M : Type u_3} {A : Type u_4} [inst : Monoid M] [inst_1 : AddMonoid A] [inst_2 : DistribMulAction M A] (a : A) (m : M)
(S : AddSubmonoid A), a ∈ S → m • a ∈ m • S | true |
TopModuleCat.instHasForget₂ContinuousLinearMapIdCarrierTopCatContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → CategoryTheory.HasForget₂ (TopModuleCat R) TopCat | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[inst_3 : CategoryTheory.BraidedCategory D] →
CategoryTheory.Functor (CategoryTheory.Functor C (CategoryT... | true |
SignType.le_neg_one_iff._simp_1 | Mathlib.Data.Sign.Defs | ∀ {a : SignType}, (a ≤ -1) = (a = -1) | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList._simp_1_15 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {a b c : ℕ}, (a - b ≤ c) = (a ≤ c + b) | false |
egauge_zero_left_eq_top._simp_1 | Mathlib.Analysis.Convex.EGauge | ∀ (𝕜 : Type u_1) [inst : NNNorm 𝕜] [Nonempty 𝕜] {E : Type u_2} [inst_2 : Zero E] [inst_3 : SMulZeroClass 𝕜 E] {x : E},
(egauge 𝕜 0 x = ⊤) = (x ≠ 0) | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M.localMapM | Lean.Meta.Tactic.FunInd | {α : Type} → (Lean.Expr → Lean.MetaM Lean.Expr) → Lean.Tactic.FunInd.M✝ α → Lean.Tactic.FunInd.M✝¹ α | true |
TopologicalSpace.PositiveCompacts.map_id | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (K : TopologicalSpace.PositiveCompacts α),
TopologicalSpace.PositiveCompacts.map id ⋯ ⋯ K = K | true |
WithBot.bot_ne_natCast._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : AddMonoidWithOne α] (n : ℕ), (⊥ = ↑n) = False | false |
_private.Mathlib.Combinatorics.Additive.CauchyDavenport.0.DevosMulRel.eq_1 | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {α : Type u_2} [inst : Group α] [inst_1 : DecidableEq α],
DevosMulRel✝ =
Function.onFun (Prod.Lex (fun x1 x2 => x1 < x2) (Prod.Lex (fun x1 x2 => x1 > x2) fun x1 x2 => x1 < x2)) fun x =>
((x.1 * x.2).card, x.1.card + x.2.card, x.1.card) | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.mem_graph_snd_inj._proof_1_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_3} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_1}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F) {x y : E} {x' y' : F},
(x, x') ∈ f.graph → (y, y') ∈ f.graph → x = y → x' = y' | false |
_private.Std.Do.Triple.SpecLemmas.0.List.Cursor.pos_at._proof_1_3 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {n : ℕ}, n < l.length → ¬min n l.length = n → False | false |
Lean.Compiler.LCNF.CodeDecl.jp.elim | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u} →
(t : Lean.Compiler.LCNF.CodeDecl pu) →
t.ctorIdx = 2 → ((decl : Lean.Compiler.LCNF.FunDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.jp decl)) → motive t | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_not._simp_1_3 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | false |
Set.mulAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | {α : Type u_1} → [Mul α] → Set α → Set α → α → Set (α × α) | true |
_private.Init.Data.Slice.List.Lemmas.0.instSliceableListSliceNat.match_1.splitter | Init.Data.Slice.List.Lemmas | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → (Unit → motive none) → ((stop : ℕ) → motive (some stop)) → motive x | true |
Lean.Lsp.Location.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Location → Sort u} →
(t : Lean.Lsp.Location) →
((uri : Lean.Lsp.DocumentUri) → (range : Lean.Lsp.Range) → motive { uri := uri, range := range }) → motive t | false |
Std.Tactic.BVDecide.BVPred.ExprPair | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Type | true |
CategoryTheory.NormalMono.lift' | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{W : C} →
(f : X ⟶ Y) →
[hf : CategoryTheory.NormalMono f] →
(k : W ⟶ Y) →
CategoryTheory.CategoryStruct.comp k Category... | true |
Std.Time.instInhabitedFraction | Std.Time.Format.Basic | Inhabited Std.Time.Fraction | true |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.UpperHemicontinuous.isClosed_domain._simp_1_7 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_3} [inst : TopologicalSpace α] {s : Set α}, (nhdsSet s = ⊥) = (s = ∅) | false |
CategoryTheory.DifferentialObject.isoApp._proof_1 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
{X Y : CategoryTheory.DifferentialObject S C} (f : X ≅ Y),
CategoryTheory.CategoryStruct.comp f.hom.f f.inv.f = Cat... | false |
SSet.Subcomplex.Pairing._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → ℕ | false |
Lean.Elab.Term.Arg.expr.noConfusion | Lean.Elab.Arg | {P : Sort u} →
{val val' : Lean.Expr} → Lean.Elab.Term.Arg.expr val = Lean.Elab.Term.Arg.expr val' → (val = val' → P) → P | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.withStructFields.goFields | Lean.Elab.Structure | {α : Type} →
Lean.Elab.Command.Structure.StructView →
List Lean.Name →
Option Lean.Expr →
(Lean.Expr → Lean.Elab.Command.Structure.StructElabM✝ α) →
Lean.Name →
List Lean.Level →
Array Lean.Expr →
Array Lean.Name →
Array Lean.Stru... | true |
SSet.PtSimplex.MulStruct.mk | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op (SimplexCategory.mk 0))} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
(map : SSet.stdSimplex.obj (SimplexCategory.mk (n + 1)) ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) map = g.map)... | true |
AddGroupTopology.noConfusionType | Mathlib.Topology.Algebra.Group.GroupTopology | Sort u_1 →
{α : Type u} →
[inst : AddGroup α] → AddGroupTopology α → {α' : Type u} → [inst' : AddGroup α'] → AddGroupTopology α' → Sort u_1 | false |
ProbabilityTheory.Kernel.rnDerivAux_nonneg | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ], κ ≤ η → ∀ {a : α} {x : γ}, 0 ≤ κ.rnDerivAux η a x | true |
SemiRingCat.FilteredColimits.colimitSemiring._proof_4 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (x : ↑(SemiRingCat.FilteredColimits.R F)), x * 0 = 0 | false |
Finset.piecewise_eq_of_mem | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} {π : ι → Sort u_2} (s : Finset ι) (f g : (i : ι) → π i) [inst : (j : ι) → Decidable (j ∈ s)] {i : ι},
i ∈ s → s.piecewise f g i = f i | true |
sup_biInf_le_biInf_sup | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α) (s : Set β) (a : α),
a ⊔ ⨅ i ∈ s, f i ≤ ⨅ i ∈ s, a ⊔ f i | true |
Cardinal.sum_zero_pow | Mathlib.SetTheory.Cardinal.Basic | (Cardinal.sum fun n => 0 ^ n) = 1 | true |
AlgebraicGeometry.Surjective.mk._flat_ctor | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y}, Function.Surjective ⇑f → AlgebraicGeometry.Surjective f | false |
Ordinal.IsFundamentalSequence.monotone | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {a o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{u}},
a.IsFundamentalSequence o f → ∀ {i j : Ordinal.{u}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj | true |
coe_lpPiLpₗᵢ_symm | Mathlib.Analysis.Normed.Lp.LpEquiv | ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {p : ENNReal} [inst_1 : Fintype α]
{𝕜 : Type u_3} [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : α) → NormedSpace 𝕜 (E i)] [inst_4 : Fact (1 ≤ p)]
(f : PiLp p E), ↑((lpPiLpₗᵢ E 𝕜).symm f) = f.ofLp | true |
IsSimpleGroup.derivedSeries_succ | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} [inst : Group G] [IsSimpleGroup G] {n : ℕ}, derivedSeries G n.succ = commutator G | true |
Lean.Omega.IntList.smul_get | Init.Omega.IntList | ∀ (xs : Lean.Omega.IntList) (a : ℤ) (i : ℕ), (a * xs).get i = a * xs.get i | true |
Mathlib.TacticAnalysis.initFn._@.Mathlib.Tactic.TacticAnalysis.1736486024._hygCtx._hyg.2 | Mathlib.Tactic.TacticAnalysis | IO Unit | false |
AddGroup.ResiduallyFinite.casesOn | Mathlib.GroupTheory.ResiduallyFinite | {G : Type u_1} →
[inst : AddGroup G] →
{motive : AddGroup.ResiduallyFinite G → Sort u} →
(t : AddGroup.ResiduallyFinite G) → ((iInf_eq_bot : ⨅ H, H.toAddSubgroup = ⊥) → motive ⋯) → motive t | false |
_private.Mathlib.Topology.MetricSpace.Completion.0.UniformSpace.Completion.mem_uniformity_dist._simp_1_1 | Mathlib.Topology.MetricSpace.Completion | ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {f : Filter α} {g : Filter β},
(s ∈ f ×ˢ g) = ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.suggestInvariant.match_7 | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | (motive : Lean.Term × Lean.Term → Sort u_1) →
(__discr : Lean.Term × Lean.Term) →
((onContinue onReturn : Lean.Term) → motive (onContinue, onReturn)) → motive __discr | false |
Set.IccExtend_of_right_le | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α} (f : ↑(Set.Icc a b) → β),
b ≤ x → Set.IccExtend h f x = f ⟨b, ⋯⟩ | true |
Lean.Elab.RecKind.rec | Lean.Elab.DeclModifiers | {motive : Lean.Elab.RecKind → Sort u} →
motive Lean.Elab.RecKind.partial →
motive Lean.Elab.RecKind.nonrec → motive Lean.Elab.RecKind.default → (t : Lean.Elab.RecKind) → motive t | false |
instLawfulOrdUInt8 | Batteries.Data.UInt | Std.LawfulOrd UInt8 | true |
Complex.addCommGroup._proof_1 | Mathlib.Data.Complex.Basic | ∀ (a b c : ℂ), a + b + c = a + (b + c) | false |
ContinuousAlternatingMap.map_vecCons_sub | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N] [inst_6 : TopologicalSpace N] {n : ℕ}
(f : M [⋀^Fin (n + 1)]→L[R] N) (x y : M) (v : Fin n → M),
f (Matrix.vecCons (x - y) v) ... | true |
CategoryTheory.Mathlib.Tactic.MonTauto.associator_hom_comp_tensorHom_tensorHom_comp_assoc | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{W X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C} (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂) (h : Z₁ ⟶ Z₂)
(gh : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₂ Z₂ ⟶ W) {Z : C}
(h_1 : CategoryTheory.MonoidalCategoryStruct.tensorObj X₂ W ⟶ Z),
... | true |
GrpCat.ofHom_injective | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : Type u} [inst : Group X] [inst_1 : Group Y], Function.Injective fun f => GrpCat.ofHom f | true |
Mathlib.Util.TermReduce.zetaStx | Mathlib.Util.TermReduce | Lean.ParserDescr | true |
AddHom.coeFn._proof_1 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ (α : Type u_1) (β : Type u_2) [inst : Add α] [inst_1 : AddCommSemigroup β] (x x_1 : α →ₙ+ β), ⇑(x + x_1) = ⇑(x + x_1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.