name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.StrictlyUnitaryPseudofunctor.casesOn | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.StrictlyUnitaryPseudofunctor B C → Sort u} →
(t : CategoryTheory.StrictlyUnitaryPseudofunctor B C) →
((toPseudofunctor : CategoryTheory.Pseud... | null | false |
Std.DHashMap.Internal.Raw₀.Const.insertMany_list_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
(↑m₁).Equiv ↑m₂ →
∀ {l : List (α × β)},
(↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m₁ l)).Equiv
↑↑(St... | null | true |
SetLike.gsemiring._proof_7 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : AddMonoid ι] [inst_1 : Semiring R] [inst_2 : SetLike σ R]
[AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedMonoid A] (n : ℕ), ↑n ∈ A 0 | null | false |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.insertAux.match_1 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.CollisionNode α β → Sort u_3) →
(newNode : Lean.PersistentHashMap.CollisionNode α β) →
((es : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
(h : Lean.PersistentHashMap.IsCollisionNode (Lean... | null | false |
Height.logHeight₁_div_eq_logHeight | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x y : K),
Height.logHeight₁ (x / y) = Height.logHeight ![x, y] | null | true |
Mathlib.Meta.NormNum.IsNat.nnreal_rpow_eq_nnreal_pow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {b : ℝ} {n : ℕ}, Mathlib.Meta.NormNum.IsNat b n → ∀ (a : NNReal), a ^ b = a ^ n | null | true |
Lean.LOption.casesOn | Lean.Data.LOption | {α : Type u} →
{motive : Lean.LOption α → Sort u_1} →
(t : Lean.LOption α) →
motive Lean.LOption.none → ((a : α) → motive (Lean.LOption.some a)) → motive Lean.LOption.undef → motive t | null | false |
_private.Mathlib.CategoryTheory.Sites.IsSheafFor.0.CategoryTheory.Presieve.isSheafFor_bind._proof_1_11 | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type u_1))
(U : CategoryTheory.Sieve X) (B : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → U.arrows f → CategoryTheory.Sieve Y)
(hB : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄ (hf : U.arrows f), CategoryTheory.Presieve.IsSheafFor P (B hf).arrows)
(s : ... | null | false |
SuccAddOrder.noConfusionType | Mathlib.Algebra.Order.SuccPred | Sort u →
{α : Type u_1} →
[inst : Preorder α] →
[inst_1 : Add α] →
[inst_2 : One α] →
SuccAddOrder α →
{α' : Type u_1} → [inst' : Preorder α'] → [inst'_1 : Add α'] → [inst'_2 : One α'] → SuccAddOrder α' → Sort u | null | false |
CategoryTheory.Mon.trivial_mon_mul | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.MonObj.mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.set_option._regBuiltin.Lean.Parser.Command.set_option_1 | Lean.Parser.Command | IO Unit | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitTraceNodesM.go.match_1 | Mathlib.Tactic.DefEqAbuse | {α : Type} →
(motive : Lean.MessageData.VisitStep✝ α → Sort u_1) →
(__do_lift : Lean.MessageData.VisitStep✝ α) →
((a? : Option α) → motive (Lean.MessageData.VisitStep.descend✝ a?)) →
((a? : Option α) → motive (Lean.MessageData.VisitStep.ascend✝ a?)) → motive __do_lift | null | false |
_private.Mathlib.Data.Finset.Disjoint.0.Finset.disjoint_singleton_left._simp_1_3 | Mathlib.Data.Finset.Disjoint | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
Metric.Snowflaking.uniformContinuous_toSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : UniformSpace X],
UniformContinuous ⇑Metric.Snowflaking.toSnowflaking | null | true |
Algebra.FiniteType.mk._flat_ctor | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⊤.FG → Algebra.FiniteType R A | null | false |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence.0.Mathlib.Tactic.Bicategory._aux_Mathlib_Tactic_CategoryTheory_Bicategory_PureCoherence___unexpand_CategoryTheory_Bicategory_whiskerLeftIso_1 | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | Lean.PrettyPrinter.Unexpander | null | false |
AddSubgroup.isOpen_of_mem_nhds | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [SeparatelyContinuousAdd G] (H : AddSubgroup G)
{g : G}, ↑H ∈ nhds g → IsOpen ↑H | null | true |
fderivWithin_comp_derivWithin | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : 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] {f : 𝕜 → F} (x : 𝕜)
{s : Set 𝕜} {l : F → E} {t : Set F},
DifferentiableWithinAt 𝕜 l t (f x) →
Differentiable... | null | true |
LinearMap.BilinForm.ker_restrict_eq_of_codisjoint | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M},
Codisjoint p q →
∀ {B : LinearMap.BilinForm R M},
(∀ x ∈ p, ∀ y ∈ q, (B x) y = 0) → LinearMap.ker (B.restrict p) = Submodule.comap p.subtype (LinearMap.ker B) | null | true |
Std.HashMap.Raw.size_alter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option β → Option β}, m.WF → (m.alter k f).size ≤ m.size + 1 | null | true |
contDiff_norm_sq | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {n : WithTop ℕ∞}, ContDiff ℝ n fun x => ‖x‖ ^ 2 | null | true |
PiTensorProduct.dualDistribInvOfBasis._proof_3 | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_2} {R : Type u_1} {M : ι → Type u_3} [inst : CommRing R] [inst_1 : (i : ι) → AddCommGroup (M i)]
[inst_2 : (i : ι) → Module R (M i)], SMulCommClass R ℕ (PiTensorProduct R fun i => Module.Dual R (M i)) | null | false |
RKHS.equiv_kerFun | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] {H : Type u_4} [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] {H' : Type u_5}
[inst... | null | true |
CategoryTheory.Mat.equivalenceSingleObjInverse._proof_1 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (R : Type) [inst : Ring R] (X : CategoryTheory.Mat_ (CategoryTheory.SingleObj Rᵐᵒᵖ)),
(fun i j => MulOpposite.unop (CategoryTheory.CategoryStruct.id X i j)) = CategoryTheory.CategoryStruct.id ↧X.ι | null | false |
FreeAddGroup.toWord_of_zsmul | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (n : ℤ),
(n • FreeAddGroup.of a).toWord = List.replicate n.natAbs (a, decide (0 ≤ n)) | null | true |
Std.DTreeMap.Internal.RocSlice | Std.Data.DTreeMap.Internal.Zipper | (α : Type u_1) → (α → Type u_2) → [Ord α] → Type (max u_2 u_1) | null | true |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.tryThisProvider | Lean.Meta.Tactic.TryThis | Lean.Server.CodeActionProvider | This is a code action provider that looks for `TryThisInfo` nodes and supplies a code action to
apply the replacement.
| true |
Lean.Linter.UnusedVariables.References.recOn | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.References → Sort u} →
(t : Lean.Linter.UnusedVariables.References) →
((constDecls : Std.HashSet Lean.Syntax.Range) →
(fvarDefs : Std.HashMap Lean.Syntax.Range Lean.Linter.UnusedVariables.FVarDefinition) →
(fvarUses : Std.HashSet Lean.FVarId) →
(... | null | false |
CategoryTheory.CardinalFilteredPoset.isCardinalPresentable_iff | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ {κ : Cardinal.{u}} [inst : Fact κ.IsRegular] (J : CategoryTheory.CardinalDirectedPoset κ) {κ' : Cardinal.{u}}
[inst_1 : Fact κ'.IsRegular], κ ≤ κ' → (CategoryTheory.IsCardinalPresentable J κ' ↔ HasCardinalLT (↑J.obj) κ') | **Alias** of `CategoryTheory.CardinalDirectedPoset.isCardinalPresentable_iff`. | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.collectStructFields._unsafe_rec | Lean.PrettyPrinter.Delaborator.Builtins | Lean.Name →
List Lean.Level →
Array Lean.Expr →
Array (Lean.TSyntax `Lean.Parser.Term.structInstField) →
Lean.NameMap Lean.Expr →
Lean.ConstructorVal →
Lean.PrettyPrinter.Delaborator.DelabM
(Lean.NameMap Lean.Expr × Array (Lean.TSyntax `Lean.Parser.Term.structInst... | null | false |
Polynomial.map_ne_zero | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {S : Type v} [inst : Ring R] [IsSimpleRing R] [inst_2 : Semiring S] [Nontrivial S] {p : Polynomial R}
{f : R →+* S}, p ≠ 0 → Polynomial.map f p ≠ 0 | null | true |
CategoryTheory.CostructuredArrow.mapIso_functor_obj_hom | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T T' : D} {S : CategoryTheory.Functor C D} (i : T ≅ T')
(X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)),
((CategoryTheory.CostructuredArrow.mapIso i).functor.obj X).hom = Cate... | null | true |
MonoidAlgebra.mem_span_support_coeff | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : MulOneClass G] (f : MonoidAlgebra k G),
f ∈ Submodule.span k (⇑(MonoidAlgebra.of k G) '' ↑f.coeff.support) | An element of `k[G]` is in the subalgebra generated by its support. | true |
Lean.Widget.instFromJsonRpcEncodablePacket._@.Lean.Widget.InteractiveGoal.2427803292._hygCtx._hyg.18 | Lean.Widget.InteractiveGoal | Lean.FromJson Lean.Widget.RpcEncodablePacket✝ | null | false |
CategoryTheory.Bicategory.associator_naturality_left_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f' (CategoryTheory.CategoryStruct.comp g h) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheo... | null | true |
groupHomology.inhomogeneousChains.d_single | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (n : ℕ) (g : Fin (n + 1) → G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom (groupHomology.inhomogeneousChains.d A n)) fun₀ | g => a) =
(fun₀ | fun i => g i.succ => (A.ρ (g 0)⁻¹) a) +
∑ j, (-1) ^ (↑j + 1) • fun₀ | j.contractNt... | null | true |
CategoryTheory.ShortComplex.HomotopyEquiv.homotopyInvHomId | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(self : S₁.HomotopyEquiv S₂) →
CategoryTheory.ShortComplex.Homotopy (CategoryTheory.CategoryStruct.comp self.inv self.hom)
(Categ... | the composition of the two directions of a homotopy equivalence is
homotopic to the identity of the target | true |
Lean.Grind.IntModule.OfNatModule.instLEQOfOrderedAdd | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
[inst_1 : LE α] →
[inst_2 : Std.IsPreorder α] → [Lean.Grind.OrderedAdd α] → LE (Lean.Grind.IntModule.OfNatModule.Q α) | null | true |
_private.Mathlib.Order.Fin.Tuple.0.Fin.preimage_insertNth_Icc_of_notMem._simp_1_2 | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (i : Fin (n + 1)) → Preorder (α i)] {i : Fin (n + 1)} {x : α i}
{p : (j : Fin n) → α (i.succAbove j)} {q₁ q₂ : (j : Fin (n + 1)) → α j},
(i.insertNth x p ∈ Set.Icc q₁ q₂) =
(x ∈ Set.Icc (q₁ i) (q₂ i) ∧ p ∈ Set.Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAb... | null | false |
Int.Internal.Linear.norm_dvd_gcd_cert | Init.Data.Int.Linear | ℤ → Int.Internal.Linear.Expr → ℤ → Int.Internal.Linear.Poly → ℤ → Bool | null | true |
Ring.DirectLimit.ringEquiv_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f' : (i j : ι) → i ≤ j → G i →+* G j) [inst_2 : DirectedSystem G fun i j h => ⇑(f' i j h)]
[inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι] {i : ι} {g : G i},
(Ring.DirectLimit.ringEquiv G f') ((Ring.DirectLimit.of G (f... | null | true |
Int.bmod_eq_of_le | Init.Data.Int.DivMod.Lemmas | ∀ {n : ℤ} {m : ℕ}, -(↑m / 2) ≤ n → n < (↑m + 1) / 2 → n.bmod m = n | null | true |
Lean.MessageLog.hasErrors | Lean.Message | Lean.MessageLog → Bool | Checks if either of `reported` or `unreported` contains an error, i.e. whether the current command
has errored yet.
| true |
Algebra.TensorProduct.piRight._proof_2 | Mathlib.RingTheory.TensorProduct.Pi | ∀ (R : Type u_1) (S : Type u_5) (A : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_3}
(B : ι → Type u_4) [inst_7 : (i : ι) → Semiring (B i)] [inst_8 : (i : ι) → Algebra... | null | false |
CommRingCat.monoidAlgebraAdj._proof_2 | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ (R : CommRingCat) ⦃X Y : CommMonCat⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id CommMonCat).map f)
(CommMonCat.ofHom (MonoidAlgebra.of ↑R ↑Y)) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (MonoidAlgebra.of ↑R ↑X))
((R.monoidAlgebra.comp ((CategoryTheory.Und... | null | false |
AddSubgroup.properlyDiscontinuousVAdd_of_tendsto_cofinite | Mathlib.Topology.Algebra.Group.Subgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G] (S : AddSubgroup G),
Filter.Tendsto (⇑S.subtype) Filter.cofinite (Filter.cocompact G) → ProperlyDiscontinuousVAdd (↥S) G | A subgroup `S` of an additive topological group `G` acts on `G` properly
discontinuously on the left, if it is discrete in the sense that `S ∩ K` is finite for all compact
`K`. (See also `DiscreteTopology`.) | true |
CategoryTheory.MorphismProperty.of_postcomp | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
{W' : CategoryTheory.MorphismProperty C} [W.HasOfPostcompProperty W'] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W' g → W (CategoryTheory.CategoryStruct.comp f g) → W f | null | true |
CategoryTheory.MorphismProperty.Under.map_comp | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y Z : T}
[inst_2 : P.IsStableUnderComposition] {f : X ⟶ Y} (hf : P f) {g : Y ⟶ Z} (hg : P g),
CategoryTheory.MorphismProperty.Under.map Q ... | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_2 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | null | false |
Convexity.StdSimplex.coe_affineMap | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
{N : Type u_3} (f : M → N), ⇑(Convexity.StdSimplex.affineMap f) = Convexity.StdSimplex.map f | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Std.DTreeMap.Internal.Impl.size_inter!_le_size_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → (m₁.inter! m₂).size ≤ m₁.size | null | true |
BddOrd.hom_comp | Mathlib.Order.Category.BddOrd | ∀ {X Y Z : BddOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
BddOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (BddOrd.Hom.hom g).comp (BddOrd.Hom.hom f) | null | true |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.addMustInline | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfoMap → Lean.FVarId → Lean.Compiler.LCNF.Simp.FunDeclInfoMap | Add new occurrence for the local function with binder name `key`.
| true |
Relation.symmGen_swap_apply | Mathlib.Logic.Relation | ∀ {α : Type u_1} {a b : α} (r : α → α → Prop), Relation.SymmGen (Function.swap r) a b ↔ Relation.SymmGen r a b | null | true |
VectorBundleCore.moduleFiber._proof_8 | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_4} (Z : VectorBundleCore R B F ι) (x : B)
(x_1 : Z.Fiber x), 0 • x_1 = 0 | null | false |
Fin.sum_univ_add | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] {a b : ℕ} (f : Fin (a + b) → M),
∑ i, f i = ∑ i, f (Fin.castAdd b i) + ∑ i, f (Fin.natAdd a i) | null | true |
NormedCommGroup.ofMulDist'.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_2} [inst : Norm E] [inst_1 : CommGroup E] [inst_2 : MetricSpace E] (h₁ : ∀ (x : E), ‖x‖ = dist 1 x)
(h₂ : ∀ (x y z : E), dist (z * x) (z * y) ≤ dist x y),
NormedCommGroup.ofMulDist' h₁ h₂ =
{ toNorm := (NormedGroup.ofMulDist' h₁ h₂).toNorm, toGroup := (NormedGroup.ofMulDist' h₁ h₂).toGroup, mul_co... | null | true |
LinearMap.lsmul_injective | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] {x : R}, x ≠ 0 → Function.Injective ⇑((LinearMap.lsmul R M) x) | null | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_sinKernel._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | null | false |
_private.Mathlib.RingTheory.Regular.LinearMap.0.IsSMulRegular.subsingleton_linearMap_iff._simp_1_3 | Mathlib.RingTheory.Regular.LinearMap | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = ∀ (x : B), x ∈ p ↔ x ∈ q | null | false |
MeasureTheory.setLIntegral_nnnorm_condExpL2_indicator_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {α : Type u_1} {E' : Type u_3} {𝕜 : Type u_7} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E']
[inst_2 : InnerProductSpace 𝕜 E'] [inst_3 : CompleteSpace E'] [NormedSpace ℝ E'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {s : Set α} (hm : m ≤ m0) (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (x : E') {t... | null | true |
DirectLimit.map₂_def₂ | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F₁ : ι → Type u_2} {F₂ : ι → Type u_3} {F : ι → Type u_4}
{T₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_6} (f₁ : (i j : ι) → (h : i ≤ j) → T₁ h)
[inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)]
[inst_2 : DirectedSystem F₁ fun x1 x2 x3 => ⇑(f₁ x1 x2 x3)] {T₂ : ⦃i j : ι⦄ → ... | null | true |
Ideal.quotientToQuotientRangePowQuotSucc._proof_4 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_2} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
(P : Ideal S) [hfp : NeZero (p.ramificationIdx' P)] {i : ℕ} {a : S} (a_mem : a ∈ P ^ i) (x : R ⧸ p) (y : S ⧸ P),
p.quotientToQuotientRangePowQuotSuccAux P a_mem (x • y) =
(RingHom.id (R ⧸ p)) x • p.quo... | null | false |
Lean.JsonRpc.instInhabitedMessage | Lean.Data.JsonRpc | Inhabited Lean.JsonRpc.Message | null | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.computeAbsoluteLspSemanticTokens.match_3 | Lean.Server.FileWorker.SemanticHighlighting | (motive : String.Pos.Raw × String.Pos.Raw → Sort u_1) →
(x : String.Pos.Raw × String.Pos.Raw) → ((pos tailPos : String.Pos.Raw) → motive (pos, tailPos)) → motive x | null | false |
Std.Iter.filterM | Init.Data.Iterators.Combinators.FilterMap | {α β : Type w} →
[Std.Iterator α Id β] →
{m : Type w → Type w'} →
[inst : Monad m] → [inst_1 : MonadAttach m] → (f : β → m (ULift.{w, 0} Bool)) → Std.Iter β → Std.IterM m β | If `it` is an iterator, then `it.filterM f` is another iterator that applies a monadic
predicate `f` to all values emitted by `it` and emits them only if they are accepted by `f`.
If `f` is pure, then the simpler variant `it.filter` can be used instead.
**Marble diagram (without monadic effects):**
```text
it ... | true |
_private.Batteries.Tactic.HelpCmd.0.Batteries.Tactic.elabHelpAttr.match_1 | Batteries.Tactic.HelpCmd | (motive : Lean.Name × Lean.AttributeImpl → Sort u_1) →
(x : Lean.Name × Lean.AttributeImpl) →
((name : Lean.Name) → (decl : Lean.AttributeImpl) → motive (name, decl)) → motive x | null | false |
skyscraperPresheafCoconeIsColimitOfNotSpecializes._proof_4 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (A : C) [inst_2 : CategoryTheory.Limits.HasTerminal C] {y : ↑X}
(h : ¬p₀ ⤳ y)
(c : CategoryTheory.Limits.Cocone ((TopologicalSpace.OpenNhds.inclusion y).op.comp (sk... | null | false |
SimpleGraph.TripartiteFromTriangles.Graph.not_in₀₀ | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {a a' : α},
¬(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₀ a) (Sum3.in₀ a') | null | true |
Ideal.isMaximal_iff_isPrime | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] [Ring.KrullDimLE 0 R] {I : Ideal R}, I.IsMaximal ↔ I.IsPrime | null | true |
Std.ExtHashSet.get_insert | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α} {h₁ : a ∈ m.insert k}, (m.insert k).get a h₁ = if h₂ : (k == a) = true ∧ k ∉ m then k else m.get a ⋯ | null | true |
Int16.toBitVec32_toISize | Init.Data.SInt.IntToBitVec | ∀ (n : Int16) (h : System.Platform.numBits = 32), n.toISize.toBitVec32 h = BitVec.signExtend 32 n.toBitVec | null | true |
Mathlib.Tactic.AtomM.Recurse.Config.casesOn | Mathlib.Util.AtomM.Recurse | {motive : Mathlib.Tactic.AtomM.Recurse.Config → Sort u} →
(t : Mathlib.Tactic.AtomM.Recurse.Config) →
((red : Lean.Meta.TransparencyMode) →
(zetaDelta contextual : Bool) → motive { red := red, zetaDelta := zetaDelta, contextual := contextual }) →
motive t | null | false |
CategoryTheory.conjugateIsoEquiv_symm_apply_inv | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂)
(β : R₁ ≅ R₂),
((CategoryTheory.conjugateIsoEquiv adj₁ adj₂).symm β).inv = (CategoryTh... | null | true |
_private.Std.Data.HashMap.IteratorLemmas.0.Std.HashMap.toArray_iter._simp_1_1 | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray | null | false |
Array.foldl_reverse | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : β → α → β} {b : β},
Array.foldl f b xs.reverse = Array.foldr (fun x y => f y x) b xs | null | true |
Circle.coeHom | Mathlib.Analysis.Complex.Circle | Circle →* ℂ | The coercion `Circle → ℂ` as a monoid homomorphism. | true |
CategoryTheory.Functor.mapCoconeWhisker.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C}
{E : Cat... | null | true |
PseudoEMetricSpace.noConfusion | Mathlib.Topology.EMetricSpace.Defs | {P : Sort u_1} →
{α : Type u} →
{t : PseudoEMetricSpace α} →
{α' : Type u} → {t' : PseudoEMetricSpace α'} → α = α' → t ≍ t' → PseudoEMetricSpace.noConfusionType P t t' | null | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.parentIsApp._default | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Bool | null | false |
SModEq.of_toAddSubgroup_le | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S] {M : Type u_4} [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : Module S M] {U : Submodule R M} {V : Submodule S M},
U.toAddSubgroup ≤ V.toAddSubgroup → ∀ {x y : M}, x ≡ y [SMOD U] → x ≡ y [SMOD V] | null | true |
AlgebraicGeometry.PresheafedSpace.isoOfComponents | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : AlgebraicGeometry.PresheafedSpace C} →
(H : ↑X ≅ ↑Y) → ((TopCat.Presheaf.pushforward C H.hom).obj X.presheaf ≅ Y.presheaf) → (X ≅ Y) | An isomorphism of `PresheafedSpace`s is a homeomorphism of the underlying space, and a
natural transformation between the sheaves.
| true |
Mathlib.Tactic.LinearCombination.Expanded._sizeOf_1 | Mathlib.Tactic.LinearCombination | Mathlib.Tactic.LinearCombination.Expanded → ℕ | null | false |
Turing.Tape.nth.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (T : Turing.Tape Γ) (n : ℕ), T.nth (Int.ofNat n.succ) = T.right.nth n | null | true |
_private.Mathlib.Tactic.Push.Attr.0.Mathlib.Tactic.Push.instBEqHead.beq._sparseCasesOn_1 | Mathlib.Tactic.Push.Attr | {motive : Mathlib.Tactic.Push.Head → Sort u} →
(t : Mathlib.Tactic.Push.Head) →
((c : Lean.Name) → motive (Mathlib.Tactic.Push.Head.const c)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.GrothendieckTopology.pseudofunctorOver_mapComp_hom_toNatTrans_app_hom_app | Mathlib.CategoryTheory.Sites.PseudofunctorSheafOver | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} A] {a b c : CategoryTheory.LocallyDiscrete Cᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c)
(X : CategoryTheory.Sheaf (J.over (Opposite.unop a.as)) A) (X_1 : (CategoryTheory.Ov... | null | true |
Lean.Meta.isDefEqOffset | Lean.Meta.Offset | Lean.Expr → Lean.Expr → Lean.MetaM Lean.LBool | null | true |
ContinuousGeneratedByCat.instHasForget₂TopCatContinuousMapCarrierContinuousMapGeneratedByCarrier | Mathlib.Topology.Convenient.Category | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] → CategoryTheory.HasForget₂ TopCat (ContinuousGeneratedByCat X) | Use the abbreviation `TopCat.toContinuousGeneratedByCat` for the faithful
functor `TopCat ⥤ ContinuousGeneratedByCat X` which sends
a topological space `Y` to the same type `Y`, with the same topology, but
considered as an object of `ContinuousGeneratedByCat X`. | true |
_private.Mathlib.Tactic.NormDet.0.norm_det.match_1 | Mathlib.Tactic.NormDet | (fst : Lean.Level) →
(fst :
have u := fst;
Q(Type u)) →
(motive : Option (Array Q(«$fst»)) → Sort u_1) →
(__x : Option (Array Q(«$fst»))) →
((entries : Array Q(«$fst»)) → motive (some entries)) → ((x : Option (Array Q(«$fst»))) → motive x) → motive __x | null | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.ensureInternalized | Lean.Meta.Tactic.Grind.ProveEq | Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | If `e` has not been internalized yet, instantiate metavariables, unfold reducible, canonicalize,
and internalize the result.
This is an auxiliary function used at `proveEq?` and `proveHEq?`.
| true |
SimpleGraph.support_deleteIncidenceSet_subset | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G : SimpleGraph V) (x : V), (G.deleteIncidenceSet x).support ⊆ G.support \ {x} | The support of `G.deleteIncidenceSet x` is a subset of the support of `G` set difference the
singleton set `{x}`. | true |
IsOrderedMonoid.of_mulLeftMono | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [MulLeftMono α], IsOrderedMonoid α | null | true |
_private.Mathlib.Data.List.Find.0.List.find?_eq_find?_of_perm._proof_1_4 | Mathlib.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} (x y : α) (l : List α),
p x = true → ¬p y = true → List.find? p (y :: x :: l) = List.find? p (x :: y :: l) | null | false |
RootPairing.toInvariantForm_form | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[inst_6 : P.IsAnisotropic], P.toInvariantForm.form = P.RootForm | null | true |
ULiftable.ctorIdx | Mathlib.Control.ULiftable | {f : outParam (Type u₀ → Type u₁)} → {g : Type v₀ → Type v₁} → ULiftable f g → ℕ | null | false |
NumberField.instCommRingAdeleRing._aux_8 | Mathlib.NumberTheory.NumberField.AdeleRing | (R : Type u_1) →
(K : Type u_2) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] → ℕ → NumberField.AdeleRing R K → NumberField.AdeleRing R K | null | false |
Lex.instDistribSMul' | Mathlib.Algebra.Order.GroupWithZero.Action.Synonym | {G₀ : Type u_1} → {M₀ : Type u_2} → [inst : AddZeroClass M₀] → [DistribSMul G₀ M₀] → DistribSMul G₀ (Lex M₀) | null | true |
CategoryTheory.Limits.limitConstTerminal._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.terminal.from (CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).o... | null | false |
Convex.isPathConnected | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
[ContinuousSMul ℝ E] {s : Set E}, Convex ℝ s → s.Nonempty → IsPathConnected s | A nonempty convex set is path connected. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.