name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Aesop.elabGlobalRuleIdent | Aesop.Builder.Basic | Aesop.BuilderName → Lean.Term → Lean.Elab.TermElabM Lean.Name | true |
Ordinal.partialOrder.match_15 | Mathlib.SetTheory.Ordinal.Basic | ∀ (x x_1 : WellOrder)
(motive :
⟦x⟧.liftOn₂ ⟦x_1⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ ∧
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ →
Prop)
(x_2 :
⟦x⟧.liftOn₂ ⟦x_1⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ ∧
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯),
(∀ (f : InitialSeg x.r x_1.r)
(h :
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_3 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_3 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯),
motive ⋯) →
motive x_2 | false |
pow_lt_pow_iff_right_of_lt_one₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀],
0 < a → a < 1 → (a ^ m < a ^ n ↔ n < m) | true |
_private.Mathlib.Data.Int.Init.0.Int.le_induction._proof_1_5 | Mathlib.Data.Int.Init | ∀ {m : ℤ} (k : ℤ), m + -1 * k + -1 ≤ 0 → m ≤ k + 1 | false |
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork | Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : CategoryTheory.Limits.MultispanShape} →
[inst_1 : Unique J.L] →
{I : CategoryTheory.Limits.MultispanIndex J C} →
{J.fst default, J.snd default} = Set.univ →
J.fst default ≠ J.snd default →
CategoryTheory.Limits.PushoutCocone (I.fst default) (I.snd default) → CategoryTheory.Limits.Multicofork I | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.caching | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | {α : Type u_1} → α → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkChainResult.go | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic →
Array (Array (Lean.TSyntax `tactic)) →
ℕ →
List (Lean.TSyntax `tactic) →
Option Lean.SyntaxNodeKind → StateT (Array (Lean.TSyntax `tactic)) Lean.Elab.Tactic.Try.TryTacticM Unit | true |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.logDeriv_eta_eq_E2._proof_1_8 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ (z : UpperHalfPlane),
2 * ↑Real.pi * Complex.I / 24 +
∑' (x : ℕ),
2 * ↑Real.pi * Complex.I *
(-((↑x + 1) * Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1)) /
(1 - Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1))) =
↑Real.pi * Complex.I / 12 * (6 / ↑Real.pi ^ 2 * 2⁻¹ * (2 * (↑Real.pi ^ 2 / 6))) +
∑' (x : ℕ),
-(↑Real.pi * Complex.I / 12 *
(6 / ↑Real.pi ^ 2 * 2⁻¹ *
(8 * ↑Real.pi ^ 2 *
((↑x + 1) * Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1) /
(1 - Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1)))))) | false |
CochainComplex.mappingCone.shiftTrianglehIso | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K L : CochainComplex C ℤ} →
(φ : K ⟶ L) →
(n : ℤ) →
(CategoryTheory.Pretriangulated.Triangle.shiftFunctor (HomotopyCategory C (ComplexShape.up ℤ)) n).obj
(CochainComplex.mappingCone.triangleh φ) ≅
CochainComplex.mappingCone.triangleh ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).map φ) | true |
CategoryTheory.Arrow.mapCechConerve._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout g.left (fun x => g.right) fun x => g.hom] (F : f ⟶ g)
(n : SimplexCategory) (i : Fin (n.len + 1)),
CategoryTheory.CategoryStruct.comp f.hom
((fun i => CategoryTheory.CategoryStruct.comp F.right (CategoryTheory.Limits.WidePushout.ι (fun x => g.hom) i))
i) =
CategoryTheory.CategoryStruct.comp F.left (CategoryTheory.Limits.WidePushout.head fun x => g.hom) | false |
NonUnitalNonAssocSemiring.directSumGNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ (ι : Type u_2) {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {i j : ι} (a b c : R), (a + b) * c = a * c + b * c | false |
Aesop.Index.mk.injEq | Aesop.Index | ∀ {α : Type} (byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed : Lean.PHashSet (Aesop.Rule α))
(byTarget_1 byHyp_1 : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed_1 : Lean.PHashSet (Aesop.Rule α)),
({ byTarget := byTarget, byHyp := byHyp, unindexed := unindexed } =
{ byTarget := byTarget_1, byHyp := byHyp_1, unindexed := unindexed_1 }) =
(byTarget = byTarget_1 ∧ byHyp = byHyp_1 ∧ unindexed = unindexed_1) | true |
Lean.Meta.Grind.GoalState.newRawFacts | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalState → Std.Queue Lean.Meta.Grind.NewRawFact | true |
HomotopicalAlgebra.Cylinder.instCofibrationI₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.Cylinder A)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A A] [inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C]
[inst_4 : CategoryTheory.Limits.HasInitial C] [(HomotopicalAlgebra.cofibrations C).IsStableUnderComposition]
[(HomotopicalAlgebra.cofibrations C).IsStableUnderCobaseChange] [HomotopicalAlgebra.IsCofibrant A] [P.IsGood],
HomotopicalAlgebra.Cofibration P.i₁ | true |
BoxIntegral.Box.lower_lt_upper._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_2} (self : BoxIntegral.Box ι) (i : ι), (self.lower i < self.upper i) = True | false |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_10 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
_private.Mathlib.CategoryTheory.Galois.Prorepresentability.0.CategoryTheory.PreGaloisCategory.PointedGaloisObject.instIsCofilteredOrEmpty.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (motive : CategoryTheory.PreGaloisCategory.PointedGaloisObject F → Prop)
(x : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(∀ (B : C) (b : (F.obj B).obj) (isGalois : CategoryTheory.PreGaloisCategory.IsGalois B),
motive { obj := B, pt := b, isGalois := isGalois }) →
motive x | false |
RecursiveIn.below.left | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)} {motive : (a : ℕ →. ℕ) → RecursiveIn O a → Prop}, RecursiveIn.below ⋯ | true |
Lean.Meta.UnificationHintEntry.mk.sizeOf_spec | Lean.Meta.UnificationHint | ∀ (keys : Array Lean.Meta.UnificationHintKey) (val : Lean.Name),
sizeOf { keys := keys, val := val } = 1 + sizeOf keys + sizeOf val | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff_ae_restrict'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {a b : Prop}, (a = b) = (a ↔ b) | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.next_reverse_eq_prev._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (hs : s.Nodup) (x : α) (hx : x ∈ s),
s.next hs x hx = s.reverse.prev ⋯ x ⋯ | false |
CategoryTheory.monoidalUnopUnop._proof_14 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᵒᵖᵒᵖ} (X' : Cᵒᵖᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' X)))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.unopUnop C).obj X')
((CategoryTheory.unopUnop C).map f)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.unopUnop C).map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' Y))) | false |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | @Orientation.definition✝ = @Orientation.definition✝ | false |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [a], x => h_2 a x
| a :: b :: xs, le => h_3 a b xs le) =
h_2 a x | true |
CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) | true |
TrivSqZeroExt.instL1NormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsBoundedSMul R M] [inst_5 : IsBoundedSMul Rᵐᵒᵖ M]
[inst_6 : SMulCommClass R Rᵐᵒᵖ M] {x y : TrivSqZeroExt R M}, dist x y = 0 → x = y | false |
_private.Init.Data.Array.Range.0.Array.mem_zipIdx._proof_1 | Init.Data.Array.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : Array α} {k : ℕ},
k ≤ (x, i).2 → (x, i).2 < k + xs.size → ¬i - k < xs.size → False | false |
HomogeneousIdeal.instMax._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (I.toIdeal ⊔ J.toIdeal) | false |
Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElim | Lean.Elab.GuardMsgs | {motive : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElimType ctorIdx → motive t | false |
SimpleGraph.induceHomOfLE | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → (G : SimpleGraph V) → {s s' : Set V} → s ≤ s' → SimpleGraph.induce s G ↪g SimpleGraph.induce s' G | true |
Monoid.CoprodI.Word.rcons_eq_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (p : Monoid.CoprodI.Word.Pair M i),
Monoid.CoprodI.Word.rcons p = Monoid.CoprodI.of p.head • p.tail | true |
AlgEquiv.isTranscendenceBasis | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
IsTranscendenceBasis R x → IsTranscendenceBasis R (⇑e ∘ x) | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.instIsIsoInvApp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (U : TopologicalSpace.Opens ↑↑X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp f U) | true |
Std.TreeMap.getKeyD_eq_fallback | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getKeyD a fallback = fallback | true |
BoxIntegral.Box.coe_subset_coe._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (↑I ⊆ ↑J) = (I ≤ J) | false |
OrderTopology.t5Space | Mathlib.Topology.Order.T5 | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X], T5Space X | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(X Y Z : P.FullSubcategory),
P
(CategoryTheory.MonoidalCategoryStruct.tensorObj X.obj
{ obj := CategoryTheory.MonoidalCategoryStruct.tensorObj Y.obj Z.obj, property := ⋯ }.obj) | false |
Std.DHashMap.Internal.Raw₀.contains_insertMany_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List ((a : α) × β a)} {k : α},
(↑(m.insertMany l)).contains k = (m.contains k || (List.map Sigma.fst l).contains k) | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerResultType.resultTypeForArity._sparseCasesOn_2 | Lean.Compiler.LCNF.ToImpure | {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.Lean.Server.Rpc.RequestHandling.0.Lean.Server.wrapRpcProcedure.match_1 | Lean.Server.Rpc.RequestHandling | (paramType : Type) →
(motive : Id (Except String paramType) → Sort u_1) →
(x : Id (Except String paramType)) →
((v : paramType) → motive (Except.ok v)) → ((e : String) → motive (Except.error e)) → motive x | false |
convexHullAddMonoidHom | Mathlib.Analysis.Convex.Combination | (R : Type u_1) →
(E : Type u_3) →
[inst : Field R] →
[inst_1 : AddCommGroup E] → [Module R E] → [inst_3 : LinearOrder R] → [IsStrictOrderedRing R] → Set E →+ Set E | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.instMulActionLeftTransversal._simp_1 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
instRingUniversalEnvelopingAlgebra._aux_8 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → ℕ → UniversalEnvelopingAlgebra R L → UniversalEnvelopingAlgebra R L | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.e | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → Lean.Expr | true |
HomotopicalAlgebra.instIsStableUnderBaseChangeFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C)],
(HomotopicalAlgebra.fibrations C).IsStableUnderBaseChange | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.getElem?_toList_eq.match_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (next : α), x = some next → motive (some next)) → motive x | false |
CategoryTheory.Idempotents.Karoubi.decompId_p._proof_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ }.p
(CategoryTheory.CategoryStruct.comp P.p P.p) =
P.p | false |
Std.DTreeMap.Internal.Impl.get!_eq_getValueCast! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [instBEq : BEq α] [inst : Ord α] [inst_1 : Std.LawfulBEqOrd α] [Std.TransOrd α]
[inst_3 : Std.LawfulEqOrd α] {k : α} [inst_4 : Inhabited (β k)] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get! k = Std.Internal.List.getValueCast! k t.toListModel | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sheafedSpace_pullback_fst_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (CategoryTheory.Limits.pullback.fst g f) | true |
CategoryTheory.FreeBicategory.comp_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g | true |
Pi.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) → {n : (i : I) → Zero (f i)} → [(i : I) → SMulZeroClass α (f i)] → SMulZeroClass α ((i : I) → f i) | true |
Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {hd : α} {tl : List α},
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity (hd :: tl)) =
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertIfNew hd ()) tl) | true |
Fin.partialProd_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_3} [inst : Monoid G] {n : ℕ} (g : Fin (n + 1) → G) (a : Fin (n + 1)),
Fin.partialProd (a.contractNth (fun x1 x2 => x1 * x2) g) = Fin.partialProd g ∘ a.succ.succAbove | true |
uniqueMDiffWithinAt_iff_uniqueDiffWithinAt | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E},
UniqueMDiffWithinAt (modelWithCornersSelf 𝕜 E) s x ↔ UniqueDiffWithinAt 𝕜 s x | true |
Topology.WithLawson.isOpen_preimage_ofLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] {S : Set α},
IsOpen (⇑Topology.WithLawson.ofLawson ⁻¹' S) ↔ TopologicalSpace.IsOpen S | true |
«term{}» | Init.Core | Lean.ParserDescr | true |
Lean.Meta.Match.mkAppDiscrEqs | Lean.Meta.Match.MatchEqs | Lean.Expr → Array Lean.Expr → ℕ → Lean.MetaM Lean.Expr | true |
Std.Packages.LinearPreorderOfLEArgs._proof_5 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (le : LE α), (∀ (a b : α), a ≤ b ∨ b ≤ a) → ∀ (a : α), a ≤ a | false |
_private.Lean.Compiler.LCNF.SplitSCC.0.Lean.Compiler.LCNF.SplitScc.findSccCalls.goCode.match_1 | Lean.Compiler.LCNF.SplitSCC | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(x : Lean.Compiler.LCNF.LetValue pu) →
((name : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.pure) Lean.Compiler.LCNF.LetValue._auto_3) →
motive (Lean.Compiler.LCNF.LetValue.const name us args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_13) →
motive (Lean.Compiler.LCNF.LetValue.fap name args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15) →
motive (Lean.Compiler.LCNF.LetValue.pap name args h)) →
((x : Lean.Compiler.LCNF.LetValue pu) → motive x) → motive x | false |
Polynomial.derivation_ext | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ | true |
WType.Listα.nil.elim | Mathlib.Data.W.Constructions | {γ : Type u} →
{motive : WType.Listα γ → Sort u_1} → (t : WType.Listα γ) → t.ctorIdx = 0 → motive WType.Listα.nil → motive t | false |
SSet.Truncated.Edge.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })} →
{motive : SSet.Truncated.Edge x₀ x₁ → Sort u_1} →
((edge : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.Edge._proof_2 })) →
(src_eq :
X.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op edge =
x₀) →
(tgt_eq :
X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op
edge =
x₁) →
motive { edge := edge, src_eq := src_eq, tgt_eq := tgt_eq }) →
(t : SSet.Truncated.Edge x₀ x₁) → motive t | false |
CategoryTheory.Classifier.hom_comp_hom | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (𝒞₁ 𝒞₂ 𝒞₃ : CategoryTheory.Classifier C),
CategoryTheory.CategoryStruct.comp (𝒞₁.hom 𝒞₂) (𝒞₂.hom 𝒞₃) = 𝒞₁.hom 𝒞₃ | true |
AbsoluteValue.LiesOver.casesOn | Mathlib.Analysis.Normed.Ring.WithAbs | {K : Type u_3} →
{L : Type u_4} →
{S : Type u_5} →
[inst : CommRing K] →
[inst_1 : IsSimpleRing K] →
[inst_2 : CommRing L] →
[inst_3 : Algebra K L] →
[inst_4 : PartialOrder S] →
[inst_5 : Nontrivial L] →
[inst_6 : Semiring S] →
{w : AbsoluteValue L S} →
{v : AbsoluteValue K S} →
{motive : w.LiesOver v → Sort u} →
(t : w.LiesOver v) → ((comp_eq : w.comp ⋯ = v) → motive ⋯) → motive t | false |
differentiableAt_const._simp_1 | 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] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | false |
AddSemigrp.hom_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y T : AddSemigrp} (f : X ⟶ Y) (g : Y ⟶ T),
AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddSemigrp.Hom.hom g).comp (AddSemigrp.Hom.hom f) | true |
UInt8.reduceBinPred._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Name → ℕ → (UInt8 → UInt8 → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step | false |
Matrix.IsDiag.submatrix | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {n : Type u_4} {m : Type u_5} [inst : Zero α] {A : Matrix n n α},
A.IsDiag → ∀ {f : m → n}, Function.Injective f → (A.submatrix f f).IsDiag | true |
PMF.toMeasure_inj._simp_1 | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {p q : PMF α},
(p.toMeasure = q.toMeasure) = (p = q) | false |
ProbabilityTheory.Kernel.rnDeriv_pos | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[ProbabilityTheory.IsFiniteKernel η] {a : α}, (κ a).AbsolutelyContinuous (η a) → ∀ᵐ (x : γ) ∂κ a, 0 < κ.rnDeriv η a x | true |
ProbabilityTheory.gaussianPDF | Mathlib.Probability.Distributions.Gaussian.Real | ℝ → NNReal → ℝ → ENNReal | true |
Pi.nonUnitalNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalNormedRing (R i)]
{x y : (i : ι) → R i}, dist x y = 0 → x = y | false |
Subgroup.commutator_eq_self | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [hH : Group.IsPerfect ↥H], ⁅H, H⁆ = H | true |
FirstOrder.Language.BoundedFormula.equal.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 1 →
({n : ℕ} → (t₁ t₂ : L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.equal t₁ t₂)) →
motive a t | false |
instAddInt64 | Init.Data.SInt.Basic | Add Int64 | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.findInt?.go | Lean.Meta.Tactic.Grind.Arith.Linear.Search | Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℤ → ℤ → Option ℚ | true |
EMetric.diam_one | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : One X], Metric.ediam 1 = 0 | true |
ProbabilityTheory.integrable_rpow_abs_of_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
0 ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => |X ω| ^ p) μ | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.solveSomeLocalFVarIdCnstr?.go._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Alt →
List (Lean.Expr × Lean.Expr) → Lean.MetaM (Option (Lean.FVarId × Lean.Expr) × List (Lean.Expr × Lean.Expr)) | false |
CategoryTheory.mop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).mop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.mop { unmop := X } | true |
Std.Internal.UV.Signal.cancel | Std.Internal.UV.Signal | Std.Internal.UV.Signal → IO Unit | true |
MvPolynomial.pderiv._proof_1 | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R], IsScalarTower R (MvPolynomial σ R) (MvPolynomial σ R) | false |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.evalTactic.match_9 | Lean.Elab.Tactic.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive ex | false |
List.zipWith_eq_nil_iff | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {l : List α} {l' : List β},
List.zipWith f l l' = [] ↔ l = [] ∨ l' = [] | true |
CategoryTheory.Limits.widePushoutShapeOp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type w) →
CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ | true |
Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.217797861._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO
(Lean.PersistentEnvExtension Lean.Name (Lean.Name × Lean.Linter.IgnoreFunction)
(List Lean.Name × Array Lean.Linter.IgnoreFunction)) | false |
PresheafOfModules.presheaf._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (X : Cᵒᵖ),
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.CategoryStruct.id X))) ⋯) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X)) | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.initializeState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.StructInstM✝ Unit | true |
CompletelyDistribLattice.MinimalAxioms.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(toCompleteLattice : CompleteLattice α) →
(∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice.MinimalAxioms α | true |
Lean.instForInMVarIdSetMVarIdOfMonad | Lean.Expr | {m : Type u_1 → Type u_2} → [Monad m] → ForIn m Lean.MVarIdSet Lean.MVarId | true |
_private.Mathlib.Order.Sublocale.0.Sublocale.giAux._proof_3 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : ↥S), x ≤ Sublocale.restrictAux✝ S ↑x | false |
CategoryTheory.Functor.map_braiding_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_6 : F.Braided] {Z : D}
(h : F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y X) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (β_ X Y).hom) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ F X Y)
(CategoryTheory.CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F Y X) h)) | true |
Lean.Parser.anyOfFn._unsafe_rec | Lean.Parser.Basic | List Lean.Parser.Parser → Lean.Parser.ParserFn | false |
Subring.range_snd | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S], (RingHom.snd R S).rangeS = ⊤ | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.loop | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array Lean.Expr →
List Lean.FVarId →
Lean.Expr →
ℕ → ℕ → List Lean.Meta.RefinedDiscrTree.StackEntry → Lean.MetaM (List Lean.Meta.RefinedDiscrTree.StackEntry) | true |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_filter_eq_false_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {f : α → β → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter f m)).isEmpty = false ↔
∃ k, ∃ (h : m.contains k = true), f (m.getKey k h) (Std.DHashMap.Internal.Raw₀.Const.get m k h) = true) | true |
Dyadic.toRat_le_toRat_iff._simp_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.toRat ≤ y.toRat) = (x ≤ y) | false |
MeasureTheory.Measure.pi_noAtoms | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (i : ι)
[MeasureTheory.NoAtoms (μ i)], MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ) | true |
InnerProductSpace.bounded_harmonic_on_complex_plane_is_constant | Mathlib.Analysis.Complex.Harmonic.Liouville | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f : ℂ → E),
InnerProductSpace.HarmonicOnNhd f Set.univ → Bornology.IsBounded (Set.range f) → ∀ (z w : ℂ), f z = f w | true |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | (B : Type u₁) →
[inst : CategoryTheory.Bicategory B] →
(C : Type u₂) → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.Bicategory (CategoryTheory.OplaxFunctor B C) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.