name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Internal.IO.Async.System.instInhabitedGroupId.default | Std.Internal.Async.System | Std.Internal.IO.Async.System.GroupId |
_private.Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup.0.Algebra.GrothendieckGroup.of_injective._simp_1_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (x : M), (Localization.monoidOf S) x = Localization.mk x 1 |
HomologicalComplex.restrictionMap_id | Mathlib.Algebra.Homology.Embedding.Restriction | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff],
HomologicalComplex.restrictionMap (CategoryTheory.CategoryStruct.id K) e =
CategoryTheory.CategoryStruct.id (K.restriction e) |
Lean.Meta.AbstractNestedProofs.isNonTrivialProof | Lean.Meta.AbstractNestedProofs | Lean.Expr → Lean.MetaM Bool |
strictConcaveOn_of_slope_strict_anti_adjacent | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
Convex 𝕜 s →
(∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)) →
StrictConcaveOn 𝕜 s f |
CategoryTheory.Pseudofunctor.DescentData.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
(obj : (i : ι) → ↑(F.obj { as := Opposite.op (X i) })) →
(hom :
⦃Y : C⦄ →
(q : Y ⟶ S) →
⦃i₁ i₂ : ι⦄ →
(f₁ : Y ⟶ X i₁) →
(f₂ : Y ⟶ X i₂) →
autoParam (CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
CategoryTheory.Pseudofunctor.DescentData._auto_1 →
autoParam (CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q)
CategoryTheory.Pseudofunctor.DescentData._auto_3 →
((F.map f₁.op.toLoc).toFunctor.obj (obj i₁) ⟶
(F.map f₂.op.toLoc).toFunctor.obj (obj i₂))) →
autoParam
(∀ ⦃Y' Y : C⦄ (g : Y' ⟶ Y) (q : Y ⟶ S) (q' : Y' ⟶ S)
(hq : CategoryTheory.CategoryStruct.comp g q = q') ⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂)
(hf₁ : CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
(hf₂ : CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q) (gf₁ : Y' ⟶ X i₁) (gf₂ : Y' ⟶ X i₂)
(hgf₁ : CategoryTheory.CategoryStruct.comp g f₁ = gf₁)
(hgf₂ : CategoryTheory.CategoryStruct.comp g f₂ = gf₂),
CategoryTheory.Pseudofunctor.LocallyDiscreteOpToCat.pullHom (hom q f₁ f₂ ⋯ ⋯) g gf₁ gf₂ ⋯ ⋯ =
hom q' gf₁ gf₂ ⋯ ⋯)
CategoryTheory.Pseudofunctor.DescentData.pullHom_hom._autoParam →
autoParam
(∀ ⦃Y : C⦄ (q : Y ⟶ S) ⦃i : ι⦄ (g : Y ⟶ X i)
(x : CategoryTheory.CategoryStruct.comp g (f i) = q),
hom q g g ⋯ ⋯ = CategoryTheory.CategoryStruct.id ((F.map g.op.toLoc).toFunctor.obj (obj i)))
CategoryTheory.Pseudofunctor.DescentData.hom_self._autoParam →
autoParam
(∀ ⦃Y : C⦄ (q : Y ⟶ S) ⦃i₁ i₂ i₃ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂) (f₃ : Y ⟶ X i₃)
(hf₁ : CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
(hf₂ : CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q)
(hf₃ : CategoryTheory.CategoryStruct.comp f₃ (f i₃) = q),
CategoryTheory.CategoryStruct.comp (hom q f₁ f₂ hf₁ hf₂) (hom q f₂ f₃ hf₂ hf₃) =
hom q f₁ f₃ hf₁ hf₃)
CategoryTheory.Pseudofunctor.DescentData.hom_comp._autoParam →
F.DescentData f |
ModularForm.sub_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f g : ModularForm Γ k) (z : UpperHalfPlane), (f - g) z = f z - g z |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_607 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w_1 [] [].length + 1 ≤ (List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length →
List.idxOfNth w_1 [] [].length < (List.findIdxs (fun x => decide (x = w)) [a, g a, g (g a)]).length |
_private.Lean.Meta.Offset.0.Lean.Meta.evalNat._sparseCasesOn_2 | Lean.Meta.Offset | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Lean.Meta.DiscrTree.Trie.ctorIdx | Lean.Meta.DiscrTree.Types | {α : Type} → Lean.Meta.DiscrTree.Trie α → ℕ |
_private.Mathlib.LinearAlgebra.QuadraticForm.Signature.0.QuadraticForm.posDef_spanSubset._simp_1_5 | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
UniformSpace.Completion.instAddMonoid._proof_12 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (n : ℕ)
(a : UniformSpace.Completion α), (n + 1) • a = n • a + a |
_private.Mathlib.Topology.Compactness.Lindelof.0.Tendsto.isLindelof_insert_range_of_coLindelof._simp_1_3 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty = ¬Disjoint s t |
IsLocalRing.ResidueField.map_id_apply | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] (x : IsLocalRing.ResidueField R),
(IsLocalRing.ResidueField.map (RingHom.id R)) x = x |
DomMulAct.instLeftCancelMonoidOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [LeftCancelMonoid Mᵐᵒᵖ] → LeftCancelMonoid Mᵈᵐᵃ |
Equiv.Perm.subtypeEquivSubtypePerm_apply_of_not_mem | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {p : α → Prop} [inst : DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)),
¬p a → ↑((Equiv.Perm.subtypeEquivSubtypePerm p) f) a = a |
Finsupp.sumFinsuppLEquivProdFinsupp_symm_inr | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_7}
{β : Type u_8} (fg : (α →₀ M) × (β →₀ M)) (y : β),
((Finsupp.sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y |
CategoryTheory.Equivalence.toAdjunction_unit | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.toAdjunction.unit = e.unit |
HomologicalComplex.xNextIso.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xNextIso r = CategoryTheory.eqToIso ⋯ |
NonUnitalSeminormedRing.noConfusion | Mathlib.Analysis.Normed.Ring.Basic | {P : Sort u} →
{α : Type u_5} →
{t : NonUnitalSeminormedRing α} →
{α' : Type u_5} →
{t' : NonUnitalSeminormedRing α'} → α = α' → t ≍ t' → NonUnitalSeminormedRing.noConfusionType P t t' |
Finset.sdiff_union_erase_cancel | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, t ⊆ s → a ∈ t → s \ t ∪ t.erase a = s.erase a |
GrpCat.SurjectiveOfEpiAuxs.h_apply_fromCoset_nin_range | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
∀ x ∈ (GrpCat.Hom.hom f).range,
∀ b ∉ (GrpCat.Hom.hom f).range,
((GrpCat.SurjectiveOfEpiAuxs.h f) x)
(GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨b • ↑(GrpCat.Hom.hom f).range, ⋯⟩) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨(x * b) • ↑(GrpCat.Hom.hom f).range, ⋯⟩ |
WittVector.toZModPow_compat | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (m n : ℕ) (h : m ≤ n),
(ZMod.castHom ⋯ (ZMod (p ^ m))).comp (WittVector.toZModPow p n) = WittVector.toZModPow p m |
AlgebraicGeometry.morphismRestrictRestrictBasicOpen._simp_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x |
Set.Intersecting.exists_mem_set | Mathlib.Combinatorics.SetFamily.Intersecting | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, 𝒜.Intersecting → ∀ {s t : Set α}, s ∈ 𝒜 → t ∈ 𝒜 → ∃ a ∈ s, a ∈ t |
_private.Mathlib.CategoryTheory.EssentiallySmall.0.CategoryTheory.essentiallySmall_iff_of_thin._simp_1_2 | Mathlib.CategoryTheory.EssentiallySmall | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [Quiver.IsThin C],
CategoryTheory.LocallySmall.{w, v, u} C = True |
CategoryTheory.HasLiftingProperty.transfiniteComposition.sqFunctor._proof_4 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X Y : C} (p : X ⟶ Y)
(f : F.obj ⊥ ⟶ X) (g : c.pt ⟶ Y) {X_1 Y_1 Z : Jᵒᵖ} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z),
(fun sq' => sq'.map (CategoryTheory.CategoryStruct.comp f_1 g_1).unop) =
CategoryTheory.CategoryStruct.comp (fun sq' => sq'.map f_1.unop) fun sq' => sq'.map g_1.unop |
Setoid.mk_eq_bot | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r : α → α → Prop} (iseqv : Equivalence r), { r := r, iseqv := iseqv } = ⊥ ↔ r = fun x1 x2 => x1 = x2 |
Real.sinhOrderIso_symm_apply | Mathlib.Analysis.SpecialFunctions.Arsinh | ⇑(RelIso.symm Real.sinhOrderIso) = Real.arsinh |
CategoryTheory.PreOneHypercover.Hom.mk | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(toHom : E.Hom F.toPreZeroHypercover) →
(s₁ : {i j : E.I₀} → E.I₁ i j → F.I₁ (toHom.s₀ i) (toHom.s₀ j)) →
(h₁ : {i j : E.I₀} → (k : E.I₁ i j) → E.Y k ⟶ F.Y (s₁ k)) →
autoParam
(∀ {i j : E.I₀} (k : E.I₁ i j),
CategoryTheory.CategoryStruct.comp (h₁ k) (F.p₁ (s₁ k)) =
CategoryTheory.CategoryStruct.comp (E.p₁ k) (toHom.h₀ i))
CategoryTheory.PreOneHypercover.Hom.w₁₁._autoParam →
autoParam
(∀ {i j : E.I₀} (k : E.I₁ i j),
CategoryTheory.CategoryStruct.comp (h₁ k) (F.p₂ (s₁ k)) =
CategoryTheory.CategoryStruct.comp (E.p₂ k) (toHom.h₀ j))
CategoryTheory.PreOneHypercover.Hom.w₁₂._autoParam →
E.Hom F |
_private.Init.Data.List.Sublist.0.List.infix_filterMap_iff._simp_1_3 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {L₁ L₂ : List β} {f : α → Option β},
(List.filterMap f l = L₁ ++ L₂) = ∃ l₁ l₂, l = l₁ ++ l₂ ∧ List.filterMap f l₁ = L₁ ∧ List.filterMap f l₂ = L₂ |
CategoryTheory.Limits.Multicoequalizer.instHasCoequalizerFstSigmaMapSndSigmaMap | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.left] [inst_3 : CategoryTheory.Limits.HasCoproduct I.right],
CategoryTheory.Limits.HasCoequalizer I.fstSigmaMap I.sndSigmaMap |
_private.Mathlib.Algebra.Ring.Idempotent.0.IsIdempotentElem.sub_iff._simp_1_5 | Mathlib.Algebra.Ring.Idempotent | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
FreeMonoid.prodAux.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {M : Type u_6} [inst : Monoid M], FreeMonoid.prodAux [] = 1 |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Simp.Types | ∀ (config : Lean.Meta.Simp.Config) (zetaDeltaSet initUsedZetaDelta : Lean.FVarIdSet)
(metaConfig indexConfig : Lean.Meta.ConfigWithKey) (maxDischargeDepth : UInt32)
(simpTheorems : Lean.Meta.SimpTheoremsArray) (congrTheorems : Lean.Meta.SimpCongrTheorems)
(parent? : Option Lean.Expr) (dischargeDepth : UInt32) (lctxInitIndices : ℕ) (inDSimp : Bool),
sizeOf
{ config := config, zetaDeltaSet := zetaDeltaSet, initUsedZetaDelta := initUsedZetaDelta,
metaConfig := metaConfig, indexConfig := indexConfig, maxDischargeDepth := maxDischargeDepth,
simpTheorems := simpTheorems, congrTheorems := congrTheorems, parent? := parent?,
dischargeDepth := dischargeDepth, lctxInitIndices := lctxInitIndices, inDSimp := inDSimp } =
1 + sizeOf config + sizeOf zetaDeltaSet + sizeOf initUsedZetaDelta + sizeOf metaConfig + sizeOf indexConfig +
sizeOf maxDischargeDepth +
sizeOf simpTheorems +
sizeOf congrTheorems +
sizeOf parent? +
sizeOf dischargeDepth +
sizeOf lctxInitIndices +
sizeOf inDSimp |
borel_eq_generateFrom_Ioi | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ (α : Type u_1) [inst : TopologicalSpace α] [SecondCountableTopology α] [inst_2 : LinearOrder α] [OrderTopology α],
borel α = MeasurableSpace.generateFrom (Set.range Set.Ioi) |
CommAlgCat.binaryCofanIsColimit._proof_1 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (A B : CommAlgCat R) {T : CommAlgCat R} (f : A ⟶ T) (g : B ⟶ T),
CategoryTheory.CategoryStruct.comp (A.binaryCofan B).inl
((fun {T} f g => CommAlgCat.ofHom (Algebra.TensorProduct.lift (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) ⋯)) f
g) =
f |
Matrix.cramer | Mathlib.LinearAlgebra.Matrix.Adjugate | {n : Type v} → {α : Type w} → [DecidableEq n] → [Fintype n] → [inst : CommRing α] → Matrix n n α → (n → α) →ₗ[α] n → α |
WeierstrassCurve.Jacobian.add_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P Q : Fin 3 → F},
W.Nonsingular P → W.Nonsingular Q → P 2 = 0 → Q 2 = 0 → W.add P Q = P 0 ^ 2 • ![1, 1, 0] |
_private.Mathlib.Order.SupIndep.0.Finset.SupIndep.biUnion._proof_1_1 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq ι]
{s : Finset ι'} {g : ι' → Finset ι} {f : ι → α} ⦃a : Finset ι⦄,
a ⊆ s.biUnion g →
∀ ⦃b : ι⦄, b ∈ s.biUnion g → b ∉ a → ∀ (i' : ι'), a.sup f ≤ ((s.erase i').biUnion g ∪ (g i').erase b).sup f |
_private.Lean.Data.Json.FromToJson.Basic.0.Float.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : String ⊕ Lean.JsonNumber → Sort u_1) →
(x : String ⊕ Lean.JsonNumber) →
((e : String) → motive (Sum.inl e)) → ((n : Lean.JsonNumber) → motive (Sum.inr n)) → motive x |
IsAddUnit.eq_add_neg_iff_add_eq | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : SubtractionMonoid α] {a b c : α}, IsAddUnit c → (a = b + -c ↔ a + c = b) |
Batteries.RBNode.upperBound?_of_some | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cut : α → Ordering} {y : α} {t : Batteries.RBNode α},
∃ x, Batteries.RBNode.upperBound? cut t (some y) = some x |
CompleteSemilatticeSup.toPartialOrder | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} → [self : CompleteSemilatticeSup α] → PartialOrder α |
HasSum.congr_fun | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α} {a : α}
{L : SummationFilter β}, HasSum f a L → (∀ (x : β), g x = f x) → HasSum g a L |
Continuous.matrix_diagonal | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
[inst_2 : Zero R] [inst_3 : DecidableEq n] {A : X → n → R}, Continuous A → Continuous fun x => Matrix.diagonal (A x) |
Option.some_eq_dite_none_left._simp_1 | Init.Data.Option.Lemmas | ∀ {β : Type u_1} {a : β} {p : Prop} {x : Decidable p} {b : ¬p → Option β},
(some a = if h : p then none else b h) = ∃ (h : ¬p), some a = b h |
Bundle.Pretrivialization.symm_trans_symm | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e e' : Bundle.Pretrivialization F proj), (e.symm.trans e'.toPartialEquiv).symm = e'.symm.trans e.toPartialEquiv |
Aesop.GoalUnsafe.brecOn_5 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
{motive_6 : Aesop.RappData Aesop.GoalUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_7 : Array (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_8 : Option (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_9 : Array (IO.Ref Aesop.GoalUnsafe) → Sort u} →
{motive_10 : Array (IO.Ref Aesop.MVarClusterUnsafe) → Sort u} →
{motive_11 : List (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_12 : List (IO.Ref Aesop.GoalUnsafe) → Sort u} →
{motive_13 : List (IO.Ref Aesop.MVarClusterUnsafe) → Sort u} →
(t : Option (IO.Ref Aesop.RappUnsafe)) →
((t : Aesop.GoalUnsafe) → t.below → motive_1 t) →
((t : Aesop.MVarClusterUnsafe) → t.below → motive_2 t) →
((t : Aesop.RappUnsafe) → t.below → motive_3 t) →
((t : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe) →
Aesop.GoalUnsafe.below_1 t → motive_4 t) →
((t : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe) →
Aesop.GoalUnsafe.below_2 t → motive_5 t) →
((t : Aesop.RappData Aesop.GoalUnsafe Aesop.MVarClusterUnsafe) →
Aesop.GoalUnsafe.below_3 t → motive_6 t) →
((t : Array (IO.Ref Aesop.RappUnsafe)) →
Aesop.GoalUnsafe.below_4 t → motive_7 t) →
((t : Option (IO.Ref Aesop.RappUnsafe)) →
Aesop.GoalUnsafe.below_5 t → motive_8 t) →
((t : Array (IO.Ref Aesop.GoalUnsafe)) →
Aesop.GoalUnsafe.below_6 t → motive_9 t) →
((t : Array (IO.Ref Aesop.MVarClusterUnsafe)) →
Aesop.GoalUnsafe.below_7 t → motive_10 t) →
((t : List (IO.Ref Aesop.RappUnsafe)) →
Aesop.GoalUnsafe.below_8 t → motive_11 t) →
((t : List (IO.Ref Aesop.GoalUnsafe)) →
Aesop.GoalUnsafe.below_9 t → motive_12 t) →
((t : List (IO.Ref Aesop.MVarClusterUnsafe)) →
Aesop.GoalUnsafe.below_10 t → motive_13 t) →
motive_8 t |
CategoryTheory.IsPullback.hasLiftingProperty | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y Z W : C} {f : X ⟶ Y} {s : X ⟶ Z} {g : Z ⟶ W}
{t : Y ⟶ W},
CategoryTheory.IsPullback s f g t →
∀ {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.HasLiftingProperty f' g], CategoryTheory.HasLiftingProperty f' f |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.mem_rootsOfUnity._simp_1_3 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
Fin.image_addNat_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), (fun x => x.addNat m) '' Set.Ioc i j = Set.Ioc (i.addNat m) (j.addNat m) |
List.findM?_pure | Init.Data.List.Control | ∀ {α : Type} {m : Type → Type u_1} [inst : Monad m] [LawfulMonad m] (p : α → Bool) (as : List α),
List.findM? (fun x => pure (p x)) as = pure (List.find? p as) |
CommRingCat.hom_inv_apply | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommRingCat} (e : R ≅ S) (s : ↑S),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun'.eq_def | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_2) {α : Type u_5} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (b x : α),
IncidenceAlgebra.muFun'✝ 𝕜 b x =
let a := x;
if a = b then 1
else
-∑ x_1 ∈ (Finset.Ioc a b).attach,
have h := ⋯;
have this := ⋯;
IncidenceAlgebra.muFun'✝¹ 𝕜 b ↑x_1 |
CategoryTheory.Bicategory.leftUnitorNatIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
(a b : B) →
(CategoryTheory.Bicategory.precomposing a a b).obj (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.Functor.id (a ⟶ b) |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi._simp_1_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True |
UniformSpace.mem_ball_comp | Mathlib.Topology.UniformSpace.Defs | ∀ {β : Type ub} {V W : Set (β × β)} {x y z : β},
y ∈ UniformSpace.ball x V → z ∈ UniformSpace.ball y W → z ∈ UniformSpace.ball x (SetRel.comp V W) |
Qq.Impl.PatternVar.ctorIdx | Qq.Match | Qq.Impl.PatternVar → ℕ |
Std.ExtHashMap.getD_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → γ} {k : α} {fallback : γ},
(Std.ExtHashMap.map f m).getD k fallback = (Option.map (f k) m[k]?).getD fallback |
Lean.Diff.instToStringAction.match_1 | Lean.Util.Diff | (motive : Lean.Diff.Action → Sort u_1) →
(x : Lean.Diff.Action) →
(Unit → motive Lean.Diff.Action.insert) →
(Unit → motive Lean.Diff.Action.delete) → (Unit → motive Lean.Diff.Action.skip) → motive x |
EReal.toReal | Mathlib.Data.EReal.Basic | EReal → ℝ |
Lean.Sym.Char.eq_eq_false | Init.Sym.Lemmas | ∀ (a b : Char), decide (a = b) = false → (a = b) = False |
ZNum.mod_to_int | Mathlib.Data.Num.ZNum | ∀ (n d : ZNum), ↑(n % d) = ↑n % ↑d |
Std.Internal.UV.Loop.Options.mk.noConfusion | Std.Internal.UV.Loop | {P : Sort u} →
{accumulateIdleTime blockSigProfSignal accumulateIdleTime' blockSigProfSignal' : Bool} →
{ accumulateIdleTime := accumulateIdleTime, blockSigProfSignal := blockSigProfSignal } =
{ accumulateIdleTime := accumulateIdleTime', blockSigProfSignal := blockSigProfSignal' } →
(accumulateIdleTime = accumulateIdleTime' → blockSigProfSignal = blockSigProfSignal' → P) → P |
Matrix.vecMulLinear_transpose | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] (M : Matrix m n R),
M.transpose.vecMulLinear = M.mulVecLin |
Std.Tactic.BVDecide.Reflect.BitVec.add_congr | Std.Tactic.BVDecide.Reflect | ∀ (w : ℕ) (lhs rhs lhs' rhs' : BitVec w), lhs' = lhs → rhs' = rhs → lhs' + rhs' = lhs + rhs |
SheafOfModules.pushforwardSections_coe | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackFree | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
[inst_2 : F.IsContinuous J K] (φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R) [inst_3 : F.IsContinuous J K]
{M : SheafOfModules R} (s : M.sections) (x : Cᵒᵖ), ↑(SheafOfModules.pushforwardSections φ s) x = ↑s (F.op.obj x) |
SignType.instBoundedOrder | Mathlib.Data.Sign.Defs | BoundedOrder SignType |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.glueDist_swap.match_1_1 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} (motive : X ⊕ Y → X ⊕ Y → Prop) (x x_1 : X ⊕ Y),
(∀ (val val_1 : X), motive (Sum.inl val) (Sum.inl val_1)) →
(∀ (val val_1 : Y), motive (Sum.inr val) (Sum.inr val_1)) →
(∀ (val : X) (val_1 : Y), motive (Sum.inl val) (Sum.inr val_1)) →
(∀ (val : Y) (val_1 : X), motive (Sum.inr val) (Sum.inl val_1)) → motive x x_1 |
UniqueAdd.addHom_preimage | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] (f : G →ₙ+ H) (hf : Function.Injective ⇑f) (a0 b0 : G)
{A B : Finset H}, UniqueAdd A B (f a0) (f b0) → UniqueAdd (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0 |
Set.Nonempty.of_vadd_right | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set α} {t : Set β}, (s +ᵥ t).Nonempty → t.Nonempty |
Prod.normedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedRing α] [inst_1 : NormedRing β] (a b c : α × β),
(a + b) * c = a * c + b * c |
Polynomial.coeff_eq_zero_of_lt_trailingDegree | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, ↑n < p.trailingDegree → p.coeff n = 0 |
ProofWidgets.Penrose.DiagramProps.maxOptSteps | ProofWidgets.Component.PenroseDiagram | ProofWidgets.Penrose.DiagramProps → ℕ |
IsSimpleOrder.instFinite | Mathlib.Order.Atoms.Finite | ∀ {α : Type u_1} [inst : LE α] [inst_1 : BoundedOrder α] [IsSimpleOrder α], Finite α |
CompactlySupportedContinuousMap.mk.sizeOf_spec | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_5} {β : Type u_6} [inst : TopologicalSpace α] [inst_1 : Zero β] [inst_2 : TopologicalSpace β]
[inst_3 : SizeOf α] [inst_4 : SizeOf β] (toContinuousMap : C(α, β))
(hasCompactSupport' : HasCompactSupport toContinuousMap.toFun),
sizeOf { toContinuousMap := toContinuousMap, hasCompactSupport' := hasCompactSupport' } = 1 + sizeOf toContinuousMap |
CochainComplex.HomComplex.leftHomologyData'._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p)
(s :
CategoryTheory.Limits.Cofork
((CochainComplex.HomComplex.Cocycle.isKernel K L m p hp).lift
(CategoryTheory.Limits.KernelFork.ofι (HomologicalComplex.sc' (K.HomComplex L) n m p).f ⋯))
0),
CochainComplex.HomComplex.coboundaries K L m ≤ (AddCommGrpCat.Hom.hom s.π).ker |
Std.Slice.Internal.SubarrayData.mk._flat_ctor | Init.Data.Array.Subarray | {α : Type u} →
(array : Array α) → (start stop : ℕ) → start ≤ stop → stop ≤ array.size → Std.Slice.Internal.SubarrayData α |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_7 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ |
_private.Mathlib.Data.Set.Insert.0.Set.ssubset_insert._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → s ⊂ insert a s |
hasFDerivAt_comp_add_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (a : E), HasFDerivAt (fun x => f (x + a)) f' x ↔ HasFDerivAt f f' (x + a) |
Nat.clog_zero_right | Mathlib.Data.Nat.Log | ∀ (b : ℕ), Nat.clog b 0 = 0 |
CategoryTheory.nerve.σ₀_mk₀_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve C) 0 (CategoryTheory.ComposableArrows.mk₀ x) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategoryStruct.id x) |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Reachable.dist_triangle_right._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V},
G.Reachable v w → ∀ (u : V), G.Reachable u w → ↑(G.dist u w) ≤ ↑(G.dist u v) + ↑(G.dist v w) |
instDecidableIff._proof_2 | Init.Core | ∀ {p q : Prop}, p → ¬q → (p ↔ q) → False |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.compProd_eq_zero_iff._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ = 0) = (μ Set.univ = 0) |
fixingSubgroup_union | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α] {s t : Set α},
fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.forall_uIoc_iff._simp_1_2 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i j : ℕ), i + k = j → ¬i ≤ j → False |
Std.Tactic.BVDecide.BVExpr.decEq._proof_129 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 start : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1), ¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.extract start w expr |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_24 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (j k : ℕ),
j < k → k + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → j < tail.length |
LinearMap.finrank_maxGenEigenspace_eq | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K),
Module.finrank K ↥(φ.maxGenEigenspace μ) = Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) |
MvPolynomial.universalFactorizationMapPresentation_val | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k) (a : Fin m ⊕ Fin k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).val a =
Sum.elim (fun x => MvPolynomial.X x ⊗ₜ[R] 1) (fun x => 1 ⊗ₜ[R] MvPolynomial.X x) a |
AlgebraicGeometry.isLocallyNoetherian_iff_of_affine_openCover | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)],
AlgebraicGeometry.IsLocallyNoetherian X ↔ ∀ (i : 𝒰.I₀), IsNoetherianRing ↑((𝒰.X i).presheaf.obj (Opposite.op ⊤)) |
Convex.mul_sub_lt_image_sub_of_lt_deriv | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {D : Set ℝ},
Convex ℝ D →
∀ {f : ℝ → ℝ},
ContinuousOn f D →
DifferentiableOn ℝ f (interior D) →
∀ {C : ℝ}, (∀ x ∈ interior D, C < deriv f x) → ∀ x ∈ D, ∀ y ∈ D, x < y → C * (y - x) < f y - f x |
CategoryTheory.Functor.ι_leftKanExtensionObjIsoColimit_hom_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : CategoryTheory.CostructuredArrow L X) {Z : H}
(h : CategoryTheory.Limits.colimit ((CategoryTheory.CostructuredArrow.proj L X).comp F) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((L.leftKanExtensionUnit F).app f.left)
(CategoryTheory.CategoryStruct.comp ((L.leftKanExtension F).map f.hom)
(CategoryTheory.CategoryStruct.comp (L.leftKanExtensionObjIsoColimit F X).hom h)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L X).comp F) f) h |
Std.DTreeMap.Internal.RciSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rci α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range |
imp_iff_not_or | Mathlib.Logic.Basic | ∀ {a b : Prop}, a → b ↔ ¬a ∨ b |
IsTopologicalGroup.leftUniformSpace | Mathlib.Topology.Algebra.IsUniformGroup.Defs | (G : Type u_1) → [inst : Group G] → [inst_1 : TopologicalSpace G] → [IsTopologicalGroup G] → UniformSpace G |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.