name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Equivalence.mk | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
(G : CategoryTheory.Functor D C) →
(CategoryTheory.Functor.id C ≅ F.comp G) → (G.comp F ≅ CategoryTheory.Functor.id D... | true |
_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult.us | Lean.Meta.Injective | Lean.Meta.MkHInjTypeResult✝ → List Lean.Level | true |
Lean.Meta.Grind.ppExprArray | Lean.Meta.Tactic.Grind.PP | Lean.Name →
String → Array Lean.Expr → optParam Lean.Name (Lean.Name.mkSimple "_") → optParam Bool true → Lean.MessageData | true |
CategoryTheory.MorphismProperty.IsMonoidal.rec | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{motive : W.IsMonoidal → Sort u} →
([toIsMultiplicative : W.IsMultiplicative] →
(whiskerLeft :
∀ (X : C)... | false |
Con.quotientKerEquivRange._proof_4 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_2} {P : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass P] (f : M →* P) (w : P)
(z : (Con.ker f).Quotient) (hz : (Con.kerLift f) z = w), (Con.kerLift f).mrangeRestrict z = ⟨w, ⋯⟩ | false |
hasFDerivWithinAt_natCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [inst_7 : NatCast F] (n : ℕ) (x : E) (s : Set E), HasFDerivWithinAt (↑n) 0... | true |
Multiset.countAddMonoidHom | Mathlib.Algebra.Order.Group.Multiset | {α : Type u_1} → [DecidableEq α] → α → Multiset α →+ ℕ | true |
conditionallyCompleteLatticeOfLatticeOfsInf.eq_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_5) [H1 : Lattice α] [inst : InfSet α]
(isLUB_sSup : ∀ (s : Set α), BddBelow s → s.Nonempty → IsGLB s (sInf s)),
conditionallyCompleteLatticeOfLatticeOfsInf α isLUB_sSup =
{ toLattice := H1, toSupSet := (conditionallyCompleteLatticeOfsInf α ⋯ ⋯ isLUB_sSup).toSupSet,
toInfSet := (conditionally... | true |
Std.Time.Text.short.elim | Std.Time.Format.Basic | {motive : Std.Time.Text → Sort u} → (t : Std.Time.Text) → t.ctorIdx = 0 → motive Std.Time.Text.short → motive t | false |
CircleDeg1Lift.map_nat_add | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) (n : ℕ) (x : ℝ), f (↑n + x) = ↑n + f x | true |
CategoryTheory.Grothendieck.preNatIso._proof_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C CategoryTheory.Cat)
{G H : CategoryTheory.Functor D C} (α : G ≅ H) {X Y : CategoryTheory.Grothendieck (G.comp F)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.c... | false |
NormedSpace.isCompact_closure_of_isBounded | Mathlib.Analysis.Normed.Module.DoubleDual | ∀ (𝕜 : Type u_3) [inst : RCLike 𝕜] (X : Type u_4) [inst_1 : NormedAddCommGroup X] [inst_2 : NormedSpace 𝕜 X]
(S : Set (WeakSpace 𝕜 X)),
Bornology.IsBounded (⇑(toWeakSpace 𝕜 X) ⁻¹' S) →
closure (⇑(NormedSpace.inclusionInDoubleDualWeak 𝕜 X) '' S) ⊆
Set.range ⇑(NormedSpace.inclusionInDoubleDualWeak �... | true |
_private.Init.Data.Array.Find.0.Array.finIdxOf?_eq_none_iff._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {l : List α} {a : α}, (List.finIdxOf? a l = none) = (a ∉ l) | false |
exists_bijective_map_powers | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (S : Submonoid R) {M' : Type u_1} [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] (f : M →ₗ[R] M') [inst_7 : IsLocalizedModule S f] {N' : Type u_2} [in... | true |
_private.Mathlib.LinearAlgebra.Vandermonde.0.Matrix.det_projVandermonde_of_field | Mathlib.LinearAlgebra.Vandermonde | ∀ {K : Type u_2} [inst : Field K] {n : ℕ} (v w : Fin n → K),
(Matrix.projVandermonde v w).det = ∏ i, ∏ j ∈ Finset.Ioi i, (v j * w i - v i * w j) | true |
PseudoMetric.instMaxOfAddLeftMonoOfAddRightMono | Mathlib.Topology.MetricSpace.BundledFun | {X : Type u_1} →
{R : Type u_2} →
[inst : AddZeroClass R] → [inst_1 : SemilatticeSup R] → [AddLeftMono R] → [AddRightMono R] → Max (PseudoMetric X R) | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts_trans._simp_1_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a' = a → p a) = p a' | false |
Polynomial.leadingCoeff_add_of_degree_lt' | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, q.degree < p.degree → (p + q).leadingCoeff = p.leadingCoeff | true |
_private.Lean.SubExpr.0.Lean.SubExpr.Pos.fromString?.match_1 | Lean.SubExpr | (motive : List String → Sort u_1) →
(x : List String) → ((tail : List String) → motive ("" :: tail)) → ((ss : List String) → motive ss) → motive x | false |
Std.HashMap.isEmpty_of_isEmpty_insertMany | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {ρ : Type w}
[inst : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α] {l : ρ},
(m.insertMany l).isEmpty = true → m.isEmpty = true | true |
USize.toBitVec_zero | Init.Data.UInt.Lemmas | USize.toBitVec 0 = 0#System.Platform.numBits | true |
Lean.Elab.Term.State.levelNames._default | Lean.Elab.Term.TermElabM | List Lean.Name | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_iterateDerivativeC_pos._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n k : ℕ}, (Finset.Icc 1 (n - k)).card = n - k | false |
Lean.Elab.Term.Do.Code._sizeOf_inst | Lean.Elab.Do.Legacy | SizeOf Lean.Elab.Term.Do.Code | false |
TopCommRingCat.α | Mathlib.Topology.Category.TopCommRingCat | TopCommRingCat → Type u | true |
Matrix.exp_units_conj | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_4} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸]
[CompleteSpace 𝔸] (U : (Matrix m m 𝔸)ˣ) (A : Matrix m m 𝔸),
NormedSpace.exp (↑U * A * ↑U⁻¹) = ↑U * NormedSpace.exp A * ↑U⁻¹ | true |
WittVector.select_isPoly | Mathlib.RingTheory.WittVector.InitTail | ∀ {p : ℕ} {P : ℕ → Prop}, WittVector.IsPoly p fun x x_1 x_2 => WittVector.select P x_2 | true |
Unitization._sizeOf_inst | Mathlib.Algebra.Algebra.Unitization | (R : Type u_1) → (A : Type u_2) → [SizeOf R] → [SizeOf A] → SizeOf (Unitization R A) | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan.0.CategoryTheory.Limits.WalkingCospan.instSubsingletonHom._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | false |
PredOrder.ofPredLeIff._proof_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] (pred : α → α), (∀ {a b : α}, b ≤ pred a ↔ b < a) → ∀ (x : α), pred x ≤ x | false |
Int.Ioc_filter_dvd_card | Mathlib.Data.Int.CardIntervalMod | ∀ (a b : ℤ) {r : ℤ}, 0 < r → ↑{x ∈ Finset.Ioc a b | r ∣ x}.card = max (⌊↑b / ↑r⌋ - ⌊↑a / ↑r⌋) 0 | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.lambda_sq_dvd_or_dvd_or_dvd._proof_1_2 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3}, IsUnit ⟨ζ, ⋯⟩ | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax._sunfold | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Level → Bool | false |
Mathlib.Tactic.BicategoryLike.Mor₂.ctorElimType | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.Mor₂ → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkTryEvalSuggestStxUnsafe | Lean.Elab.Tactic.Try | Lean.MVarId → Lean.Meta.Try.Info → Lean.MetaM (Lean.TSyntax `tactic) | true |
List.replaceFTR.go.match_1.congr_eq_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → Array α → Sort u_2) (x : List α) (x_1 : Array α)
(h_1 : (acc : Array α) → motive [] acc) (h_2 : (x : α) → (xs : List α) → (acc : Array α) → motive (x :: xs) acc)
(x_2 : α) (xs : List α) (acc : Array α),
x = x_2 :: xs →
x_1 = acc →
(match x, x_1 with
| [], acc ... | true |
ContinuousMap.Homotopy.symm_apply | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁) (x : ↑unitInterval × X), F.symm x = F (unitInterval.symm x.1, x.2) | true |
Matroid.copyBase_Indep | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (E : Set α) (IsBase : Set α → Prop) (hE : E = M.E)
(h : ∀ (B : Set α), IsBase B ↔ M.IsBase B) (a : Set α), (M.copyBase E IsBase hE h).Indep a = M.Indep a | true |
Matroid.comap_indep_iff | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {I : Set α} {N : Matroid β},
(N.comap f).Indep I ↔ N.Indep (f '' I) ∧ Set.InjOn f I | true |
AlgebraicGeometry.Scheme.instOverPullbackCoverOverProp' | Mathlib.AlgebraicGeometry.Cover.Over | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
(S : AlgebraicGeometry.Scheme) →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X W : AlgebraicGeometry.Scheme} →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeo... | true |
Unitary.toUnits._proof_4 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x x_1 : ↥(unitary R)), ↑(x * x_1) * ↑(star (x * x_1)) = 1 | false |
PrimeSpectrum.preimageEquivFiber._proof_15 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : PrimeSpectrum R)
(q : ↑(PrimeSpectrum.comap (algebraMap R S) ⁻¹' {p})) (x : p.asIdeal.ResidueField) (x_1 : S),
Commute ((Ideal.ResidueField.mapₐ p.asIdeal (↑q).asIdeal (Algebra.ofId R S) ⋯) x)
((IsScalarTower.t... | false |
Aesop.instHashablePremiseIndex | Aesop.Forward.PremiseIndex | Hashable Aesop.PremiseIndex | true |
Std.Internal.UV.System.CPUTimes._sizeOf_inst | Std.Internal.UV.System | SizeOf Std.Internal.UV.System.CPUTimes | false |
Submonoid.LocalizationMap.lift._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_2} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_3} [inst_1 : CommMonoid N] {P : Type u_1}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)),
g (f.sec 1).1 * ↑((IsUnit.liftRight (g.restrict S) hg) (f.sec 1).2)⁻¹ = 1 | false |
Std.Format.instBEqFlattenBehavior.beq | Init.Data.Format.Basic | Std.Format.FlattenBehavior → Std.Format.FlattenBehavior → Bool | true |
Lex.instAddAction | Mathlib.Algebra.Order.Group.Action.Synonym | {M : Type u_1} → {α : Type u_3} → [inst : AddMonoid M] → [AddAction M α] → AddAction (Lex M) α | true |
AlgebraicGeometry.coprodIsoSigma | Mathlib.AlgebraicGeometry.Limits | (X Y : AlgebraicGeometry.Scheme) → X ⨿ Y ≅ ∐ fun i => CategoryTheory.Limits.WalkingPair.casesOn i.down X Y | true |
LibraryNote.continuous_functional_calculus | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Note | Batteries.Util.LibraryNote | true |
skyscraperPresheafCoconeOfSpecializes._proof_2 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} C] (A : C) [inst_2 : CategoryTheory.Limits.HasTerminal C] {y : ↑X},
p₀ ⤳ y → ∀ (U : (TopologicalSpace.OpenNhds y)ᵒᵖ), (if p₀ ∈ (↑(Opposite.unop U)).carrier then A else ⊤... | false |
PontryaginDual.mapHom._proof_1 | Mathlib.Topology.Algebra.PontryaginDual | ∀ (A : Type u_1) (G : Type u_2) [inst : Monoid A] [inst_1 : CommGroup G] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace G], PontryaginDual.map 1 = 1 | false |
Lean.Lsp.InitializeParams.casesOn | Lean.Data.Lsp.InitShutdown | {motive : Lean.Lsp.InitializeParams → Sort u} →
(t : Lean.Lsp.InitializeParams) →
((processId? : Option ℤ) →
(clientInfo? : Option Lean.Lsp.ClientInfo) →
(rootUri? : Option String) →
(initializationOptions? : Option Lean.Lsp.InitializationOptions) →
(capabilities : Lean... | false |
upperHemicontinuous_singleton_id | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} [inst : TopologicalSpace α], UpperHemicontinuous fun x => {x} | true |
_private.Init.Data.List.Monadic.0.List.mapA.match_1.splitter | Init.Data.List.Monadic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (as : List α) → motive (a :: as)) → motive x | true |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.reduce.not._proof_1_3 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (x : α) (b : Bool) (L2 L3 : List (α × Bool)) (x' : α) (b' : Bool),
[(x, b)].length = (L2 ++ (x', b') :: (x', !b') :: L3).length → False | false |
_private.Mathlib.Topology.UniformSpace.Closeds.0.TotallyBounded.powerset_hausdorff._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
HImp.himp | Mathlib.Order.Notation | {α : Type u_1} → [self : HImp α] → α → α → α | true |
ValuativeRel.div_rel_iff | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {K : Type u_2} [inst : Field K] [inst_1 : ValuativeRel K] {a b c : K}, c ≠ 0 → (a / c ≤ᵥ b ↔ a ≤ᵥ b * c) | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_leftShift._simp_1_8 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
Lean.Meta.RewriteResult.noConfusion | Lean.Meta.Tactic.Rewrite | {P : Sort u} → {t t' : Lean.Meta.RewriteResult} → t = t' → Lean.Meta.RewriteResult.noConfusionType P t t' | false |
TestFunction.instSMulOfSMulCommClassRealOfContinuousConstSMul._proof_3 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} {R : Type u_3} [inst_4 : Semiring R]
[inst_5 : Module R F] (c : R) (f : TestFunction Ω F n), (tsupport fun x => c • f x) ⊆ ↑Ω | false |
CategoryTheory.MonoidalOpposite.mopEquiv._proof_2 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.mopFunctor C).map ((CategoryTheory.Iso.refl (CategoryTheory.Functor.id C)).hom.app X))
((CategoryTheory.Iso.refl ((CategoryTheory.unmopFunctor C).comp (CategoryTheory.mopFunctor C)))... | false |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm.0.PiTensorProduct.bddBelow_projectiveSemiNormAux._simp_1_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type uι} [inst : Fintype ι] {𝕜 : Type u𝕜} {E : ι → Type uE} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NormedField 𝕜] (p : FreeAddMonoid (𝕜 × ((i : ι) → E i))),
(0 ≤ PiTensorProduct.projectiveSeminormAux p) = True | false |
Std.Tactic.BVDecide.LRAT.Internal.Result.recOn | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | {motive : Std.Tactic.BVDecide.LRAT.Internal.Result → Sort u} →
(t : Std.Tactic.BVDecide.LRAT.Internal.Result) →
motive Std.Tactic.BVDecide.LRAT.Internal.Result.success →
motive Std.Tactic.BVDecide.LRAT.Internal.Result.outOfProof →
motive Std.Tactic.BVDecide.LRAT.Internal.Result.rupFailure → motive t | false |
Lean.Meta.Grind.Order.CnstrKind.le.sizeOf_spec | Lean.Meta.Tactic.Grind.Order.Types | sizeOf Lean.Meta.Grind.Order.CnstrKind.le = 1 | true |
ProbabilityTheory.bayesRisk_const_of_neZero | Mathlib.Probability.Decision.Risk.Basic | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {ℓ : Θ → 𝓨 → ENNReal},
Measurable (Function.uncurry ℓ) →
∀ (μ : MeasureTheory.Measure 𝓧) [NeZero μ] [MeasureTheory.IsFiniteMeasure μ] (π : MeasureTheory.Measure Θ)
[MeasureTheo... | true |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.notAnInvariantUse.elim | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | {motive : Lean.Elab.Tactic.Do.ClassifyInvariantUseResult✝ → Sort u} →
(t : Lean.Elab.Tactic.Do.ClassifyInvariantUseResult✝¹) →
Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.ctorIdx✝ t = 1 →
motive Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.notAnInvariantUse✝ → motive t | false |
HahnSeries.leadingCoeff_eq | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero Γ] {x : HahnSeries Γ R},
x.leadingCoeff = x.coeff x.order | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofIsLimitKernelFork_K | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (c : CategoryTheory.Limits.KernelFork S.g)
(hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.ShortComplex.LeftHomologyData.ofIsLimitKernelFork... | true |
Filter.Eventually.congr | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p q : α → Prop},
(∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x ↔ q x) → ∀ᶠ (x : α) in f, q x | true |
HahnSeries.cardSupp_neg | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddGroup R] (x : HahnSeries Γ R),
(-x).cardSupp = x.cardSupp | true |
Lean.Elab.PartialFixpoint.registerEqnsInfo | Lean.Elab.PreDefinition.PartialFixpoint.Eqns | Array Lean.Elab.PreDefinition →
Lean.Name → Lean.Elab.FixedParamPerms → Array Lean.Elab.PartialFixpointType → Lean.MetaM Unit | true |
eq_of_nhds_neBot | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] {x y : X}, (nhds x ⊓ nhds y).NeBot → x = y | true |
Std.ExtDTreeMap.mem_insert_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, k ∈ t.insert k v | true |
Int.lcm_dvd_mul._simp_1 | Init.Data.Int.Gcd | ∀ (m n : ℤ), (↑(m.lcm n) ∣ m * n) = True | false |
RingCon.toCon_coe_eq_coe | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (c : RingCon R), ⇑c.toCon = ⇑c | true |
SimpleGraph.IsMaximumIndepSet.maximum | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} [inst : Finite α] {G : SimpleGraph α} {s : Finset α},
G.IsMaximumIndepSet s → ∀ (t : Finset α), G.IsIndepSet ↑t → t.card ≤ s.card | true |
integrable_cfc'._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Integral | Lean.Syntax | false |
WithTop.pow_ne_top | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MonoidWithZero α] [inst_2 : NoZeroDivisors α] [inst_3 : Nontrivial α]
{x : WithTop α} {n : ℕ}, x ≠ ⊤ → x ^ n ≠ ⊤ | true |
CStarRing.norm_one | Mathlib.Analysis.CStarAlgebra.Basic | ∀ {E : Type u_2} [inst : NormedRing E] [inst_1 : StarRing E] [CStarRing E] [Nontrivial E], ‖1‖ = 1 | true |
IsWeakLowerModularLattice.recOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsWeakLowerModularLattice α → Sort u} →
(t : IsWeakLowerModularLattice α) →
((inf_covBy_of_covBy_covBy_sup : ∀ {a b : α}, a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a) → motive ⋯) → motive t | false |
Std.Iterators.PostconditionT.map_pure | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α β : Type w} {f : α → β} {a : α},
Std.Iterators.PostconditionT.map f (pure a) = pure (f a) | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_mframeMacro_1 | Init.Tactics | Lean.Macro | false |
Lean.MessageData | Lean.Message | Type | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.monadLift_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
ZSpan.floor.eq_1 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (m : E),
ZSpan.floor b m = ∑ i, ⌊(b.repr m) i⌋ • (Module.B... | true |
MulEquiv.prodUnique_symm_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Unique N] (a : M),
MulEquiv.prodUnique.symm a = (a, default) | true |
_private.Mathlib.Algebra.BigOperators.Group.List.Lemmas.0.List.prod_rotate_eq_one_of_prod_eq_one.match_1_1 | Mathlib.Algebra.BigOperators.Group.List.Lemmas | ∀ {G : Type u_1} [inst : Group G] (motive : (x : List G) → x.prod = 1 → ℕ → Prop) (x : List G) (x_1 : x.prod = 1)
(x_2 : ℕ),
(∀ (x : [].prod = 1) (x_3 : ℕ), motive [] x x_3) →
(∀ (a : G) (l : List G) (hl : (a :: l).prod = 1) (n : ℕ), motive (a :: l) hl n) → motive x x_1 x_2 | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Countable.0.CategoryTheory.Limits.IsFiltered.sequentialFunctor_final._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α},
List.IsChain R (a :: b :: l) = (R a b ∧ List.IsChain R (b :: l)) | false |
Lean.Order.instCCPOPProd._proof_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] {c : α ×' β → Prop},
Lean.Order.chain c → Exists (Lean.Order.is_sup c) | false |
_private.Aesop.Frontend.RuleExpr.0.Aesop.Frontend.RuleConfig.buildGlobalRule.match_3 | Aesop.Frontend.RuleExpr | (motive : Aesop.LocalRuleSetMember × Array Aesop.RuleSetName → Sort u_1) →
(__discr : Aesop.LocalRuleSetMember × Array Aesop.RuleSetName) →
((m : Aesop.LocalRuleSetMember) → (rsNames : Array Aesop.RuleSetName) → motive (m, rsNames)) → motive __discr | false |
CategoryTheory.CostructuredArrow.toStructuredArrow._proof_3 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor C D) (d : D)
{X Y Z : (CategoryTheory.CostructuredArrow F d)ᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.com... | false |
LinearMap.restrictScalars_add | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_14} {S : Type u_15} {M : Type u_16} {N : Type u_17} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module S M] [inst_7 : Module S N] [inst_8 : LinearMap.CompatibleSMul M N R S] (f g : M →ₗ[S] N),
↑... | true |
Set.InjOn.of_comp | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {f : α → β} {g : β → γ}, Set.InjOn (g ∘ f) s → Set.InjOn f s | true |
Array.stop_toSubarray | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo hi : ℕ}, (xs.toSubarray lo hi).stop = min hi xs.size | true |
Lean.IR.SimpleGroundExpr.pap | Lean.Compiler.IR.SimpleGroundExpr | Lean.IR.FunId → Array Lean.IR.SimpleGroundArg → Lean.IR.SimpleGroundExpr | true |
IsLocalization.map._proof_3 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {P : Type u_3} [inst_1 : CommSemiring P] {T : Submonoid P}
(Q : Type u_2) [inst_2 : CommSemiring Q] [inst_3 : Algebra P Q] [IsLocalization T Q] (g : R →+* P)
(hy : M ≤ Submonoid.comap g T) (y : ↥M), IsUnit ((algebraMap P Q) ↑⟨g ↑y, ⋯⟩) | false |
CategoryTheory.TransfiniteCompositionOfShape.ofOrderIso | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
CategoryTheory.Transfinit... | true |
SeparatedNhds.mono | Mathlib.Topology.Separation.SeparatedNhds | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s₁ s₂ t₁ t₂ : Set X},
SeparatedNhds s₂ t₂ → s₁ ⊆ s₂ → t₁ ⊆ t₂ → SeparatedNhds s₁ t₁ | true |
List.Vector.singleton_tail | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} (v : List.Vector α 1), v.tail = List.Vector.nil | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.