name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f_assoc | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C) {Z : C} (h : S.L₂.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp S.φ₁ (CategoryTheory.CategoryStruct.comp S.L₂.f h) =
CategoryTheory.CategoryStruct.comp S.φ₂ h | null | true |
HomotopyGroup.commGroup._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : Nontrivial N], ∃ y, y ≠ Classical.arbitrary N | null | false |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.getRel.match_1 | Batteries.Tactic.Trans | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((rel x : Lean.Expr) → motive (rel, x)) → motive __discr | null | false |
Lean.Meta.LazyDiscrTree.PartialMatch.score | Lean.Meta.LazyDiscrTree | Lean.Meta.LazyDiscrTree.PartialMatch → ℕ | null | true |
hasStrictDerivAt_exp_smul_const_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_3} [inst : NontriviallyNormedField 𝕂] [CharZero 𝕂] [inst_2 : NormedRing 𝔸]
[inst_3 : NormedAlgebra 𝕂 𝔸] [CompleteSpace 𝔸] (x : 𝔸) (t : 𝕂),
t • x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius →
HasStrictDerivAt (fun u => NormedSpace.exp (u • x)) (NormedSpace.exp (t ... | null | true |
CategoryTheory.Functor.ι_biproductComparison'_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {J : Type w₁}
(F : CategoryTheory.Functor C D) (f : J → C) [inst_4 : CategoryTheory.Limits.H... | null | true |
ContinuousAt.comp₂_of_eq | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : Y × Z → W} {g : X → Y} {h : X → Z} {x : X}
{y : Y × Z},
ContinuousAt f y → ContinuousAt g x → ContinuousAt h x → (g x, h x) = y → Con... | null | true |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalIte._proof_1 | Mathlib.Tactic.Positivity.Basic | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_b : Q(Preorder «$α»)), «$_b» =Q «$pα».toPreorder | null | false |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn._@.Lean.Parser.Tactic.Doc.1176478476._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | IO Unit | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_le_length_insertEntry._proof_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} {l : List ((a : α) × β a)}, ¬l.length ≤ l.length + 1 → False | null | false |
_private.Mathlib.Algebra.Lie.Basis.0.LieAlgebra.Basis.coroot_eq_h'.match_1_2 | Mathlib.Algebra.Lie.Basis | ∀ {ι : Type u_3} {K : Type u_2} {L : Type u_1} [inst : Fintype ι] [inst_1 : Field K] [inst_2 : LieRing L]
[inst_3 : LieAlgebra K L] (b : LieAlgebra.Basis ι K L) (motive : ↥b.cartan → Prop) (x : ↥b.cartan),
(∀ (z : L) (hz : z ∈ b.cartan), motive ⟨z, hz⟩) → motive x | null | false |
ContinuousENorm.toENorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → {inst : TopologicalSpace E} → [self : ContinuousENorm E] → ENorm E | null | true |
Submonoid.instCompleteLattice.eq_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M],
Submonoid.instCompleteLattice =
{ le := fun x1 x2 => x1 ≤ x2, lt := fun x1 x2 => x1 < x2, le_refl := ⋯, le_trans := ⋯, lt_iff_le_not_ge := ⋯,
le_antisymm := ⋯, sup := SemilatticeSup.sup, le_sup_left := ⋯, le_sup_right := ⋯, sup_le := ⋯,
inf := fun x1 x2 => x1 ⊓... | null | true |
String.rawStartPos_eq | Init.Data.String.Defs | ∀ {s : String}, s.rawStartPos = 0 | null | true |
IO.Error.mkInterrupted | Init.System.IOError | String → UInt32 → String → IO.Error | null | true |
TensorProduct.assoc._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R M (TensorProduct R N P)) | null | false |
CategoryTheory.monoidalCategoryMop._proof_9 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : Cᴹᵒᵖ}
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f.unmop
{ unmop := CategoryTheory.MonoidalCategoryStruct.tensorUnit C }.un... | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.le_weightedOrder_subst_of_forall_ne_zero._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i | null | false |
CategoryTheory.Endofunctor.algebraPreadditive._proof_24 | Mathlib.CategoryTheory.Preadditive.EndoFunctor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(F : CategoryTheory.Functor C C) [inst_2 : F.Additive] (A₁ A₂ : CategoryTheory.Endofunctor.Algebra F)
(x x_1 : A₁ ⟶ A₂), x + x_1 = x_1 + x | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.arg_mul_coe_angle._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) | null | false |
Lean.ReducibilityHints.isAbbrev | Lean.Declaration | Lean.ReducibilityHints → Bool | null | true |
CategoryTheory.congrArg_cast_hom_left | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y ⟶ Z),
cast ⋯ q = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) q | Reducible form of `congrArg_mpr_hom_left` | true |
Topology.IsInducing.mk | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] {f : X → Y},
tX = TopologicalSpace.induced f tY → Topology.IsInducing f | null | true |
CategoryTheory.compCreatesLimit._proof_1 | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_8}
[inst_1 : CategoryTheory.Category.{u_7, u_8} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{K : CategoryTheory.Functor J C} {E : Type u_6} [ℰ : CategoryTheory.Category.{u_4, u_6} E]
(F : CategoryTheory.Functor C D) (... | null | false |
SFinKer.instMonoidalCategory._proof_15 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y Z : SFinKer),
CategoryTheory.CategoryStruct.comp
{ hom := ProbabilityTheory.Kernel.deterministic ⇑MeasurableEquiv.prodAssoc.symm ⋯, property := ⋯ }
{ hom := ProbabilityTheory.Kernel.deterministic ⇑MeasurableEquiv.prodAssoc ⋯, property := ⋯ } =
CategoryTheory.CategoryStruct.id
{ carrier :=... | null | false |
AffineSubspace.direction_top | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], ⊤.direction = ⊤ | The direction of `⊤` is the whole module as a submodule. | true |
Filter.disjoint_pure_pure._simp_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {x y : α}, Disjoint (pure x) (pure y) = (x ≠ y) | null | false |
CategoryTheory.PreZeroHypercover.refineOneHypercover_p₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
[inst_1 : E.HasPullbacks]
(F : (i j : E.I₀) → CategoryTheory.PreZeroHypercover (CategoryTheory.Limits.pullback (E.f i) (E.f j))) (i j : E.I₀)
(k : (F i j).I₀),
(E.refineOneHypercover F).p₁ k =
CategoryT... | null | true |
NumberField.InfinitePlace.instMulActionAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K], RingHomClass Gal(K/k) K K | null | false |
WType.mk.injEq | Mathlib.Data.W.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (f : β a → WType β) (a_1 : α) (f_1 : β a_1 → WType β),
(WType.mk a f = WType.mk a_1 f_1) = (a = a_1 ∧ f ≍ f_1) | null | true |
CategoryTheory.Discrete.discreteCases | Mathlib.CategoryTheory.Discrete.Basic | Lean.Elab.Tactic.TacticM Unit | Use:
```
attribute [local aesop safe tactic (rule_sets := [CategoryTheory])]
CategoryTheory.Discrete.discreteCases
```
to locally give `cat_disch` the ability to call `cases` on
`Discrete` and `(_ : Discrete _) ⟶ (_ : Discrete _)` hypotheses.
| true |
CategoryTheory.TwoSquare | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | A `2`-square consists of a natural transformation `T ⋙ R ⟶ L ⋙ B`
involving fours functors `T`, `L`, `R`, `B` that are on the
top/left/right/bottom sides of a square of categories. | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.BaseChange.0.LinearIndependent.linearIndependent_algebraMap_comp_aux | Mathlib.LinearAlgebra.LinearIndependent.BaseChange | ∀ {ι : Type u_1} {ι' : Type u_2} [Finite ι'] {K : Type u_3} (L : Type u_4) [inst : Field K] [inst_1 : Field L]
[inst_2 : Algebra K L] {v : ι → ι' → K}, LinearIndependent K v → LinearIndependent L fun i => ⇑(algebraMap K L) ∘ v i | This is an auxiliary lemma dominated by `linearIndependent_algebraMap_comp_iff`. | true |
NormedSpace.inclusionInDoubleDualWeak | Mathlib.Analysis.Normed.Module.DoubleDual | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
(X : Type u_2) →
[inst_1 : SeminormedAddCommGroup X] → [inst_2 : NormedSpace 𝕜 X] → WeakSpace 𝕜 X →L[𝕜] WeakDual 𝕜 (StrongDual 𝕜 X) | The map from a normed space with the weak topology into the weak-star bidual, as a continuous
linear map. Built using `LinearEquiv.arrowCongr` to properly bundle the topology changes via
`toWeakSpace` and `StrongDual.toWeakDual`. | true |
Real.rpow_two | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), x ^ 2 = x ^ 2 | null | true |
CategoryTheory.ShortComplex.SnakeInput.exact_C₁_up._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.CategoryStruct.comp S.v₀₁.τ₁ S.v₁₂.τ₁ = 0 | null | false |
_private.Std.Data.HashMap.IteratorLemmas.0.Std.HashMap.Raw.keysIter.eq_1 | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} (m : Std.HashMap.Raw α β), m.keysIter = m.inner.keysIter | null | true |
mul_lt_mul_of_pos_right | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosStrictMono α],
b < c → 0 < a → b * a < c * a | null | true |
IsLocalFrameOn.mdifferentiableAt_of_coeff | Mathlib.Geometry.Manifold.VectorBundle.LocalFrame | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | Given a local frame `s i` on a neighbourhood `u` of `x`, if a section `t` has differentiable
coefficients at `x` w.r.t. `s i`, then `t` is differentiable at `x`. | true |
subset_interior_add_left | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : AddGroup α] [ContinuousConstVAdd αᵃᵒᵖ α] {s t : Set α},
interior s + t ⊆ interior (s + t) | null | true |
RingCon.dfinsuppSum | Mathlib.RingTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {β : ι → Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : Mul M]
[inst_3 : (i : ι) → Zero (β i)] [inst_4 : (i : ι) → (y : β i) → Decidable (y ≠ 0)] (c : RingCon M)
(h h' : (i : ι) → β i → M) {f g : Π₀ (i : ι), β i},
(∀ (i : ι), c (h i 0) 0) →
(∀ (i : ι), c ... | null | true |
Lean.Parser.Term.doIfCond.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | null | true |
MeasureTheory.SimpleFunc.range_const | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {β : Type u_2} (α : Type u_5) [inst : MeasurableSpace α] [Nonempty α] (b : β),
(MeasureTheory.SimpleFunc.const α b).range = {b} | null | true |
Lean.Quote.mk._flat_ctor | Init.Meta.Defs | {α : Type} → {k : optParam Lean.SyntaxNodeKind `term} → (α → Lean.TSyntax k) → Lean.Quote α k | null | false |
Units.cfcRpow._proof_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] (a : Aˣ) (x : ℝ), 0 ≤ ↑a → ↑a ^ (-x) * ↑a ^ x = 1 | null | false |
addMonoidAlgebraAlgEquivDirectSum._proof_4 | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_2} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : (m : A) → Decidable (m ≠ 0)] (x y : AddMonoidAlgebra A ι),
addMonoidAlgebraRingEquivDirectSum.toFun (x + y) =
addMonoidAlgebraRingEquivDirectSum.toFun x + addMonoidAlgebraRingEquivDirectSum.toFun y | null | false |
LinearOrderedCommGroupWithZero.zpow | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → ℤ → α → α | The power operation: `a ^ n = a * ··· * a`; `a ^ (-n) = a⁻¹ * ··· a⁻¹` (`n` times) | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_15 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) | null | false |
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.Lax | Lean.Syntax | null | false |
CompactlyGenerated.isoEquivHomeo_symm_apply | Mathlib.Topology.Category.CompactlyGenerated | ∀ {X Y : CompactlyGenerated} (f : ↑X.toTop ≃ₜ ↑Y.toTop),
CompactlyGenerated.isoEquivHomeo.symm f = CompactlyGenerated.isoOfHomeo f | null | true |
CategoryTheory.MonoidalCategoryStruct.whiskerRight | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
{X₁ X₂ : C} →
(X₁ ⟶ X₂) →
(Y : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ Y ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj X₂ Y | right whiskering for morphisms | true |
ContinuousMap.mk | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
(toFun : X → Y) → autoParam (Continuous toFun) ContinuousMap.continuous_toFun._autoParam → C(X, Y) | null | true |
OrderIso.Icc._proof_5 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] (e : α ≃o β) (x y : α) (y_1 : ↑(Set.Icc x y)),
(fun z => ⟨e.symm ↑z, ⋯⟩) ((fun z => ⟨e ↑z, ⋯⟩) y_1) = y_1 | null | false |
ContinuousLinearMap.hasDerivWithinAt_of_bilinear | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : 𝕜} {s : Set 𝕜} {B : E →L[𝕜] F →L[𝕜... | null | true |
OmegaCompletePartialOrder.ContinuousHom.ωSup._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_1} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c' : OmegaCompletePartialOrder.Chain α) (a : β),
(OmegaCompletePartialOrder.ωSup (c.map OmegaCompletePartialOrder.ContinuousHom.toMono)).toFun
(OmegaCo... | null | false |
MulEquiv.funUnique._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (α : Type u_2) (M : Type u_1) [inst : Mul M] [inst_1 : Unique α] (x y : α → M),
(Equiv.funUnique α M).toFun (x * y) = (Equiv.funUnique α M).toFun x * (Equiv.funUnique α M).toFun y | null | false |
Equiv.Perm.equivUnitsEnd._proof_6 | Mathlib.Algebra.Group.End | ∀ {α : Type u_1} (x x_1 : Equiv.Perm α), ⇑(Equiv.symm (x * x_1)) ∘ ⇑(x * x_1) = id | null | false |
CategoryTheory.Abelian.SpectralObject.mapFourδ₁Toδ₀'_mapFourδ₃Toδ₃' | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι' : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : Preorder ι'] (X' : CategoryTheory.Abelian.SpectralObject C ι') (i₀ i₁ i₂ i₃ i₄ i₅ : ι') (hi₀₁ : i₀ ≤ i₁)
(hi₁₂ : i₁ ≤ i₂) (hi₂₃ : i₂ ≤ i₃) (hi₃₄ : i₃ ≤ i₄) (hi₄₅ : i₄ ≤ i₅) (n₀ n₁ n₂ : ℤ)
(... | null | true |
_private.Mathlib.Data.Int.Bitwise.0.Int.shiftLeft_eq_mul_pow.match_1_1 | Mathlib.Data.Int.Bitwise | ∀ (motive : ℤ → ℕ → Prop) (x : ℤ) (x_1 : ℕ),
(∀ (m x : ℕ), motive (Int.ofNat m) x) → (∀ (a x : ℕ), motive (Int.negSucc a) x) → motive x x_1 | null | false |
HasFDerivAt.multiset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸']
{g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι] {u : Multiset ι} {x : E},
... | Unlike `HasFDerivAt.finsetProd`, supports duplicate elements.
| true |
Lean.Meta.Grind.Extension.addEMatchAttrAndSuggest | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.Extension →
Lean.Syntax →
Lean.Name →
Lean.AttributeKind → Lean.Meta.Grind.SymbolPriorities → Bool → Bool → optParam Bool false → Lean.MetaM Unit | Tries different modifiers, logs info messages with modifiers that worked, but stores just the first one that worked.
Remark: if `backward.grind.inferPattern` is `true`, then `.default false` is used.
The parameter `showInfo` is only taken into account when `backward.grind.inferPattern` is `true`.
| true |
_private.Mathlib.Algebra.Module.SpanRank.0.Submodule.spanRank_toENat_eq_iInf_finset_card._simp_1_1 | Mathlib.Algebra.Module.SpanRank | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iInf s = ⊤) = ∀ (i : ι), s i = ⊤ | null | false |
SimpleGraph.Copy.mapNeighborSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_2} {β : Type u_1} {A : SimpleGraph α} {B : SimpleGraph β} (f : A.Copy B) (a : α) (v : ↑(A.neighborSet a)),
f.toHom ↑v ∈ B.neighborSet (f.toHom a) | null | false |
instAddLeftCancelSemigroupPNat._proof_2 | Mathlib.Data.PNat.Basic | IsLeftCancelAdd ℕ+ | null | false |
IsReduced.mk | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R | null | true |
Std.ExtHashSet.size_diff_add_size_inter_eq_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size | null | true |
ArchimedeanOrder.instLE | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → [AddGroup M] → [Lattice M] → LE (ArchimedeanOrder M) | null | true |
Plausible.TestResult.ctorElim | Plausible.Testable | {p : Prop} →
{motive : Plausible.TestResult p → Sort u} →
(ctorIdx : ℕ) →
(t : Plausible.TestResult p) → ctorIdx = t.ctorIdx → Plausible.TestResult.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.ComposableArrows.sc'._auto_5 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | null | false |
Lean.Meta.StructProjDecl.projName | Lean.Meta.Structure | Lean.Meta.StructProjDecl → Lean.Name | null | true |
HomologicalComplex.evalCompCoyonedaCorepresentableBySingle._proof_3 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_3 : DecidableEq ι]
(hi : ∀ (j : ι), ¬c.Rel i j) (X : C) {K : HomologicalComplex C c}
(f : ((Homologi... | null | false |
WithBot.ofDual_lt_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] {x y : WithBot αᵒᵈ}, WithBot.ofDual x < WithBot.ofDual y ↔ y < x | null | true |
Ideal.connectedComponentOfZero._proof_2 | Mathlib.Topology.Algebra.Ring.Ideal | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (c x : R),
x ∈ (AddSubgroup.connectedComponentOfZero R).carrier → c • x ∈ connectedComponent 0 | null | false |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0.«_aux_Mathlib_RingTheory_Perfectoid_BDeRham___macroRules__private_Mathlib_RingTheory_Perfectoid_BDeRham_0_term𝔹_dR^+(_)_1» | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.Macro | null | false |
_private.Mathlib.MeasureTheory.Measure.OpenPos.0.IsMeagre.of_isSigmaCompact_null.match_1_1 | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} (K : ℕ → Set X) (t : Set X) (motive : t ∈ Set.range K → Prop) (x : t ∈ Set.range K),
(∀ (n : ℕ) (hn : K n = t), motive ⋯) → motive x | null | false |
Matrix.mulVecLin_reindex | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5}
[inst_1 : Fintype n] [inst_2 : Fintype l] (e₁ : k ≃ m) (e₂ : l ≃ n) (M : Matrix k l R),
((Matrix.reindex e₁ e₂) M).mulVecLin =
↑(LinearEquiv.funCongrLeft R R e₁.symm) ∘ₗ M.mulVecLin ∘ₗ ↑(LinearEquiv.funCongrLeft... | A variant of `Matrix.mulVecLin_submatrix` that keeps around `LinearEquiv`s. | true |
Matrix.det_isEmpty | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [IsEmpty n]
{A : Matrix n n R}, A.det = 1 | null | true |
Lean.JsonRpc.RequestID.num.inj | Lean.Data.JsonRpc | ∀ {n n_1 : Lean.JsonNumber}, Lean.JsonRpc.RequestID.num n = Lean.JsonRpc.RequestID.num n_1 → n = n_1 | null | true |
Vector.rec | Init.Data.Vector.Basic | {α : Type u} →
{n : ℕ} →
{motive : Vector α n → Sort u_1} →
((toArray : Array α) → (size_toArray : toArray.size = n) → motive (Vector.mk toArray size_toArray)) →
(t : Vector α n) → motive t | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat.0.SSet.Truncated.HomotopyCategory.subsingleton_hom._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (X : SSet.Truncated 2)
[inst : Unique (X.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 }))]
(a : SSet.OneTruncation₂ X), a = default | null | false |
Std.TreeMap.mem_of_mem_union_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ ∪ t₂ → k ∉ t₂ → k ∈ t₁ | null | true |
Ordinal.CNF.snd_lt | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {b o : Ordinal.{u}}, 1 < b → ∀ {x : Ordinal.{u} × Ordinal.{u}}, x ∈ Ordinal.CNF b o → x.2 < b | Every coefficient in the Cantor normal form `CNF b o` is less than `b`. | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α}, (f ≠ ⊥) = f.NeBot | null | false |
Std.Do.Spec.Iter.forIn_map | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → β₂} {init : γ} {g : β₂ → γ → ... | null | true |
Manifold.IsImmersionOfComplement.contMDiff | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} {F : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_7}
[inst_7 : Topolo... | A `C^n` immersion is `C^n`. | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.tdiv_one.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
_private.Lean.Meta.GeneralizeTelescope.0.Lean.Meta.GeneralizeTelescope.generalizeTelescopeAux.match_1 | Lean.Meta.GeneralizeTelescope | (motive : Lean.LocalDecl → Sort u_1) →
(localDecl : Lean.LocalDecl) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (Lean.LocalDecl.cdecl index fvarId u... | null | false |
Vector.mk_isPrefixOf_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs ys : Array α} (h : xs.size = n) (h' : ys.size = n),
(Vector.mk xs h).isPrefixOf (Vector.mk ys h') = xs.isPrefixOf ys | null | true |
TensorProduct.finsuppLeft_symm_apply_single | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] {ι : Type u_5} [inst_9 : Decidable... | null | true |
AddSubgroup.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddGroup M]
[inst_3 : AddAction M X] [ContinuousVAdd M X] {S : AddSubgroup M}, ContinuousVAdd (↥S) X | null | true |
RBTree.RBNode.Path.RootOrdered.eq_1 | BatteriesRecycling.RBTree.Alter | ∀ {α : Type u_1} (cmp : α → α → Ordering) (x : α), RBTree.RBNode.Path.RootOrdered cmp RBTree.RBNode.Path.root x = True | null | true |
CategoryTheory.SpectralSequence.Hom.mk.injEq | 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₀}
(hom : (r : ℤ) → (hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_1) → E.page r ⋯ ⟶ E'.page r ⋯)
(co... | null | true |
CategoryTheory.Limits.CompleteLattice.finiteColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u_2} {J : Type u_1} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeSup α] [inst_3 : OrderBot α] (F : CategoryTheory.Functor J α)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp
({ pt := Finset.univ.sup F.obj, ... | null | false |
Real.Angle.toReal_neg_iff_sign_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal < 0 ↔ θ.sign = -1 | null | true |
CategoryTheory.EnrichedCat.bicategory._proof_6 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b} (η : f ⟶ g),
CategoryTheory.EnrichedCat.whiskerLeft (CategoryTheory.EnrichedFunctor.id V ↑a) η =
CategoryTheory.Category... | null | false |
OpenSubgroup.hasCoeSubgroup.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
OpenSubgroup.hasCoeSubgroup = { coe := OpenSubgroup.toSubgroup } | null | true |
UniqueAdd.mt | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} [inst : Add G] {A B : Finset G} {a0 b0 : G},
UniqueAdd A B a0 b0 → ∀ ⦃a b : G⦄, a ∈ A → b ∈ B → a ≠ a0 ∨ b ≠ b0 → a + b ≠ a0 + b0 | null | true |
Array.extract.loop.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i j : ℕ) (bs : Array α),
Array.extract.loop as i j bs =
if hlt : j < as.size then
match i with
| 0 => bs
| i'.succ => Array.extract.loop as i' (j + 1) (bs.push (as.getInternal j hlt))
else bs | null | true |
NonUnitalRingHom.srange_eq_top_iff_surjective | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] {F : Type u_1} [inst_1 : FunLike F R S]
[inst_2 : NonUnitalNonAssocSemiring S] [inst_3 : NonUnitalRingHomClass F R S] {f : F},
NonUnitalRingHom.srange f = ⊤ ↔ Function.Surjective ⇑f | null | true |
Std.DHashMap.get?_insert_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, (m.insert k v).get? k = some v | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.