name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PowerSeries.coe_sub | Mathlib.RingTheory.LaurentSeries | ∀ {R' : Type u_2} [inst : Ring R'] (f' g' : PowerSeries R'),
(HahnSeries.ofPowerSeries ℤ R') (f' - g') = (HahnSeries.ofPowerSeries ℤ R') f' - (HahnSeries.ofPowerSeries ℤ R') g' | true |
Std.ExtDTreeMap.union | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp | true |
LinearEquiv.rTensor_zpow | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (f : M ≃ₗ[R] M) (n : ℤ),
LinearEquiv.rTensor N f ^ n = LinearEquiv.rTensor N (f ^ n) | true |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.instInhabitedSimpleGroundValue | Lean.Compiler.IR.SimpleGroundExpr | Inhabited Lean.IR.SimpleGroundValue✝ | true |
InnerProductSpace.Core.topology_eq | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[cd : InnerProductSpace.Core 𝕜 F] [tF : TopologicalSpace F] [IsTopologicalAddGroup F] [ContinuousConstSMul 𝕜 F],
ContinuousAt (fun v => inner 𝕜 v v) 0 →
Bornology.IsVonNBounded 𝕜 {v | RCLike.re (inner 𝕜 v v) < 1} →
tF = PseudoMetricSpace.toUniformSpace.toTopologicalSpace | true |
WithZero.coe_pow._simp_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℕ] (a : α) (n : ℕ), ↑a ^ n = ↑(a ^ n) | false |
CategoryTheory.Limits.Types.isColimitOfMulticoequalizerDiagram._simp_9 | Mathlib.CategoryTheory.Limits.Types.Multicoequalizer | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.Adjunction.homEquiv_apply | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {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} (adj : F ⊣ G) (X : C) (Y : D) (f : F.obj X ⟶ Y),
(adj.homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (adj.unit.app X) (G.map f) | true |
Finset.subset_vadd | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : VAdd α β] {u : Finset β} {s : Set α} {t : Set β},
↑u ⊆ s +ᵥ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' +ᵥ t' | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.Indep.fundCircuit_isCircuit._simp_1_2 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Field.DirectLimit.field._proof_3 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : Nonempty ι] [inst_2 : IsDirectedOrder ι]
[inst_3 : (i : ι) → Field (G i)] (f' : (i j : ι) → i ≤ j → G i →+* G j) (n : ℕ)
(a : Ring.DirectLimit G fun x1 x2 x3 => ⇑(f' x1 x2 x3)), zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | false |
ZFSet.iUnion_vonNeumann | Mathlib.SetTheory.ZFC.VonNeumann | ⋃ o, ↑(ZFSet.vonNeumann o) = Class.univ | true |
Finset.empty_eq_image._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α}, (∅ = Finset.image f s) = (s = ∅) | false |
ContinuousAlternatingMap.piLinearEquiv._proof_2 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {ι' : Type u_2} {M' : ι' → Type u_3} [inst_1 : (i : ι') → AddCommMonoid (M' i)]
[inst_2 : (i : ι') → TopologicalSpace (M' i)] [inst_3 : (i : ι') → Module R (M' i)]
[∀ (i : ι'), ContinuousConstSMul R (M' i)], ContinuousConstSMul R ((i : ι') → M' i) | false |
AddSubgroup.prod | Mathlib.Algebra.Group.Subgroup.Basic | {G : Type u_1} →
[inst : AddGroup G] → {N : Type u_5} → [inst_1 : AddGroup N] → AddSubgroup G → AddSubgroup N → AddSubgroup (G × N) | true |
AddLECancellable.tsub_lt_tsub_iff_left_of_le | Mathlib.Algebra.Order.Sub.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b c : α}, AddLECancellable a → AddLECancellable b → b ≤ a → (a - b < a - c ↔ c < b) | true |
CategoryTheory.Pi.closedUnit | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] →
[inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)] →
(X : (i : I) → C i) →
CategoryTheory.Functor.id ((i : I) → C i) ⟶
(CategoryTheory.MonoidalCategory.tensorLeft X).comp (CategoryTheory.Pi.ihom X) | true |
_private.Batteries.Data.Array.Scan.0.Array.getElem_succ_scanl._proof_1_6 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {b : β} {as : Array α} {f : β → α → β} (h : i + 1 < (Array.scanl f b as).size),
(List.scanl f b as.toList)[i + 1] = f (List.scanl f b as.toList)[i] as[i] | false |
String.Pos.Raw.extract.go₂._sunfold | Init.Data.String.Basic | List Char → String.Pos.Raw → String.Pos.Raw → List Char | false |
MeasureTheory.Measure.comap | Mathlib.MeasureTheory.Measure.Comap | {α : Type u_1} →
{β : Type u_2} →
[inst : MeasurableSpace α] →
[inst_1 : MeasurableSpace β] → (α → β) → MeasureTheory.Measure β → MeasureTheory.Measure α | true |
IsPGroup.of_equiv | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G ≃* H), IsPGroup p H | true |
CategoryTheory.CountableCategory.objAsTypeEquiv._proof_1 | Mathlib.CategoryTheory.Countable | ∀ (α : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} α] [inst_1 : CategoryTheory.CountableCategory α],
(CategoryTheory.inducedFunctor ⇑(equivShrink α).symm).IsEquivalence | false |
Aesop.getConclusionDiscrTreeKeys | Aesop.Util.Basic | Lean.Expr → Lean.MetaM (Array Lean.Meta.DiscrTree.Key) | true |
Int.ediv_eq_iff_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {k x y : ℤ}, 0 < k → (x / k = y ↔ y * k ≤ x ∧ x < y * k + k) | true |
CommGrpCat.Hom.casesOn | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →* ↑B) → motive { hom' := hom' }) → motive t | false |
LinearOrderedAddCommGroupWithTop.top_pos._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α], (0 < ⊤) = True | false |
CategoryTheory.InjectiveResolution.ctorIdx | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} → {Z : C} → CategoryTheory.InjectiveResolution Z → ℕ | false |
Polynomial.logMahlerMeasure_mul_eq_add_logMahlerMeasure | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {p q : Polynomial ℂ}, p * q ≠ 0 → (p * q).logMahlerMeasure = p.logMahlerMeasure + q.logMahlerMeasure | true |
Prod.mk_wcovBy_mk_iff | Mathlib.Order.Cover | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] {a₁ a₂ : α} {b₁ b₂ : β},
(a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂ | true |
LLVM.Value.noConfusion | Lean.Compiler.IR.LLVMBindings | {P : Sort u} →
{ctx : LLVM.Context} →
{t : LLVM.Value ctx} →
{ctx' : LLVM.Context} → {t' : LLVM.Value ctx'} → ctx = ctx' → t ≍ t' → LLVM.Value.noConfusionType P t t' | false |
Derivation.mapCoeffs._proof_2 | Mathlib.RingTheory.Derivation.MapCoeffs | ∀ {R : Type u_3} {A : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : AddCommGroup M] [inst_4 : Module A M] [inst_5 : Module R M] (d : Derivation R A M) (p q : Polynomial A),
(PolynomialModule.map A ↑d ∘ₗ ↑PolynomialModule.equivPolynomial.symm) (p * q) =
p • (PolynomialModule.map A ↑d ∘ₗ ↑PolynomialModule.equivPolynomial.symm) q +
q • (PolynomialModule.map A ↑d ∘ₗ ↑PolynomialModule.equivPolynomial.symm) p | false |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Turing.TM2to1.stRun.match_1.splitter | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_3} →
{k : K} →
(motive : Turing.TM2to1.StAct K Γ σ k → Sort u_4) →
(x : Turing.TM2to1.StAct K Γ σ k) →
((f : σ → Γ k) → motive (Turing.TM2to1.StAct.push f)) →
((f : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.peek f)) →
((f : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.pop f)) → motive x | true |
AList.extract | Mathlib.Data.List.AList | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → AList β → Option (β a) × AList β | true |
BddDistLat.mk.injEq | Mathlib.Order.Category.BddDistLat | ∀ (toDistLat : DistLat) [isBoundedOrder : BoundedOrder ↑toDistLat] (toDistLat_1 : DistLat)
(isBoundedOrder_1 : BoundedOrder ↑toDistLat_1),
({ toDistLat := toDistLat, isBoundedOrder := isBoundedOrder } =
{ toDistLat := toDistLat_1, isBoundedOrder := isBoundedOrder_1 }) =
(toDistLat = toDistLat_1 ∧ isBoundedOrder ≍ isBoundedOrder_1) | true |
Subgroup.discreteTopology_iff_of_isFiniteRelIndex | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [T2Space G] {H K : Subgroup G},
H ≤ K → ∀ [H.IsFiniteRelIndex K], DiscreteTopology ↥H ↔ DiscreteTopology ↥K | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.Context.ctorIdx | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.Context✝ → ℕ | false |
Batteries.HashMap.casesOn | Batteries.Data.HashMap.Basic | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Batteries.HashMap α β → Sort u_1} →
(t : Batteries.HashMap α β) → ((inner : Std.HashMap α β) → motive { inner := inner }) → motive t | false |
MeasureTheory.NoAtoms.rec | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | {α : Type u_1} →
{m0 : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.NoAtoms μ → Sort u} →
((measure_singleton : ∀ (x : α), μ {x} = 0) → motive ⋯) → (t : MeasureTheory.NoAtoms μ) → motive t | false |
Std.IterM.fold_hom | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β γ₁ γ₂ : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} (f : γ₁ → γ₂)
{g₁ : γ₁ → β → γ₁} {g₂ : γ₂ → β → γ₂} {init : γ₁},
(∀ (x : γ₁) (y : β), g₂ (f x) y = f (g₁ x y)) → Std.IterM.fold g₂ (f init) it = f <$> Std.IterM.fold g₁ init it | true |
Equiv.coe_vaddConst | Mathlib.Algebra.AddTorsor.Defs | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [inst_1 : AddTorsor G P] (p : P),
⇑(Equiv.vaddConst p) = fun v => v +ᵥ p | true |
CompHausLike.instPreservesLimitTopCatWalkingCospanCospanCompHausLikeToTop | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g],
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.compHausLikeToTop P) | true |
MeasurableVAdd₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [VAdd M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop | true |
Vector.getElem?_eq_some_getElem_iff | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} (h : i < n), xs[i]? = some xs[i] ↔ True | true |
Std.Tactic.BVDecide.LRAT.Internal.CNF.convertLRAT' | Std.Tactic.BVDecide.LRAT.Internal.Convert | {n : ℕ} →
Std.Sat.CNF (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
Array (Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)) | true |
USize.toUInt64_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
USize.size ≤ n →
(USize.ofNatTruncate n).toUInt64 = UInt64.ofNatLT (USize.size - 1) USize.toUInt64_ofNatTruncate_of_le._proof_1 | true |
Lean.Meta.DefEqCacheKeyInfo.mk.noConfusion | Lean.Meta.ExprDefEq | {P : Sort u} →
{kind : Lean.Meta.DefEqCacheKind} →
{key : Lean.Meta.DefEqCacheKey} →
{kind' : Lean.Meta.DefEqCacheKind} →
{key' : Lean.Meta.DefEqCacheKey} →
{ kind := kind, key := key } = { kind := kind', key := key' } → (kind = kind' → key = key' → P) → P | false |
SetLike.GradeZero.instRing._proof_11 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | false |
_private.Init.Data.Nat.Lemmas.0.Nat.sub_add_sub_cancel._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, b ≤ a → c ≤ b → ¬a - b + (b - c) = a - c → False | false |
CategoryTheory.Kleisli.category_id_of | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C) (X : CategoryTheory.Kleisli T),
(CategoryTheory.CategoryStruct.id X).of = T.η.app X.of | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_10 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
String.Slice.mk.noConfusion | Init.Data.String.Defs | {P : Sort u} →
{str : String} →
{startInclusive endExclusive : str.Pos} →
{startInclusive_le_endExclusive : startInclusive ≤ endExclusive} →
{str' : String} →
{startInclusive' endExclusive' : str'.Pos} →
{startInclusive_le_endExclusive' : startInclusive' ≤ endExclusive'} →
{ str := str, startInclusive := startInclusive, endExclusive := endExclusive,
startInclusive_le_endExclusive := startInclusive_le_endExclusive } =
{ str := str', startInclusive := startInclusive', endExclusive := endExclusive',
startInclusive_le_endExclusive := startInclusive_le_endExclusive' } →
(str = str' → startInclusive ≍ startInclusive' → endExclusive ≍ endExclusive' → P) → P | false |
ContinuousLinearEquiv.conjContinuousAlgEquiv | Mathlib.Topology.Algebra.Module.StrongTopology | {𝕜 : Type u_1} →
{G : Type u_4} →
{H : Type u_5} →
[inst : AddCommGroup G] →
[inst_1 : AddCommGroup H] →
[inst_2 : NormedField 𝕜] →
[inst_3 : Module 𝕜 G] →
[inst_4 : Module 𝕜 H] →
[inst_5 : TopologicalSpace G] →
[inst_6 : TopologicalSpace H] →
[inst_7 : IsTopologicalAddGroup G] →
[inst_8 : IsTopologicalAddGroup H] →
[inst_9 : ContinuousConstSMul 𝕜 G] →
[inst_10 : ContinuousConstSMul 𝕜 H] → (G ≃L[𝕜] H) → (G →L[𝕜] G) ≃A[𝕜] H →L[𝕜] H | true |
UpperHalfPlane.atImInfty | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | Filter UpperHalfPlane | true |
CategoryTheory.Pseudofunctor.map₂_left_unitor_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (self : CategoryTheory.Pseudofunctor B CategoryTheory.Cat)
{a b : B} (f : a ⟶ b) (X : ↑(self.obj a)),
(self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom).toNatTrans.app X =
CategoryTheory.CategoryStruct.comp ((self.mapComp (CategoryTheory.CategoryStruct.id a) f).hom.toNatTrans.app X)
(CategoryTheory.CategoryStruct.comp ((self.map f).toFunctor.map ((self.mapId a).hom.toNatTrans.app X))
(CategoryTheory.eqToHom ⋯)) | true |
SimpleGraph.commonNeighbors_subset_neighborSet_left | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), G.commonNeighbors v w ⊆ G.neighborSet v | true |
Std.ExtTreeMap.foldrM | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{δ : Type w} →
{m : Type w → Type w₂} →
[inst : Monad m] → [LawfulMonad m] → [Std.TransCmp cmp] → (α → β → δ → m δ) → δ → Std.ExtTreeMap α β cmp → m δ | true |
DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(a : Fin n) (hV' : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ),
(DirectSum.IsInternal.subordinateOrthonormalBasis hn hV hV') a ∈
V (DirectSum.IsInternal.subordinateOrthonormalBasisIndex hn hV a hV') | true |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_10 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Lean.JsonRpc.instCoeOutResponseErrorMessageOfToJson | Lean.Data.JsonRpc | {α : Type u_1} → [Lean.ToJson α] → CoeOut (Lean.JsonRpc.ResponseError α) Lean.JsonRpc.Message | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.seq_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} {β : Type u_1} (motive : (x : ℕ) → (Fin x → α → β) → (Fin x → α) → Prop) (x : ℕ) (x_1 : Fin x → α → β)
(x_2 : Fin x → α),
(∀ (x : Fin 0 → α → β) (x_3 : Fin 0 → α), motive 0 x x_3) →
(∀ (n : ℕ) (f : Fin (n + 1) → α → β) (v : Fin (n + 1) → α), motive n.succ f v) → motive x x_1 x_2 | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.isStronglyTranscendental_iff_of_field._simp_1_5 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ (α : Type u_3) [Nontrivial α], Subsingleton α = False | false |
_private.Init.Data.UInt.Bitwise.0.UInt64.shiftLeft_or._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | false |
_private.Init.Data.List.Nat.Range.0.List.sum_range'._simp_1_1 | Init.Data.List.Nat.Range | ∀ (n m k : ℕ), n + (m + k) = n + m + k | false |
Std.Rxc.Iterator.rec | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
{motive : Std.Rxc.Iterator α → Sort u_1} →
((next : Option α) → (upperBound : α) → motive { next := next, upperBound := upperBound }) →
(t : Std.Rxc.Iterator α) → motive t | false |
NonUnitalAlgHom.snd | Mathlib.Algebra.Algebra.NonUnitalHom | (R : Type u) →
[inst : Monoid R] →
(A : Type v) →
(B : Type w) →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : NonUnitalNonAssocSemiring B] → [inst_4 : DistribMulAction R B] → A × B →ₙₐ[R] B | true |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorLeftObjFunctorTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : W.IsMonoidal] →
[inst_4 : L.IsLocalization W] →
{unit : D} →
(ε : L.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ unit) →
(X : C) →
CategoryTheory.Localization.Lifting
(CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε) W
((CategoryTheory.MonoidalCategory.tensorLeft X).comp
(CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε))
((CategoryTheory.Localization.Monoidal.tensorBifunctor L W ε).obj
((CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε).obj X)) | true |
Lean.Elab.Tactic.evalTacticSeqBracketed | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | true |
Module.Relations.Solution.postcomp_id | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M), solution.postcomp LinearMap.id = solution | true |
Quaternion.normSq_ne_zero | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
Quaternion.normSq a ≠ 0 ↔ a ≠ 0 | true |
MonoidAlgebra.single_commute_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m₁ m₂ : M} [inst_1 : Mul M],
Commute m₁ m₂ → Commute r₁ r₂ → Commute (MonoidAlgebra.single m₁ r₁) (MonoidAlgebra.single m₂ r₂) | true |
Polynomial.monic_one | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 1 | true |
Std.ExtDHashMap.getKeyD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, (m₁ ∪ m₂).getKeyD k fallback = m₂.getKeyD k (m₁.getKeyD k fallback) | true |
FirstOrder.Language.Theory.CompleteType.formula_mem_typeOf | Mathlib.ModelTheory.Types | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {M : Type w'} [inst : L.Structure M] [inst_1 : Nonempty M]
[inst_2 : M ⊨ T] {v : α → M} {φ : L.Formula α}, FirstOrder.Language.Formula.equivSentence φ ∈ T.typeOf v ↔ φ.Realize v | true |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_4 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
SimpleGraph.Subgraph.support_mono | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph}, H ≤ H' → H.support ⊆ H'.support | true |
lebesgue_number_lemma_of_emetric_nhdsWithin | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α} {c : α → Set α},
IsCompact s → (∀ x ∈ s, c x ∈ nhdsWithin x s) → ∃ δ > 0, ∀ x ∈ s, ∃ y, Metric.eball x δ ∩ s ⊆ c y | true |
ZLattice.comap_equiv._proof_4 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_2) [inst : NormedField K] {E : Type u_3} {F : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace K F] (L : Submodule ℤ E)
(e : F ≃ₗ[K] E), ∀ x ∈ L, (↑ℤ ↑e.symm) x ∈ ZLattice.comap K L ↑e | false |
map_inj_right_of_nonempty._simp_1 | Init.Control.Lawful.Lemmas | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Functor m] [LawfulFunctor m] [Nonempty α] {f : α → β},
(∀ {x y : α}, f x = f y → x = y) → ∀ {x y : m α}, (f <$> x = f <$> y) = (x = y) | false |
Lean.Lsp.WorkspaceEdit.ofTextEdit | Lean.Data.Lsp.Basic | Lean.Lsp.VersionedTextDocumentIdentifier → Lean.Lsp.TextEdit → Lean.Lsp.WorkspaceEdit | true |
StateM | Init.Control.State | Type u → Type u → Type u | true |
ContinuousLinearEquiv.smulLeft._proof_3 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {M₁ : Type u_1} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {G : Type u_2} [inst_2 : Group G]
[inst_3 : DistribMulAction G M₁] [ContinuousConstSMul G M₁], Continuous fun x => 1 • x | false |
_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperation.match_1.eq_4 | Mathlib.Data.Nat.Hyperoperation | ∀ (motive : ℕ → ℕ → ℕ → Sort u_1) (n x : ℕ) (h_1 : (x k : ℕ) → motive 0 x k) (h_2 : (m : ℕ) → motive 1 m 0)
(h_3 : (x : ℕ) → motive 2 x 0) (h_4 : (n x : ℕ) → motive n.succ.succ.succ x 0)
(h_5 : (n m k : ℕ) → motive n.succ m k.succ),
(match n.succ.succ.succ, x, 0 with
| 0, x, k => h_1 x k
| 1, m, 0 => h_2 m
| 2, x, 0 => h_3 x
| n.succ.succ.succ, x, 0 => h_4 n x
| n.succ, m, k.succ => h_5 n m k) =
h_4 n x | true |
AlgHom.fst_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), (AlgHom.fst R B C).comp (f.prod g) = f | true |
IsBaseChange.linearMap | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) (S : Type v₃) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsBaseChange S (Algebra.linearMap R S) | true |
differentiableWithinAt_abs_neg | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ (s : Set ℝ) {x : ℝ}, x < 0 → DifferentiableWithinAt ℝ (fun x => |x|) s x | true |
CategoryTheory.SpectralSequence.Hom.mk.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{P : Sort u} →
{hom :
(r : ℤ) →
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_1) →
E.page r ⋯ ⟶ E'.page r ⋯} →
{comm :
autoParam
(∀ (r r' : ℤ) (pq : κ)
(hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence.Hom._auto_5)
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_7),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap (hom r ⋯) pq)
(E'.iso r r' pq ⋯ ⋯).hom =
CategoryTheory.CategoryStruct.comp (E.iso r r' pq ⋯ ⋯).hom ((hom r' ⋯).f pq))
CategoryTheory.SpectralSequence.Hom.comm._autoParam} →
{hom' :
(r : ℤ) →
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_1) →
E.page r ⋯ ⟶ E'.page r ⋯} →
{comm' :
autoParam
(∀ (r r' : ℤ) (pq : κ)
(hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence.Hom._auto_5)
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_7),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap (hom' r ⋯) pq)
(E'.iso r r' pq ⋯ ⋯).hom =
CategoryTheory.CategoryStruct.comp (E.iso r r' pq ⋯ ⋯).hom ((hom' r' ⋯).f pq))
CategoryTheory.SpectralSequence.Hom.comm._autoParam} →
{ hom := hom, comm := comm } = { hom := hom', comm := comm' } → (hom ≍ hom' → P) → P | false |
VectorField.mpullbackWithin_smul | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSpace H']
{E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M}
{V : (x : M') → TangentSpace I' x} {g : M' → 𝕜},
VectorField.mpullbackWithin I I' f (g • V) s = g ∘ f • VectorField.mpullbackWithin I I' f V s | true |
_private.Mathlib.Analysis.Complex.AbsMax.0.Complex.norm_le_of_forall_mem_frontier_norm_le._simp_1_1 | Mathlib.Analysis.Complex.AbsMax | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Setoid.ker_def | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α}, (Setoid.ker f) x y ↔ f x = f y | true |
MeasureTheory.Measure.instSub | Mathlib.MeasureTheory.Measure.Sub | {α : Type u_1} → [inst : MeasurableSpace α] → Sub (MeasureTheory.Measure α) | true |
_private.Lean.Meta.Tactic.Rfl.0.Lean.Meta.Rfl.initFn._sparseCasesOn_3._@.Lean.Meta.Tactic.Rfl.914023288._hygCtx._hyg.2 | Lean.Meta.Tactic.Rfl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.Repr.0.Decidable.repr.match_1 | Init.Data.Repr | {p : Prop} →
(motive : Decidable p → ℕ → Sort u_1) →
(x : Decidable p) →
(x_1 : ℕ) →
((h : p) → (prec : ℕ) → motive (isTrue h) prec) →
((h : ¬p) → (prec : ℕ) → motive (isFalse h) prec) → motive x x_1 | false |
IsStrictWeakOrder.incomp_trans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {lt : α → α → Prop} [self : IsStrictWeakOrder α lt] (a b c : α),
¬lt a b ∧ ¬lt b a → ¬lt b c ∧ ¬lt c b → ¬lt a c ∧ ¬lt c a | true |
Lean.Elab.Tactic.Do.ProofMode.MGoal.pureRflAndAndIntro | Lean.Elab.Tactic.Do.ProofMode.Pure | Lean.Elab.Tactic.Do.ProofMode.MGoal → OptionT Lean.MetaM Lean.Expr | true |
Ideal.torsionOf.eq_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
Ideal.torsionOf R M x = (LinearMap.toSpanSingleton R M x).ker | true |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheckHygieneInfo.match_1 | Lean.Elab.Quotation.Precheck | (motive : Lean.Syntax → Sort u_1) → (x : Lean.Syntax) → ((x : Lean.Syntax) → motive x) → motive x | false |
SimpleGraph.instDecidableRelAdjDeleteEdgesOfDecidablePredSym2MemSetOfDecidableEq | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} →
{G : SimpleGraph V} →
{s : Set (Sym2 V)} →
[DecidableRel G.Adj] → [DecidablePred fun x => x ∈ s] → [DecidableEq V] → DecidableRel (G.deleteEdges s).Adj | true |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute.match_1_20 | Mathlib.RingTheory.Nilpotent.Exp | (motive : (_ : ℕ) × ℕ → Sort u_1) → (x : (_ : ℕ) × ℕ) → ((i j : ℕ) → motive ⟨i, j⟩) → motive x | false |
Stream'.Seq.map_append | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s t : Stream'.Seq α),
Stream'.Seq.map f (s.append t) = (Stream'.Seq.map f s).append (Stream'.Seq.map f t) | true |
Real.tendsto_mul_log_one_add_of_tendsto | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {g : ℝ → ℝ} {t : ℝ},
Filter.Tendsto (fun x => x * g x) Filter.atTop (nhds t) →
Filter.Tendsto (fun x => x * Real.log (1 + g x)) Filter.atTop (nhds t) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.