name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HasDerivAtFilter.sub_const | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {L : Filter (𝕜 × 𝕜)} (c : F),
HasDerivAtFilter f f' L → HasDerivAtFilter (fun x => f x - c) f' L | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_385 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Real.Gamma_neg_nat_eq_zero._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ (r : ℝ), -↑r = ↑(-r) | false |
CategoryTheory.Limits.Cone.toCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
CategoryTheory.Functor (CategoryTheory.Limits.Cone F)
(CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const... | true |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.apply_mem_fixedPoints_iff_mem_of_mem_centralizer._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u_1} {f : α → α} {x : α}, (x ∈ Function.fixedPoints f) = (f x = x) | false |
Function.locallyFinsuppWithin.apply_eq_zero_of_notMem | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : Zero Y] {z : X}
(D : Function.locallyFinsuppWithin U Y), z ∉ U → D z = 0 | true |
_private.Init.Grind.Ordered.Module.0.Lean.Grind.OrderedAdd.zsmul_pos_iff.match_1_1 | Init.Grind.Ordered.Module | ∀ (motive : ℤ → Prop) (k : ℤ),
(∀ (k : ℕ), motive (Int.ofNat k.succ)) →
(∀ (a : Unit), motive (Int.ofNat 0)) → (∀ (k : ℕ), motive (Int.negSucc k)) → motive k | false |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftRight_or._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Rat.intCast_lt_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℤ} {n : ℚ}, (↑m < ↑n) = (↑m < n) | false |
invOf_inj | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a] [inst_2 : Invertible b], ⅟a = ⅟b ↔ a = b | true |
AlgebraicGeometry.LocallyRingedSpace.isoOfSheafedSpaceIso._proof_3 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X.toSheafedSpace ≅ Y.toSheafedSpace), CategoryTheory.IsIso f.hom | false |
Function.iterate_add._f | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α) (m x : ℕ) (f_1 : Nat.below x), f^[m + x] = f^[m] ∘ f^[x] | false |
CategoryTheory.MorphismProperty.Comma | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
CategoryTheory.Functor A T →
CategoryTheory.Functor B T →
... | true |
_private.Mathlib.RingTheory.Valuation.Integers.0.Valuation.Integers.dvdNotUnit_iff_lt._simp_1_1 | Mathlib.RingTheory.Valuation.Integers | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Turing.PartrecToTM2.Λ'.Supports.eq_def | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (S : Finset Turing.PartrecToTM2.Λ') (x : Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.Λ'.Supports S x =
match x with
| Turing.PartrecToTM2.Λ'.move p k₁ k₂ q => Turing.PartrecToTM2.Λ'.Supports S q
| Turing.PartrecToTM2.Λ'.push k s q => Turing.PartrecToTM2.Λ'.Supports S q
| Turing.PartrecToTM2.Λ'.read... | true |
TopCat.Presheaf.pullback | Mathlib.Topology.Sheaves.Presheaf | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasColimits C] →
{X Y : TopCat} → (X ⟶ Y) → CategoryTheory.Functor (TopCat.Presheaf C Y) (TopCat.Presheaf C X) | true |
HasFDerivWithinAt.prodMap | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {G' : Type u_5} [inst_7 : NormedAddCo... | true |
RingCat.ctorIdx | Mathlib.Algebra.Category.Ring.Basic | RingCat → ℕ | false |
MeasureTheory.Submartingale.integrable_stoppedValue | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {𝒢 : MeasureTheory.Filtration ℕ m0} [inst_3 : LE E]
{f : ℕ → Ω → E},
MeasureTheory.Submartingale f 𝒢 μ →
∀ {τ : Ω → ℕ∞},
MeasureThe... | true |
LinearMap.eq_restrictScalarsRange_iff | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {P : Type u_4} {M' : Type u_5} {P' : Type u_6} [inst : Semiring R]
[inst_1 : Semiring S] [inst_2 : SMul S R] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid P]
[inst_6 : Module R P] [inst_7 : Module S M] [inst_8 : Module S P] [inst_9 : IsScalar... | true |
AlternatingMap.curryLeft_apply_apply | Mathlib.LinearAlgebra.Alternating.Curry | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {n : ℕ} (f : M [⋀^Fin n.succ]→ₗ[R] N) (x : M)
(v : Fin n → M), (f.curryLeft x) v = f (Matrix.vecCons x v) | true |
CircularPreorder.sbtw_iff_btw_not_btw | Mathlib.Order.Circular | ∀ {α : Type u_1} [self : CircularPreorder α] {a b c : α}, sbtw a b c ↔ btw a b c ∧ ¬btw c b a | true |
AdicCompletion.ofAlgEquiv._proof_5 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) [inst_1 : IsAdicComplete I S] (x y : S),
(↑(AdicCompletion.ofLinearEquiv I S)).toFun (x + y) =
(↑(AdicCompletion.ofLinearEquiv I S)).toFun x + (↑(AdicCompletion.ofLinearEquiv I S)).toFun y | false |
HMul.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HMul α β γ → Sort u_1} → ((hMul : α → β → γ) → motive { hMul := hMul }) → (t : HMul α β γ) → motive t | false |
mellin.eq_1 | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (f : ℝ → E) (s : ℂ),
mellin f s = ∫ (t : ℝ) in Set.Ioi 0, ↑t ^ (s - 1) • f t | true |
MeasureTheory.LocallyIntegrable.locallyIntegrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X},
MeasureTheory.LocallyIntegrable f μ → ∀ (s : Set X), MeasureTheory.LocallyIntegrableOn f s μ | true |
toDual_symmDiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α),
OrderDual.toDual (symmDiff a b) = bihimp (OrderDual.toDual a) (OrderDual.toDual b) | true |
Concept.instLattice._proof_2 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} {r : α → β → Prop} (a b : Concept α β r), SemilatticeInf.inf a b ≤ b | false |
Algebra.PreSubmersivePresentation.mk.congr_simp | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(toPresentation toPresentation_1 : Algebra.Presentation R S ι σ),
toPresentation = toPresentation_1 →
∀ (map map_1 : σ → ι) (e_map : map = map_1) (map_inj : Function.Injective map),
{ toP... | true |
TopModuleCat.indiscrete._proof_6 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_2) [inst : Ring R] (X : ModuleCat R), ContinuousAdd ↑X | false |
TensorProduct.equivFinsuppOfBasisLeft.eq_1 | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : DecidableEq ι]
(ℬ : Module.Basis ι R M),
TensorProduct.equivFinsuppOfBasisLeft ℬ = (TensorProduct.comm R M N).trans (Ten... | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory._aux_Mathlib_CategoryTheory_Localization_Monoidal_Basic___unexpand_CategoryTheory_Localization_Monoidal_toMonoidalCategory_1 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | Lean.PrettyPrinter.Unexpander | false |
AlternatingMap.instAddCommGroup._proof_3 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N' : Type u_3}
[inst_3 : AddCommGroup N'] [inst_4 : Module R N'] {ι : Type u_4},
autoParam (∀ (n : ℕ) (a : M [⋀^ι]→ₗ[R] N'), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | false |
_private.Std.Data.Iterators.Lemmas.Producers.Vector.0.Std.Iterators.Types.ArrayIterator.instIterator.match_1.eq_1 | Std.Data.Iterators.Lemmas.Producers.Vector | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it' : Std.IterM m α)
(out : α) (h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(mat... | true |
Finset.sym2_nonempty._simp_1 | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α}, s.sym2.Nonempty = s.Nonempty | false |
NNRat.cast_mk | Mathlib.Data.Rat.Cast.Lemmas | ∀ {K : Type u_1} [inst : DivisionRing K] (q : ℚ) (h : 0 ≤ q), ↑⟨q, h⟩ = ↑q | true |
Rat.uniformContinuous_coe_real | Mathlib.Topology.Instances.Rat | UniformContinuous Rat.cast | true |
LeftCancelMonoid.casesOn | Mathlib.Algebra.Group.Defs | {M : Type u} →
{motive : LeftCancelMonoid M → Sort u_1} →
(t : LeftCancelMonoid M) →
([toMonoid : Monoid M] →
[toIsLeftCancelMul : IsLeftCancelMul M] →
motive { toMonoid := toMonoid, toIsLeftCancelMul := toIsLeftCancelMul }) →
motive t | false |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.CancelDenoms.cancelDenominatorsInType.match_5 | Mathlib.Tactic.CancelDenoms.Core | (motive : Option (Lean.Expr × Lean.Expr × Lean.Name × Bool) → Sort u_1) →
(__discr : Option (Lean.Expr × Lean.Expr × Lean.Name × Bool)) →
((lhs rhs : Lean.Expr) → (lem : Lean.Name) → (ord : Bool) → motive (some (lhs, rhs, lem, ord))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Name × Bool)) → motive x) → m... | false |
«prec(_)» | Init.Notation | Lean.ParserDescr | true |
IO.FS.Stream.ofHandle | Init.System.IO | IO.FS.Handle → IO.FS.Stream | true |
OrderDual.isCobounded_preimage_ofDual | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} [inst : Bornology α] {s : Set α},
Bornology.IsCobounded (⇑OrderDual.ofDual ⁻¹' s) ↔ Bornology.IsCobounded s | true |
Lean.MonadCacheT.instMonadHashMapCacheAdapter | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] →
[inst_2 : Hashable α] → [MonadLiftT (ST ω) m] → Lean.MonadHashMapCacheAdapter α β (Lean.MonadCacheT α β m) | true |
_private.Init.Data.Option.Array.0.List.forIn'_cons.match_1.eq_1 | Init.Data.Option.Array | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.done b))
(h_2 : (b : β) → motive (ForInStep.yield b)),
(match ForInStep.done b with
| ForInStep.done b => h_1 b
| ForInStep.yield b => h_2 b) =
h_1 b | true |
_private.Init.Data.Format.Basic.0.Std.Format.FlattenAllowability.shouldFlatten.match_1 | Init.Data.Format.Basic | (motive : Std.Format.FlattenAllowability → Sort u_1) →
(x : Std.Format.FlattenAllowability) →
(Unit → motive (Std.Format.FlattenAllowability.allow true)) →
((x : Std.Format.FlattenAllowability) → motive x) → motive x | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo.match_8 | Lean.Meta.MethodSpecs | (motive : Option Lean.Name → Sort u_1) →
(__x : Option Lean.Name) →
((clsName : Lean.Name) → motive (some clsName)) → ((x : Option Lean.Name) → motive x) → motive __x | false |
Std.DTreeMap.getD_eq_getD_get? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {a : α} {fallback : β a}, t.getD a fallback = (t.get? a).getD fallback | true |
ContinuousLinearMap.flipMultilinearEquiv._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) {ι : Type u_5} (E : ι → Type u_4) (G : Type u_2) (G' : Type u_3) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | false |
List.nnnorm_prod_le' | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] {l : List α}, l ≠ [] → ‖l.prod‖₊ ≤ (List.map nnnorm l).prod | true |
CategoryTheory.SplitMono._sizeOf_inst | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.SplitMono f) | false |
SubAddAction.instSetLike | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : VAdd R M] → SetLike (SubAddAction R M) M | true |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.correspondence._simp_1 | Mathlib.RingTheory.Congruence.Hom | ∀ {R : Type u_2} {R' : Type u_3} {F : Type u_4} [inst : Add R] [inst_1 : Add R'] [inst_2 : FunLike F R R']
[inst_3 : AddHomClass F R R'] [inst_4 : Mul R] [inst_5 : Mul R'] [inst_6 : MulHomClass F R R'] {J : RingCon R'}
{f : F} {x y : R}, (J.comap f) x y = J (f x) (f y) | false |
Set.IsWF.min_vadd | Mathlib.Data.Finset.SMulAntidiagonal | ∀ {G : Type u_1} {P : Type u_2} [inst : LinearOrder G] [inst_1 : LinearOrder P] [inst_2 : VAdd G P]
[inst_3 : IsOrderedVAdd G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty)
(htn : t.Nonempty), ⋯.min ⋯ = hs.min hsn +ᵥ ht.min htn | true |
Submonoid.coe_iInf._simp_2 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] {ι : Sort u_4} {S : ι → Submonoid M}, ⋂ i, ↑(S i) = ↑(⨅ i, S i) | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.instHashableBVBinOp.hash.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | (motive : Std.Tactic.BVDecide.BVBinOp → Sort u_1) →
(x : Std.Tactic.BVDecide.BVBinOp) →
(Unit → motive Std.Tactic.BVDecide.BVBinOp.and) →
(Unit → motive Std.Tactic.BVDecide.BVBinOp.or) →
(Unit → motive Std.Tactic.BVDecide.BVBinOp.xor) →
(Unit → motive Std.Tactic.BVDecide.BVBinOp.add) →
... | false |
ValuativeRel.instLinearOrderedCommGroupWithZeroValueGroupWithZero | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : CommRing R] → [inst_1 : ValuativeRel R] → LinearOrderedCommGroupWithZero (ValuativeRel.ValueGroupWithZero R) | true |
ProperCone.innerDual_univ | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : CompleteSpace E],
ProperCone.innerDual Set.univ = ⊥ | true |
Matrix.toLin'_symm | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : DecidableEq n] [inst_2 : Fintype n],
Matrix.toLin'.symm = LinearMap.toMatrix' | true |
Finset.sum_cancels_of_partition_cancels | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f : ι → M} (R : Setoid ι)
[inst_1 : DecidableRel ⇑R], (∀ x ∈ s, ∑ a ∈ s with R a x, f a = 0) → ∑ x ∈ s, f x = 0 | true |
Topology.IsEmbedding.induced | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [t : TopologicalSpace Y], Function.Injective f → Topology.IsEmbedding f | true |
CategoryTheory.Limits.MulticospanIndex.multicospan_obj | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) (x : CategoryTheory.Limits.WalkingMulticospan J),
I.multicospan.obj x =
match x with
| CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
| Cate... | true |
Lean.MetavarContext.noConfusion | Lean.MetavarContext | {P : Sort u} → {t t' : Lean.MetavarContext} → t = t' → Lean.MetavarContext.noConfusionType P t t' | false |
smoothSheafRing._proof_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | false |
MvPolynomial.rTensorAlgHom._proof_4 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u_1} {N : Type u_4} [inst : CommSemiring R] {σ : Type u_3} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : CommSemiring N] [inst_4 : Algebra R N],
IsScalarTower R S (AddMonoidAlgebra (TensorProduct R S N) (σ →₀ ℕ)) | false |
Aesop.GoalOrigin.toString | Aesop.Tree.Data | Aesop.GoalOrigin → String | true |
Set.vadd_set_inter_subset | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {t₁ t₂ : Set β} {a : α}, a +ᵥ t₁ ∩ t₂ ⊆ (a +ᵥ t₁) ∩ (a +ᵥ t₂) | true |
Lean.Order.FlatOrder.instOrder | Init.Internal.Order.Basic | {α : Sort u} → {b : α} → Lean.Order.PartialOrder (Lean.Order.FlatOrder b) | true |
IntervalIntegrable.congr_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] [TopologicalSpace.PseudoMetrizableSpace ε]
{f : ℝ → ε} {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {g : ℝ → ε},
IntervalIntegrable f μ a b → f =ᵐ[μ.restrict (Set.uIoc a b)] g → IntervalIntegrable g μ a b | true |
_private.Mathlib.GroupTheory.Perm.Fin.0.Equiv.Perm.prod_Iio_comp_eq_sign_mul_prod.match_1_2 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} (D : Finset ((_ : Fin n) × Fin n)) (motive : (x : (_ : Fin n) × Fin n) → x ∈ D → Prop)
(x : (_ : Fin n) × Fin n) (hx : x ∈ D), (∀ (x₁ x₂ : Fin n) (hx : ⟨x₁, x₂⟩ ∈ D), motive ⟨x₁, x₂⟩ hx) → motive x hx | false |
ContT.instULiftableULiftULift | Mathlib.Control.ULiftable | {s : Type u₀} →
{m : Type (max u₀ v₀) → Type u_5} →
{m' : Type (max u₀ v₁) → Type u_6} →
[ULiftable m m'] → ULiftable (ContT (ULift.{max v₀ u₀, u₀} s) m) (ContT (ULift.{max v₁ u₀, u₀} s) m') | true |
Aesop.instOrdDisplayRuleName.ord | Aesop.Rule.Name | Aesop.DisplayRuleName → Aesop.DisplayRuleName → Ordering | true |
Set.surjOn_image | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.SurjOn f s (f '' s) | true |
ContinuousAlternatingMap.toContinuousLinearMap | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_4} →
{ι : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R N] →
... | true |
List.Perm.nodup_iff | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → (l₁.Nodup ↔ l₂.Nodup) | true |
Commute.expUnitary | Mathlib.Analysis.CStarAlgebra.Exponential | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] [inst_2 : StarRing A] [inst_3 : ContinuousStar A]
[inst_4 : CompleteSpace A] [inst_5 : StarModule ℂ A] {a b : ↥(selfAdjoint A)},
Commute ↑a ↑b → Commute (selfAdjoint.expUnitary a) (selfAdjoint.expUnitary b) | true |
_private.Mathlib.Tactic.ProxyType.0.Mathlib.ProxyType.defaultMkProxyType._proof_1 | Mathlib.Tactic.ProxyType | ∀ (ctors : Array (Lean.Name × Lean.Expr × Lean.Term)), ∀ i ∈ [:ctors.size], i < ctors.size | false |
AlgHom.liftOfSurjective_apply | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_5} {A : Type u_6} {B : Type u_7} {C : Type u_8} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing B] [inst_3 : CommRing C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (hf : Function.Surjective ⇑f) (g : A →ₐ[R] C) (H : RingHom.ker f.toRingHom ≤ RingHo... | true |
WeakDual.CharacterSpace.compContinuousMap_comp | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing A]
[inst_2 : NormedAlgebra 𝕜 A] [inst_3 : CompleteSpace A] [inst_4 : StarRing A] [inst_5 : NormedRing B]
[inst_6 : NormedAlgebra 𝕜 B] [inst_7 : CompleteSpace B] [inst_8 : StarRing B] [inst_9 : N... | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.tsum_eisSummand_eq_tsum_sigma_mul_cexp_pow._proof_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {k : ℕ}, 3 ≤ k → k - 1 + 1 = k | false |
MulSemiringActionHom._sizeOf_1 | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
{inst : Monoid M} →
{N : Type u_2} →
{inst_1 : Monoid N} →
{φ : M →* N} →
{R : Type u_10} →
{inst_2 : Semiring R} →
{inst_3 : MulSemiringAction M R} →
{S : Type u_12} →
{inst_4 : Semiring S} →
... | false |
_private.Mathlib.FieldTheory.Galois.IsGaloisGroup.0.IsGaloisGroup.ringEquivFixedPoints._simp_3 | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
IsStarProjection.one._simp_1 | Mathlib.Algebra.Star.StarProjection | ∀ (R : Type u_1) [inst : MulOneClass R] [inst_1 : StarMul R], IsStarProjection 1 = True | false |
Aesop.RuleTacDescr.tacticStx.elim | Aesop.RuleTac.Descr | {motive : Aesop.RuleTacDescr → Sort u} →
(t : Aesop.RuleTacDescr) →
t.ctorIdx = 8 → ((stx : Lean.Syntax) → motive (Aesop.RuleTacDescr.tacticStx stx)) → motive t | false |
Ordnode.all_balanceR | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α},
l.Balanced →
r.Balanced →
l.Sized →
r.Sized →
((∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r') →
(Ordnode.All ... | true |
Std.HashMap.any_eq_true_iff_exists_mem_getElem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {p : α → β → Bool},
m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = true | true |
CategoryTheory.CommSq.op | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z}, CategoryTheory.CommSq f g h i → CategoryTheory.CommSq i.op h.op g.op f.op | true |
Aesop.instInhabitedScopeName | Aesop.Rule.Name | Inhabited Aesop.ScopeName | true |
CategoryTheory.Center.whiskerRight.eq_1 | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X₁ X₂ : CategoryTheory.Center C} (f : X₁ ⟶ X₂) (Y : CategoryTheory.Center C),
CategoryTheory.Center.whiskerRight f Y =
{ f := CategoryTheory.MonoidalCategoryStruct.whiskerRight f.f Y.fst, comm := ⋯ } | true |
MeasureTheory.measureReal_union_add_inter | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasurableSet t →
autoParam (μ s ≠ ⊤) MeasureTheory.measureReal_union_add_inter._auto_1 →
autoParam (μ t ≠ ⊤) MeasureTheory.measureReal_union_add_inter._auto_3 →
μ.real (s ∪ t) + μ.real (s ∩ t) = μ.real s + μ.real ... | true |
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.instLaxMonoidalDiscretePUnitMonToLaxMonoidalObj._proof_8 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.Mon C) (X : CategoryTheory.Discrete PUnit.{u_1 + 1}),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
((CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidalObj A).obj... | false |
Std.DHashMap.Internal.Raw₀.getD_diff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.diff m₂).getD k fallback = if m₂.contains k = true then fallback else m₁.getD k fallback | true |
CategoryTheory.CatEnrichedOrdinary.hComp._proof_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {a b c : CategoryTheory.CatEnrichedOrdinary C}
{f' : a ⟶ b} {g' : b ⟶ c},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatEnrichedOrdinary.homEquiv f')
(CategoryTheory... | false |
_private.Init.Data.Vector.Lemmas.0.Vector.any_eq'._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs : Vector α n}, (xs.any p = true) = ∃ x ∈ xs, p x = true | false |
_private.Batteries.Data.Char.Basic.0.Char.of_any_eq_false_aux._proof_1_14 | Batteries.Data.Char.Basic | ∀ (n : ℕ), 57343 < n → n < 1114112 → ¬n - (57343 + 1) < 1114111 - 57343 → False | false |
CategoryTheory.GrpObj.tensorObj.instTensorObj | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[CategoryTheory.BraidedCategory C] →
{G H : C} →
[CategoryTheory.GrpObj G] →
[CategoryTheory.GrpObj H] → CategoryTheory.GrpObj (CategoryTheory.MonoidalCategoryS... | true |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.FiniteMulArchimedeanClass.lift.match_1.splitter | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedMonoid M] →
(motive : FiniteMulArchimedeanClass M → Sort u_2) →
(x : FiniteMulArchimedeanClass M) → ((A : MulArchimedeanClass M) → (hA : A ≠ ⊤) → motive ⟨A, hA⟩) → motive x | true |
CategoryTheory.Limits.opCoproductIsoProduct_hom_comp_π | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct Z] (i : α),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opCoproductIsoProduct Z).hom
(CategoryTheory.Limits.Pi.π (fun x => Opposite.op (Z x)) i) =
(CategoryTheo... | true |
DivisionMonoid.npow._inherited_default | Mathlib.Algebra.Group.Defs | {G : Type u} → (mul : G → G → G) → (∀ (a b c : G), a * b * c = a * (b * c)) → G → ℕ → G → G | false |
TemperedDistribution.besselPotential.congr_simp | Mathlib.Analysis.Distribution.Sobolev | ∀ (E : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : NormedSpace ℂ F] (s s_1 : ℝ),
s = s_1 → TemperedDistribution.besselPotential E F s = Temper... | true |
List.maxOn.congr_simp | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [i : LE β] {inst : DecidableLE β} [inst_1 : DecidableLE β] (f f_1 : α → β),
f = f_1 → ∀ (l l_1 : List α) (e_l : l = l_1) (h : l ≠ []), List.maxOn f l h = List.maxOn f_1 l_1 ⋯ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.