name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Grind.SplitStatus.resolved | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitStatus | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.Value.mk.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ (n : ℕ) (value : Fin n) (n_1 : ℕ) (value_1 : Fin n_1),
({ n := n, value := value } = { n := n_1, value := value_1 }) = (n = n_1 ∧ value ≍ value_1) | null | true |
map_mem_nonunits_iff._simp_1 | Mathlib.RingTheory.Ideal.Nonunits | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] [inst_2 : FunLike F α β]
[MonoidHomClass F α β] (f : F) [IsLocalHom f] (a : α), (f a ∈ nonunits β) = (a ∈ nonunits α) | null | false |
EarlyReturnT | Init.Control.Do | Type u_1 → (Type u_1 → Type u_2) → Type u_1 → Type u_2 | A wrapper around `ExceptT` signifying early return. | true |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_append._proof_5 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → ¬n + (m - 1) = n + m - 1 → False | null | false |
Set.eqOn_union._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β},
Set.EqOn f₁ f₂ (s₁ ∪ s₂) = (Set.EqOn f₁ f₂ s₁ ∧ Set.EqOn f₁ f₂ s₂) | null | false |
_private.Mathlib.Order.ScottContinuity.0.ScottContinuousOn.prodMk._simp_1_2 | Mathlib.Order.ScottContinuity | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
exists_or_eq_imp'._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, (q a ∨ a' = a) ∧ p a) = ((∃ a, q a ∧ p a) ∨ p a') | null | false |
ComplexShape.QFactorsThroughHomotopy.mk._flat_ctor | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_3} {c : ComplexShape ι} {C : Type u_4} [inst : CategoryTheory.Category.{v_2, u_4} C]
[inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.CategoryWithHomology C],
(∀ {K L : HomologicalComplex C c} {f g : K ⟶ L} (h : Homotopy f g),
CategoryTheory.AreEqualizedByLocalization (Homologica... | null | false |
QuadraticForm.toDualProd | Mathlib.LinearAlgebra.QuadraticForm.Dual | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(Q : QuadraticForm R M) → [Invertible 2] → QuadraticMap.prod Q (-Q) →qᵢ QuadraticForm.dualProd R M | The isometry sending `(Q.prod <| -Q)` to `(QuadraticForm.dualProd R M)`.
This is `σ` from Proposition 4.8, page 84 of
[*Hermitian K-Theory and Geometric Applications*][hyman1973]; though we swap the order of the pairs.
| true |
CategoryTheory.ChosenPullbacksAlong.pullbackMap_snd._auto_3 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | null | false |
ContMDiffAddMonoidMorphism._sizeOf_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{H : Type u_2} →
{inst_1 : TopologicalSpace H} →
{E : Type u_3} →
{inst_2 : NormedAddCommGroup E} →
{inst_3 : NormedSpace 𝕜 E} →
{H' : Type u_5} →
{inst_4 : TopologicalSpace H'} →
... | null | false |
LinearOrder.OfStdArgs.mk.injEq | Mathlib.Order.Std | ∀ {α : Type u_1} (toPartialOrderArgs : PartialOrder.OfStdArgs α)
(isLinearOrder :
autoParam
(let this := toPartialOrderArgs.le;
Std.IsLinearOrder α)
LinearOrder.OfStdArgs.isLinearOrder._autoParam)
(decidableLE : autoParam (DecidableLE α) LinearOrder.OfStdArgs.decidableLE._autoParam)
(decidab... | null | true |
SSet.coherentIso.x₀ | Mathlib.AlgebraicTopology.SimplicialSet.CoherentIso | SSet.coherentIso.obj (Opposite.op { len := 0 }) | The source vertex of `coherentIso`. | true |
ProbabilityTheory.condIndepFun_iff_map_prod_eq_prod_map_map | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} [MeasurableSpace.CountableOrCountablyGenerat... | Two random variables are conditionally independent iff they satisfy the almost sure equality
of conditional expectations `μ⟦f ⁻¹' s ∩ g ⁻¹' t | m'⟧ =ᵐ[μ] μ⟦f ⁻¹' s | m'⟧ * μ⟦g ⁻¹' t | m'⟧`
for all measurable sets `s` and `t` (see `condIndepFun_iff_condExp_inter_preimage_eq_mul`).
Here, this is phrased with Markov kerne... | true |
CategoryTheory.MorphismProperty.relative_map_iff | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {P : CategoryTheory.MorphismProperty C} [F.Faithful] [F.Full]
[CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan F]
[CategoryTheor... | null | true |
SheafOfModules.pushforwardCompForgetToSheafModuleCat._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} {F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat}
{R : CategoryTheory.Sheaf K Ri... | null | false |
MeasureTheory.Lp.dist_eq_norm | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)), dist f g = ‖-f + g‖ | null | true |
MeasureTheory.hasFiniteIntegral_count_iff_enorm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} [inst : ENorm ε] [MeasurableSingletonClass α] {f : α → ε},
MeasureTheory.HasFiniteIntegral f MeasureTheory.Measure.count ↔ ∑' (x : α), ‖f x‖ₑ < ⊤ | A function has finite integral for the counting measure iff its enorm has finite `tsum`. | true |
DirectLimit.instSMulZeroClassOfMulActionHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι... | null | false |
CategoryTheory.Pretriangulated.Triangle.rotate_obj₃ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
T.rotate.obj₃ = (CategoryTheory.shiftFunctor C 1).obj T.obj₁ | null | true |
biInf_ge_eq_of_monotone | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ (b : β), ⨅ b', ⨅ (_ : b ≤ b'), f b' = f b | null | true |
BoxIntegral.unitPartition.prepartition_isPartition | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] {B : BoxIntegral.Box ι},
BoxIntegral.hasIntegralVertices B → (BoxIntegral.unitPartition.prepartition n B).IsPartition | If `B : BoxIntegral.Box` has integral vertices, then `prepartition n B` is a partition of
`B`. | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.eq_of_pairwise_lt_of_mem_iff_mem._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) | null | false |
Lean.Parser.Tactic.MCasesPat.clear | Std.Tactic.Do.Syntax | Lean.Parser.Tactic.MCasesPat | null | true |
Ordinal.card_lt_ofNat | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} {n : ℕ} [inst : n.AtLeastTwo], o.card < OfNat.ofNat n ↔ o < OfNat.ofNat n | null | true |
FirstOrder.Language.BoundedFormula.realize_inf._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ ⊓ ψ).Realize v xs = (φ.Realize v xs ∧ ψ.Realize v xs) | null | false |
Lean.Lsp.Ipc.ModuleHierarchy.mk.inj | Lean.Data.Lsp.Ipc | ∀ {item : Lean.Lsp.LeanImport} {children : Array Lean.Lsp.Ipc.ModuleHierarchy} {item_1 : Lean.Lsp.LeanImport}
{children_1 : Array Lean.Lsp.Ipc.ModuleHierarchy},
{ item := item, children := children } = { item := item_1, children := children_1 } →
item = item_1 ∧ children = children_1 | null | true |
Std.Iter.step_take | Init.Data.Iterators.Lemmas.Combinators.Take | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} {it : Std.Iter β},
(Std.Iter.take n it).step =
match n with
| 0 => Std.PlausibleIterStep.done ⋯
| k.succ =>
match it.step with
| ⟨Std.IterStep.yield it' out, h⟩ => Std.PlausibleIterStep.yield (Std.Iter.take k it') out ⋯
| ⟨Std.IterS... | null | true |
CategoryTheory.Precoverage.instCompleteLattice._proof_4 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (x x_1 : CategoryTheory.Precoverage C),
(x ⊓ x_1).coverings = (x ⊓ x_1).coverings | null | false |
AntisymmRel.antisymmRel_congr_right | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
AntisymmRel (fun x1 x2 => x1 ≤ x2) b c →
(AntisymmRel (fun x1 x2 => x1 ≤ x2) a b ↔ AntisymmRel (fun x1 x2 => x1 ≤ x2) a c) | null | true |
CategoryTheory.Localization.lift₄NatIso._proof_2 | Mathlib.CategoryTheory.Localization.Quadrifunctor | ∀ {C₁ : Type u_12} {C₂ : Type u_14} {C₃ : Type u_16} {C₄ : Type u_18} {D₁ : Type u_10} {D₂ : Type u_8} {D₃ : Type u_6}
{D₄ : Type u_4} {E : Type u_2} [inst : CategoryTheory.Category.{u_11, u_12} C₁]
[inst_1 : CategoryTheory.Category.{u_13, u_14} C₂] [inst_2 : CategoryTheory.Category.{u_15, u_16} C₃]
[inst_3 : Cat... | null | false |
_private.Aesop.Script.StructureDynamic.0.Aesop.Script.structureDynamicCore.go | Aesop.Script.StructureDynamic | Lean.MVarId →
Lean.Meta.SavedState → Array Lean.MVarId → Aesop.Script.DynStructureM (Option Aesop.Script.DynStructureResult) | null | true |
IsCyclotomicExtension.Rat.intermediateFieldEquivSubgroupChar | Mathlib.NumberTheory.NumberField.Cyclotomic.Galois | (n : ℕ) →
[NeZero n] →
(K : Type u_1) →
[inst : Field K] →
[inst_1 : NumberField K] →
[hK : IsCyclotomicExtension {n} ℚ K] →
(R : Type u_2) →
[inst_2 : CommRing R] →
[HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)] →
[IsAbeli... | The bijection between the intermediate fields of `ℚ(ζₙ)/ℚ` and the subgroups of the group
of Dirichlet characters of level `n`.
| true |
List.Nodup.length_le_of_subset | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Nodup → l₁ ⊆ l₂ → l₁.length ≤ l₂.length | A list with no duplicates that is a subset of another list is no longer than
that list. | true |
_private.Lean.Elab.Tactic.Classical.0.Lean.Elab.Tactic.evalClassical._regBuiltin.Lean.Elab.Tactic.evalClassical_3 | Lean.Elab.Tactic.Classical | IO Unit | null | false |
instMonoidalTopCatSSetToSSet | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | TopCat.toSSet.Monoidal | null | true |
mem_segment_iff_sameRay | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E}, x ∈ segment 𝕜 y z ↔ SameRay 𝕜 (x - y) (z - x) | null | true |
MeasureTheory.Integrable.sub' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f g : α → β},
MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → MeasureTheory.Integrable (fun a => f a - g a) μ | null | true |
Ideal.neg_mem_iff | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Ring α] (I : Ideal α) {a : α}, -a ∈ I ↔ a ∈ I | null | true |
AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f ↔
∀ {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ {V : X.Opens},
Algebr... | null | true |
Nat.length_repr_pos | Init.Data.Nat.ToString | ∀ {n : ℕ}, 0 < n.repr.length | null | true |
PseudoEpimorphism.copy._proof_2 | Mathlib.Topology.Order.Hom.Esakia | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (f : PseudoEpimorphism α β) (f' : α → β)
(h : f' = ⇑f) ⦃a : α⦄ ⦃b : β⦄, (f.copy f' h).toFun a ≤ b → ∃ c, a ≤ c ∧ (f.copy f' h).toFun c = b | null | false |
CategoryTheory.SpectralSequence.pageFunctor._proof_2 | 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₀ r : ℤ) (hr : r₀ ≤ r) {X Y Z : CategoryTheory.SpectralSequence C c r₀} (f : X ⟶ Y)
(g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).hom r ⋯ = CategoryTheory.CategorySt... | null | false |
Lean.Elab.Term.collectUnassignedMVars | Lean.Elab.Term.TermElabM | Lean.Expr →
optParam (Array Lean.Expr) #[] →
(optParam (Lean.MVarId → Bool) fun x => false) → Lean.Elab.TermElabM (Array Lean.Expr) | Collect unassigned metavariables in `type` that are not already in `init` and not satisfying `except`.
| true |
neg_concaveOn_iff._simp_1 | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f : E → β}, ConcaveOn 𝕜 s (-f) = ConvexOn 𝕜 s f | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.maxView.match_1.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β)
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3)
(size : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hr : (Std.DTreeMap.Internal... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_9 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ∀ i < p.darts.length, i + 1 < p.support.length | null | false |
ContMDiffMap.restrictMonoidHom | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{E' : Type u_3} →
[inst_3 : NormedAddCommGroup E'] →
[inst_4 : NormedSpace 𝕜 E'] →
{H : Type u_4} →
... | For a Lie group `G` and open sets `U ⊆ V` in `N`, the 'restriction' group homomorphism from
`C^n⟮I, V; I', G⟯` to `C^n⟮I, U; I', G⟯`. | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_theta_div_log_sq_isBigO._simp_1_4 | Mathlib.NumberTheory.Chebyshev | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
CategoryTheory.ConcreteCategory.epi_of_surjective | Mathlib.CategoryTheory.ConcreteCategory.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
(f : X ⟶ Y), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f) → CategoryTheory.Epi f | In any concrete category, surjective morphisms are epimorphisms. | true |
FreeGroup.instInv._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} ⦃a b : List (α × Bool)⦄,
FreeGroup.Red.Step a b → FreeGroup.Red.Step (FreeGroup.invRev a) (FreeGroup.invRev b) | null | false |
FiniteField.pow_card | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : GroupWithZero K] [inst_1 : Fintype K] (a : K), a ^ Fintype.card K = a | null | true |
Int.Internal.Linear.dvd_elim_cert.eq_1 | Init.Data.Int.Linear | ∀ (k₁ : ℤ) (p₁ : Int.Internal.Linear.Poly) (k₂ : ℤ) (p₂ : Int.Internal.Linear.Poly),
Int.Internal.Linear.dvd_elim_cert k₁ p₁ k₂ p₂ =
Int.Internal.Linear.Poly.rec (fun x => false) (fun a x p x_1 => k₂.beq' ↑(k₁.gcd a) && p₂.beq' p) p₁ | null | true |
Path.instHSpace | Mathlib.Topology.Homotopy.HSpaces | {X : Type u} → [inst : TopologicalSpace X] → (x : X) → HSpace (Path x x) | The loop space at x carries a structure of an H-space. Note that the field `eHmul`
(resp. `hmulE`) neither implies nor is implied by `Path.Homotopy.reflTrans`
(resp. `Path.Homotopy.transRefl`).
| true |
CategoryTheory.Bicategory.RightLift.IsKan.ofIdComp._proof_1 | Mathlib.CategoryTheory.Bicategory.Kan.IsKan | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t :
CategoryTheory.Bicategory.RightLift f (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id c) g))
(P : t.IsKan) (s : CategoryTheory.Bicategory.RightLift f g) (τ : s ⟶ t.ofIdComp),
τ = t.whiskerIdCan... | null | false |
ContDiffAt.abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {n : ℕ∞} {f : E → ℝ} {x : E},
ContDiffAt ℝ (↑n) f x → f x ≠ 0 → ContDiffAt ℝ (↑n) (fun x => |f x|) x | null | true |
_private.Batteries.Data.List.Lemmas.0.List.mem_idxsOf_iff_getElem_pos._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (hi : i < xs.length),
i ∈ List.idxsOf x xs ↔ (xs[i] == x) = true | null | false |
_private.Mathlib.Topology.Algebra.Group.SubmonoidClosure.0.mapClusterPt_inv_atTop_pow._simp_1_1 | Mathlib.Topology.Algebra.Group.SubmonoidClosure | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [CompactSpace G] [inst_3 : IsTopologicalGroup G]
{x y : G}, (MapClusterPt x Filter.atTop fun x => y ^ x) = (x ∈ (Subgroup.zpowers y).topologicalClosure) | null | false |
Multiset.filter_sub | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} [inst : DecidableEq α] (p : α → Prop) [inst_1 : DecidablePred p] (s t : Multiset α),
Multiset.filter p (s - t) = Multiset.filter p s - Multiset.filter p t | null | true |
Encodable.decode_unit_succ | Mathlib.Logic.Encodable.Basic | ∀ (n : ℕ), Encodable.decode n.succ = none | null | true |
instMonadFinallyEST | Init.System.ST | {ε σ : Type} → MonadFinally (EST ε σ) | null | true |
AddEquiv.piAddUnits | Mathlib.Algebra.Group.Pi.Units | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → AddMonoid (M i)] → AddUnits ((i : ι) → M i) ≃+ ((i : ι) → AddUnits (M i)) | The additive-monoid equivalence between (additive) units of a product,
and the product of the (additive) units of each monoid. | true |
SSet.PtSimplex.MulStruct.δ_map_of_lt | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i),
∀ j < i.castSucc.castSucc, CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) self.map = SSet.const x | null | true |
Lean.Elab.Tactic.BVDecide.BVDecideConfig._sizeOf_inst | Std.Tactic.BVDecide.Syntax | SizeOf Lean.Elab.Tactic.BVDecide.BVDecideConfig | null | false |
_private.Mathlib.Tactic.Linarith.Parsing.0.Mathlib.Tactic.Linarith.linearFormOfExpr.match_9 | Mathlib.Tactic.Linarith.Parsing | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → (Unit → motive (some 0)) → ((n : ℕ) → motive (some n.succ)) → (Unit → motive none) → motive x | null | false |
Prod.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (a : R × S),
a * 0 = 0 | null | false |
Real.iteratedDeriv_odd_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (n : ℕ), iteratedDeriv (2 * n + 1) Real.sinh = Real.cosh | null | true |
nonemptyFinLinOrdDualCompForgetToFinPartOrd | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd.dual.comp (CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd) ≅
(CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd).comp FinPartOrd.dual | The forgetful functor `NonemptyFinLinOrd ⥤ FinPartOrd` and `OrderDual` commute. | true |
Rat.lt_toNNRat_iff_coe_lt | Mathlib.Data.NNRat.Defs | ∀ {p : ℚ} {q : ℚ≥0}, q < p.toNNRat ↔ ↑q < p | null | true |
summable_eisSummand | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {k : ℕ}, 3 ≤ k → ∀ (z : UpperHalfPlane), Summable fun x => EisensteinSeries.eisSummand (↑k) x z | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.encodePi.match_5.splitter | Batteries.Data.Fin.Coding | (motive : (n : ℕ) → (f : Fin n → ℕ) → ((i : Fin n) → Fin (f i)) → Sort u_1) →
(n : ℕ) →
(f : Fin n → ℕ) →
(x : (i : Fin n) → Fin (f i)) →
((x : Fin 0 → ℕ) → (x_1 : (i : Fin 0) → Fin (x i)) → motive 0 x x_1) →
((n : ℕ) → (f : Fin (n + 1) → ℕ) → (x : (i : Fin (n + 1)) → Fin (f i)) → motive n... | null | true |
Rep.coindFunctorIso_hom_app_hom_toFun_hom_toFun | Mathlib.RepresentationTheory.Coinduced | ∀ {k : Type u} {G : Type v} {H : Type w} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
(X : Rep.{max u w, u, v} k G) (f : ↥(Representation.coindV φ X.ρ)) (x : ↑(Rep.leftRegular k H)),
(Rep.Hom.hom ((Rep.Hom.hom ((Rep.coindFunctorIso φ).hom.app X)) f)) x = (Finsupp.linearCombination k ↑f) ... | null | true |
tacticClosedness?_ | Mathlib.Tactic.GrindAttrs | Lean.ParserDescr | `closedness` is a simple tactic that tries various lemmas to prove that a set is closed,
and reasoning about the closure of sets.
It is implemented using `grind`, and has the same configuration options as `grind`.
It also exists as a grind attribute, and can be combined with other grind attributes using
`grind only [c... | true |
MeasureTheory.Adapted.measurable_le | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : ι → Type u_3} [inst_1 : (i : ι) → MeasurableSpace (β i)] {u : (i : ι) → Ω → β i} {i j : ι},
MeasureTheory.Adapted f u → i ≤ j → Measurable (u i) | null | true |
TopCat.instCreatesLimitsSheafPresheafForgetOfHasLimits | Mathlib.Topology.Sheaves.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasLimits C] → (X : TopCat) → CategoryTheory.CreatesLimits (TopCat.Sheaf.forget C X) | null | true |
Lean.Meta.SizeOfSpecNested.Context.ctorIdx | Lean.Meta.SizeOf | Lean.Meta.SizeOfSpecNested.Context → ℕ | null | false |
AddMonoidHom.addSubgroupComap_surjective | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (f : G →+ G') (H' : AddSubgroup G'),
Function.Surjective ⇑f → Function.Surjective ⇑(f.addSubgroupComap H') | null | true |
IsOpen.trivializationDiscrete_baseSet | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X}
[inst_2 : Nonempty (X → E)] {ι : Type u_3} [inst_3 : Nonempty ι] [inst_4 : TopologicalSpace ι]
[inst_5 : DiscreteTopology ι] (U : ι → Set E) (V : Set X) (open_V : IsOpen V)
(open_iff : ∀ (i : ι) {W : Set X}, W ⊆ ... | null | true |
FirstOrder.Field.instModelACFOfCharPOfIsAlgClosed | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {K : Type u_1} [inst : Field K] [inst_1 : FirstOrder.Ring.CompatibleRing K] {p : ℕ} [CharP K p] [IsAlgClosed K],
K ⊨ FirstOrder.Language.Theory.ACF p | null | true |
Ordinal.veblen_le_veblen_iff_right | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o a b : Ordinal.{u}}, Ordinal.veblen o a ≤ Ordinal.veblen o b ↔ a ≤ b | null | true |
Std.Broadcast.close | Std.Sync.Broadcast | {α : Type} → Std.Broadcast α → IO Unit | Closes a `Broadcast` channel.
| true |
Nat.Primrec'.below | Mathlib.Computability.Primrec.List | {motive : {n : ℕ} → (a : List.Vector ℕ n → ℕ) → Nat.Primrec' a → Prop} →
{n : ℕ} → {a : List.Vector ℕ n → ℕ} → Nat.Primrec' a → Prop | null | true |
MeasureTheory.Measure.compProd_apply_prod | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β} [MeasureTheory.SFinite μ] [ProbabilityTheory.IsSFiniteKernel κ] {s : Set α}
{t : Set β}, MeasurableSet s → MeasurableSet t → (μ.compProd κ) (s ×ˢ t) = ∫⁻ (a : α) in s, (... | null | true |
CategoryTheory.IsIso.eq_inv_comp._simp_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
{f : X ⟶ Z} {g : Y ⟶ Z},
(g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f) = (CategoryTheory.CategoryStruct.comp α g = f) | null | false |
Singleton.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{β : Type v} →
{P : Sort u_1} →
{singleton singleton' : α → β} →
{ singleton := singleton } = { singleton := singleton' } → (singleton ≍ singleton' → P) → P | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Rank.0.Matrix.cRank_diagonal._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {a b c : α}, ((if P then a else b) = c) = ((P → a = c) ∧ (¬P → b = c)) | null | false |
CategoryTheory.Adjunction.compCoyonedaIso | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
(F.op.comp CategoryTheory.coyoneda ≅
Categ... | The isomorphism which an adjunction `F ⊣ G` induces on `F.op ⋙ coyoneda`. This states that
`Adjunction.homEquiv` is natural in both arguments. | true |
Lean.Elab.Tactic.Grind.Context.ctx | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.Context → Lean.Meta.Grind.Context | null | true |
Lean.Compiler.LCNF.UnreachableBranches.InterpContext | Lean.Compiler.LCNF.ElimDeadBranches | Type | The context of `InterpM`.
| true |
Order.IsSuccLimit | Mathlib.Order.SuccPred.Limit | {α : Type u_1} → [Preorder α] → α → Prop | A successor limit is a value that isn't minimal and doesn't cover any other.
It's so named because in a successor order, a successor limit can't be the successor of anything
smaller.
Use `IsSuccPrelimit` if you want to include the case of a minimal element. | true |
IsLocalExtr | Mathlib.Topology.Order.LocalExtr | {α : Type u} → {β : Type v} → [TopologicalSpace α] → [Preorder β] → (α → β) → α → Prop | `IsLocalExtr f s a` means `IsLocalMin f s a ∨ IsLocalMax f s a`. | true |
PiTensorProduct.dualDistribInvOfBasis.congr_simp | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b b_1 : (i : ι) → Module.Basis (κ i) R (M i)),
b = b_1 → PiTensorProduct.dualDistribInvOfBas... | null | true |
_private.Mathlib.Algebra.GroupWithZero.Center.0.Set.zero_mem_centralizer._simp_1_1 | Mathlib.Algebra.GroupWithZero.Center | ∀ {M : Type u_1} {S : Set M} [inst : Mul M] {c : M}, (c ∈ S.centralizer) = ∀ m ∈ S, m * c = c * m | null | false |
CategoryTheory.Functor.weightedLimFlipObj'._proof_4 | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {C : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} C] (F : CategoryTheory.Functor J C)
{X Y Z : F.hasWeightedLimit.FullSubcategoryᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Functor.weightedLimFlipObjMap (CategoryTheory.CategoryStruct.comp f ... | null | false |
LSeries.abscissaOfAbsConv_congr' | Mathlib.NumberTheory.LSeries.Convergence | ∀ {f g : ℕ → ℂ}, f =ᶠ[Filter.atTop] g → LSeries.abscissaOfAbsConv f = LSeries.abscissaOfAbsConv g | If `f` and `g` agree on large `n : ℕ`, then their `LSeries` have the same
abscissa of absolute convergence. | true |
exists_ratio_deriv_eq_ratio_slope' | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ (f : ℝ → ℝ) {a b : ℝ},
a < b →
∀ (g : ℝ → ℝ) {lfa lga lfb lgb : ℝ},
DifferentiableOn ℝ f (Set.Ioo a b) →
DifferentiableOn ℝ g (Set.Ioo a b) →
Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds lfa) →
Filter.Tendsto g (nhdsWithin a (Set.Ioi a)) (nhds lga) →
Filter... | Cauchy's Mean Value Theorem, extended `deriv` version. | true |
MemHolder.of_le' | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {r : NNReal} {f : X → Y}
{s : NNReal}, MemHolder r f → s ≤ r → (∃ C, ∀ (x y : X), edist x y ≤ ↑C) → MemHolder s f | If a function is `r`-Hölder over a bounded space, then it is also `s`-Hölder when `s ≤ r`.
See `MemHolder.of_le` for the version in a pseudometric space. | true |
Lean.Meta.Simp.ResultQ.mk | Qq.Simp | {u : Lean.Level} →
{α : Q(Sort u)} →
{e : Q(«$α»)} → (expr : Q(«$α»)) → Option Q(«$e» = «$expr») → optParam Bool true → Lean.Meta.Simp.ResultQ e | A copy of `Meta.Simp.Result.mk` with explicit types. | true |
AddChar.coe_mul._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : CommMonoid M] (ψ χ : AddChar A M), ⇑ψ * ⇑χ = ⇑(ψ * χ) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.