name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasFiniteProducts C] (f : α → C) (S : (Finset (CategoryTheory.Discrete α))ᵒᵖ),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => (CategoryTheory.Discrete.functor f).obj ↑x) |
Antisymmetrization.induction_on | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsPreorder α r] {p : Antisymmetrization α r → Prop}
(a : Antisymmetrization α r), (∀ (a : α), p (toAntisymmetrization r a)) → p a |
Std.Tactic.BVDecide.BVUnOp.ctorElimType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} → ℕ → Sort (max 1 u) |
_private.Mathlib.CategoryTheory.Sites.Coherent.Comparison.0.CategoryTheory.extensive_regular_generate_coherent.match_1_4 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C] (Y : C)
(T : CategoryTheory.Presieve Y) (motive : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y → Prop)
(x : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y),
(∀ (α : Type) (x : Finite α) (X : α → C) (π : (a : α) → X a ⟶ Y) (h : T = CategoryTheory.Presieve.ofArrows X π)
(right : CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc π)), motive ⋯) →
motive x |
_private.Mathlib.Computability.Tape.0.Turing.Tape.nth.match_1.splitter | Mathlib.Computability.Tape | (motive : ℤ → Sort u_1) →
(x : ℤ) → (Unit → motive 0) → ((n : ℕ) → motive (Int.ofNat n.succ)) → ((n : ℕ) → motive (Int.negSucc n)) → motive x |
_private.Mathlib.Testing.Plausible.Functions.0.Plausible.TotalFunction.zeroDefault.match_1.splitter | Mathlib.Testing.Plausible.Functions | {α : Type u_1} →
{β : Type u_2} →
(motive : Plausible.TotalFunction α β → Sort u_3) →
(x : Plausible.TotalFunction α β) →
((A : List ((_ : α) × β)) → (a : β) → motive (Plausible.TotalFunction.withDefault A a)) → motive x |
Std.DTreeMap.Const.mergeWith._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} (mergeFn : α → β → β → β)
(t₁ t₂ : Std.DTreeMap α (fun x => β) cmp),
(Std.DTreeMap.Internal.Impl.Const.mergeWith mergeFn t₁.inner t₂.inner ⋯).impl.WF |
NormedSpace.exp_op | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_2} [inst : Ring 𝔸] [inst_1 : TopologicalSpace 𝔸] [inst_2 : IsTopologicalRing 𝔸] [T2Space 𝔸] (x : 𝔸),
NormedSpace.exp (MulOpposite.op x) = MulOpposite.op (NormedSpace.exp x) |
Module.Basis.linearMap | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
{ι₁ : Type u_6} →
{ι₂ : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
[Fintype ι₁] →
[Fintype ι₂] →
[DecidableEq ι₁] →
Module.Basis ι₁ R M₁ → Module.Basis ι₂ R M₂ → Module.Basis (ι₂ × ι₁) R (M₁ →ₗ[R] M₂) |
Topology.IsLower.tendsto_nhds_iff_not_le | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLower α] {β : Type u_3} {f : β → α}
{l : Filter β} {x : α}, Filter.Tendsto f l (nhds x) ↔ ∀ (y : α), ¬y ≤ x → ∀ᶠ (z : β) in l, ¬y ≤ f z |
_private.Mathlib.Algebra.Order.Round.0.round_eq_div._simp_1_3 | Mathlib.Algebra.Order.Round | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n |
ContinuousAlternatingMap.instContinuousEval | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NormedField 𝕜] [Finite ι]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommGroup F]
[inst_6 : IsTopologicalAddGroup F] [inst_7 : Module 𝕜 F], ContinuousEval (E [⋀^ι]→L[𝕜] F) (ι → E) F |
MeasureTheory.setIntegral_abs_condExp_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → ∀ (f : α → ℝ), ∫ (x : α) in s, |μ[f | m] x| ∂μ ≤ ∫ (x : α) in s, |f x| ∂μ |
Lean.Elab.Do.map1TermElabM | Lean.Elab.Do.Basic | {β : Sort u_1} →
({α : Type} → (β → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α) →
{α : Type} → (β → Lean.Elab.Do.DoElabM α) → Lean.Elab.Do.DoElabM α |
CompactT2.Projective | Mathlib.Topology.ExtremallyDisconnected | (X : Type u) → [TopologicalSpace X] → Prop |
Pi.zero_mono | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_4} {β : Type u_5} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Zero β], Monotone 0 |
Lean.IR.LitVal.str.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.LitVal → Sort u} →
(t : Lean.IR.LitVal) → t.ctorIdx = 1 → ((v : String) → motive (Lean.IR.LitVal.str v)) → motive t |
LinearMap.tensorEqLocus_coe | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N] [inst_10 : Module R P]
(f g : N →ₗ[R] P) (x : TensorProduct R M ↥(LinearMap.eqLocus f g)),
↑((LinearMap.tensorEqLocus S M f g) x) = (LinearMap.lTensor M (LinearMap.eqLocus f g).subtype) x |
CategoryTheory.Factorisation.casesOn | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Factorisation f → Sort u_1} →
(t : CategoryTheory.Factorisation f) →
((mid : C) →
(ι : X ⟶ mid) →
(π : mid ⟶ Y) →
(ι_π : CategoryTheory.CategoryStruct.comp ι π = f) →
motive { mid := mid, ι := ι, π := π, ι_π := ι_π }) →
motive t |
Subgroup.inv_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x ∈ H → x⁻¹ ∈ H |
RingQuot.mkRingHom_def | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop),
RingQuot.mkRingHom r =
{ toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ } |
Std.IterM.step_intermediateDropWhile._proof_4 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] {P : β → Bool} (out : β),
P out = false → ((pure ∘ ULift.up ∘ P) out).Property { down := false } |
Multiplicative.ofAdd.eq_1 | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {α : Type u}, Multiplicative.ofAdd = { toFun := fun x => x, invFun := fun x => x, left_inv := ⋯, right_inv := ⋯ } |
Lean.Grind.Nat.lo_lo | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w + k₂ ≤ v → u + (k₁ + k₂) ≤ v |
Int.instLocallyFiniteOrder._proof_6 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ),
x ∈ Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b + 1 - a).toNat) ↔ a ≤ x ∧ x ≤ b |
_private.Init.Data.String.Decode.0.String.toBitVec_getElem_utf8EncodeChar_zero_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (h : c.utf8Size = 2), (String.utf8EncodeChar c)[0].toBitVec = 6#3 ++ BitVec.extractLsb' 6 5 c.val.toBitVec |
List.Shortlex.of_length_lt | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} {s t : List α}, s.length < t.length → List.Shortlex r s t |
LinearEquiv.cast | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
[inst : Semiring R] →
{ι : Type u_14} →
{M : ι → Type u_15} →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → {i j : ι} → i = j → M i ≃ₗ[R] M j |
_private.Lean.Structure.0.Lean.findParentProjStruct?.go._unsafe_rec | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → StateM Lean.NameSet (Option Lean.Name) |
Filter.map_mapsTo_Iic_iff_tendsto | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {F : Filter α} {G : Filter β} {m : α → β},
Set.MapsTo (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ Filter.Tendsto m F G |
Lean.Lsp.ResolvableCompletionItemData.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentUri →
Lean.Lsp.Position → Option ℕ → Option Lean.Lsp.CompletionIdentifier → Lean.Lsp.ResolvableCompletionItemData |
_private.Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion.0.AlgebraicGeometry.isDominant_of_of_appTop_injective._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F), (RingHom.ker f = ⊥) = Function.Injective ⇑f |
Lean.Parser.Term.whereDecls._regBuiltin.Lean.Parser.Term.whereFinally.formatter_7 | Lean.Parser.Term | IO Unit |
smoothSheafCommGroup.eq_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H) (M : Type u) [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace HM M] (A : Type u)
[inst_9 : TopologicalSpace A] [inst_10 : ChartedSpace H A] [inst_11 : CommGroup A] [inst_12 : LieGroup I (↑⊤) A],
smoothSheafCommGroup IM I M A = { obj := smoothPresheafCommGroup IM I M A, property := ⋯ } |
_private.Mathlib.RingTheory.Radical.NatInt.0.Nat.one_lt_radical_iff.match_1_1 | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ} (motive : (∃ x ∈ n.primeFactors, 1 < x) → Prop) (x : ∃ x ∈ n.primeFactors, 1 < x),
(∀ (p : ℕ) (h : p ∈ n.primeFactors ∧ 1 < p), motive ⋯) → motive x |
AddMonoidHom.ofLeftInverse_symm_apply | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {g : N →+ G}
(h : Function.LeftInverse ⇑g ⇑f) (x : ↥f.range), (AddMonoidHom.ofLeftInverse h).symm x = g ↑x |
Positive.addSemigroup | Mathlib.Algebra.Order.Positive.Ring | {M : Type u_1} → [inst : AddMonoid M] → [inst_1 : Preorder M] → [AddLeftStrictMono M] → AddSemigroup { x // 0 < x } |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpiFamilies → Sort u_3} →
(t : F.PreservesEffectiveEpiFamilies) →
((preserves :
∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π],
CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) →
motive ⋯) →
motive t |
EuclideanGeometry.oangle_eq_zero_iff_oangle_rev_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ = 0 ↔ EuclideanGeometry.oangle p₃ p₂ p₁ = 0 |
Cardinal.powerlt_le | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b c : Cardinal.{u}}, a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c |
NonUnitalSubring.neg_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x : R}, x ∈ s → -x ∈ s |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) |
Lean.Grind.AC.SubsetResult.rec | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.SubsetResult → Sort u} →
motive Lean.Grind.AC.SubsetResult.false →
motive Lean.Grind.AC.SubsetResult.exact →
((s : Lean.Grind.AC.Seq) → motive (Lean.Grind.AC.SubsetResult.strict s)) →
(t : Lean.Grind.AC.SubsetResult) → motive t |
Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo.mk.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | ∀ {eToInt α he eToInt_1 α_1 he_1 : Lean.Expr},
{ eToInt := eToInt, α := α, he := he } = { eToInt := eToInt_1, α := α_1, he := he_1 } →
eToInt = eToInt_1 ∧ α = α_1 ∧ he = he_1 |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.visitAssignments.visitExpr | Lean.Linter.UnusedVariables | IO.Ref (Std.HashSet USize) → IO.Ref (Std.HashSet Lean.FVarId) → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit IO Unit |
Lean.Elab.Term.withSynthesize | Lean.Elab.SyntheticMVars | {m : Type → Type u_1} →
{α : Type} →
[MonadFunctorT Lean.Elab.TermElabM m] →
m α → optParam Lean.Elab.Term.PostponeBehavior Lean.Elab.Term.PostponeBehavior.no → m α |
Lean.PersistentArrayNode.node.elim | Lean.Data.PersistentArray | {α : Type u} →
{motive_1 : Lean.PersistentArrayNode α → Sort u_1} →
(t : Lean.PersistentArrayNode α) →
t.ctorIdx = 0 →
((cs : Array (Lean.PersistentArrayNode α)) → motive_1 (Lean.PersistentArrayNode.node cs)) → motive_1 t |
ContinuousWithinAt.eval_const | Mathlib.Topology.Hom.ContinuousEvalConst | ∀ {F : Type u_1} {α : Type u_2} {X : Type u_3} {Z : Type u_4} [inst : FunLike F α X] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [ContinuousEvalConst F α X] [inst_4 : TopologicalSpace Z] {f : Z → F} {s : Set Z}
{z : Z}, ContinuousWithinAt f s z → ∀ (x : α), ContinuousWithinAt (fun x_1 => (f x_1) x) s z |
Setoid.eq_iff_rel_eq | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, r₁ = r₂ ↔ ⇑r₁ = ⇑r₂ |
FreeGroup.Red.Step.lift | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [inst : Group β] {f : α → β},
FreeGroup.Red.Step L₁ L₂ → FreeGroup.Lift.aux f L₁ = FreeGroup.Lift.aux f L₂ |
Function.Injective.mem_range_iff_existsUnique | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {b : β}, b ∈ Set.range f ↔ ∃! a, f a = b |
Lean.Server.Test.Runner.Client.InteractiveGoalCore.noConfusionType | Lean.Server.Test.Runner | Sort u →
Lean.Server.Test.Runner.Client.InteractiveGoalCore → Lean.Server.Test.Runner.Client.InteractiveGoalCore → Sort u |
pow_le_pow | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] [MulRightMono M] {a b : M},
a ≤ b → 1 ≤ b → ∀ {m n : ℕ}, m ≤ n → a ^ m ≤ b ^ n |
Std.TreeSet.isSome_max?_eq_not_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isSome = !t.isEmpty |
CategoryTheory.LocalizerMorphism.LeftResolution.comp_f_assoc | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' L'' : Φ.LeftResolution X₂} (φ : L ⟶ L') (ψ : L' ⟶ L'') {Z : C₁} (h : L''.X₁ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp φ ψ).f h =
CategoryTheory.CategoryStruct.comp φ.f (CategoryTheory.CategoryStruct.comp ψ.f h) |
Function.locallyFinsuppWithin.restrictMonoidHom._proof_2 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(h : V ⊆ U), Function.locallyFinsuppWithin.restrict 0 h = 0 |
LinearEquiv.algEquivOfRing._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (e : R ≃ₗ[R] A)
(x : R), e.symm (e 1 * (algebraMap R A) x) = e.symm (x • e 1) |
mdifferentiableAt_prod_module_iff | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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_17} [inst_6 : NormedAddCommGroup F₁]
[inst_7 : NormedSpace 𝕜 F₁] {F₂ : Type u_18} [inst_8 : NormedAddCommGroup F₂] [inst_9 : NormedSpace 𝕜 F₂] {x : M}
(f : M → F₁ × F₂), MDiffAt f x ↔ MDiffAt (Prod.fst ∘ f) x ∧ MDiffAt (Prod.snd ∘ f) x |
Associates.mk_surjective | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], Function.Surjective Associates.mk |
List.sbtw_iff_triplewise_and_ne_pair | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {l : List P},
List.Sbtw R l ↔ List.Triplewise (Sbtw R) l ∧ ∀ (a : P), l ≠ [a, a] |
MeasureTheory.JordanDecomposition.exists_compl_positive_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α),
∃ S,
MeasurableSet S ∧
MeasureTheory.VectorMeasure.restrict j.toSignedMeasure S ≤ MeasureTheory.VectorMeasure.restrict 0 S ∧
MeasureTheory.VectorMeasure.restrict 0 Sᶜ ≤ MeasureTheory.VectorMeasure.restrict j.toSignedMeasure Sᶜ ∧
j.posPart S = 0 ∧ j.negPart Sᶜ = 0 |
alexDiscEquivPreord_inverse_map | Mathlib.Topology.Order.Category.AlexDisc | ∀ {X Y : Preord} (f : X ⟶ Y),
alexDiscEquivPreord.inverse.map f =
CategoryTheory.ConcreteCategory.ofHom (Topology.WithUpperSet.map (Preord.Hom.hom f)) |
TopologicalSpace.isSeparable_iUnion._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {ι : Sort u_2} [Countable ι] {s : ι → Set α},
TopologicalSpace.IsSeparable (⋃ i, s i) = ∀ (i : ι), TopologicalSpace.IsSeparable (s i) |
CategoryTheory.Over.postAdjunctionLeft_counit_app_left | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X : C} {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (a : F ⊣ G) (Y : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj (F.obj X))),
((CategoryTheory.Over.postAdjunctionLeft a).counit.app Y).left =
((((CategoryTheory.Over.mapPullbackAdj (a.unit.app X)).comp (CategoryTheory.Over.postAdjunctionRight a)).homEquiv
((CategoryTheory.Over.pullback (a.unit.app X)).obj (CategoryTheory.Over.mk (G.map Y.hom))) Y).symm
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Over.pullback (a.unit.app X)).obj (CategoryTheory.Over.mk (G.map Y.hom))))).left |
List.Pairwise.destutter_eq_dedup | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} [inst : DecidableEq α] {r : α → α → Prop} [Std.Antisymm r] {l : List α},
List.Pairwise r l → List.destutter (fun x1 x2 => x1 ≠ x2) l = l.dedup |
LinearIsometryEquiv.norm_iteratedFDeriv_comp_left | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (g : F ≃ₗᵢ[𝕜] G) (f : E → F) (x : E) (i : ℕ),
‖iteratedFDeriv 𝕜 i (⇑g ∘ f) x‖ = ‖iteratedFDeriv 𝕜 i f x‖ |
CategoryTheory.Abelian.Ext.comp_zero | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) (Z : C) (m p : ℕ)
(h : n + m = p), α.comp 0 h = 0 |
Int.Linear.Poly.divCoeffs.eq_2 | Init.Data.Int.Linear | ∀ (k k_1 : ℤ) (v : Int.Linear.Var) (p_1 : Int.Linear.Poly),
Int.Linear.Poly.divCoeffs k (Int.Linear.Poly.add k_1 v p_1) = (k_1 % k == 0 && Int.Linear.Poly.divCoeffs k p_1) |
Order.IsPredPrelimit.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LT α] (a : α), Order.IsPredPrelimit a = ∀ (b : α), ¬a ⋖ b |
NormedSpace.invertibleExpOfMemBall | Mathlib.Analysis.Normed.Algebra.Exponential | {𝕂 : Type u_1} →
{𝔸 : Type u_2} →
[inst : NontriviallyNormedField 𝕂] →
[inst_1 : NormedRing 𝔸] →
[inst_2 : NormedAlgebra 𝕂 𝔸] →
[CompleteSpace 𝔸] →
[CharZero 𝕂] →
{x : 𝔸} → x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → Invertible (NormedSpace.exp x) |
HurwitzZeta.evenKernel._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (x : ℝ),
Function.Periodic
(fun ξ => Real.exp (-Real.pi * ξ ^ 2 * x) * (jacobiTheta₂ (↑ξ * Complex.I * ↑x) (Complex.I * ↑x)).re) 1 |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_eq_if._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m + 1 < n + 1 → ¬n < m + 1 → False |
CategoryTheory.MorphismProperty.RightFraction.ofHom_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities], (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).f = f |
AlgebraicGeometry.ext_of_isDominant | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {W X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] {f g : X ⟶ Y} [Y.IsSeparated] (ι : W ⟶ X)
[AlgebraicGeometry.IsDominant ι],
CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g → f = g |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.exists_iso_single._proof_1_4 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n i : ℤ), n < i → n < i |
Std.DHashMap.Internal.mkIdx._proof_2 | Std.Data.DHashMap.Internal.Index | ∀ (sz : ℕ),
0 < sz → ∀ (hash : UInt64), ((Std.DHashMap.Internal.scrambleHash hash).toUSize &&& USize.ofNat sz - 1).toNat < sz |
IsLocalization.Away.mvPolynomialQuotientEquiv.congr_simp | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u_2} [inst : CommRing R] (S : Type u_3) [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
IsLocalization.Away.mvPolynomialQuotientEquiv S r = IsLocalization.Away.mvPolynomialQuotientEquiv S r |
Hindman.FP.below.casesOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FP a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FP a a_1) → Hindman.FP.below t → Prop} {a : Stream' M}
{a_1 : M} {t : Hindman.FP a a_1} (t_1 : Hindman.FP.below t),
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
(∀ (a : Stream' M) (m : M) (h : Hindman.FP a.tail m) (ih : Hindman.FP.below h) (h_ih : motive a.tail m h),
motive_1 ⋯ ⋯) →
(∀ (a : Stream' M) (m : M) (h : Hindman.FP a.tail m) (ih : Hindman.FP.below h) (h_ih : motive a.tail m h),
motive_1 ⋯ ⋯) →
motive_1 t t_1 |
Std.HashMap.Raw.size_filter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Bool}, m.WF → (Std.HashMap.Raw.filter f m).size ≤ m.size |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_right_inj._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) |
Lean.Lsp.CallHierarchyItem._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyItem |
Batteries.RBNode.Path.Zoomed._unsafe_rec | Batteries.Data.RBMap.Alter | {α : Type u_1} → (α → Ordering) → Batteries.RBNode.Path α → Prop |
Associates.normalize_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
(a : Associates α), normalize a.out = a.out |
Locale.pt | Mathlib.Topology.Order.Category.FrameAdjunction | CategoryTheory.Functor Locale TopCat |
_private.Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic.0.zpow_left_strictMonoOn₀._proof_1_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ (n : ℕ), 0 < ↑n → ¬n = 0 |
Class.coe_empty | Mathlib.SetTheory.ZFC.Class | ↑∅ = ∅ |
nnnorm_apply_le_nnnorm_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax |
AlgHom.tensorEqualizerEquiv_apply | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {A : Type u_4}
{B : Type u_5} [inst_7 : CommRing A] [inst_8 : CommRing B] [inst_9 : Algebra R A] [inst_10 : Algebra R B]
(f g : A →ₐ[R] B) [inst_11 : Module.Flat R T] (x : TensorProduct R T ↥(AlgHom.equalizer f g)),
(AlgHom.tensorEqualizerEquiv S T f g) x = (AlgHom.tensorEqualizer S T f g) x |
Set.Finite.iSup_biInf_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsCodirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j |
Std.Time.GenericFormat.ctorIdx | Std.Time.Format.Basic | {awareness : Std.Time.Awareness} → Std.Time.GenericFormat awareness → ℕ |
Lean.PrettyPrinter.Parenthesizer.many1NoAntiquot.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer |
Set.pi_univ_Ici | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i),
(Set.univ.pi fun i => Set.Ici (x i)) = Set.Ici x |
Sym2.diagSet_compl_eq_fromRel_ne | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1}, Sym2.diagSetᶜ = Sym2.fromRel ⋯ |
Nat.Linear.Poly.cancelAux.eq_def | Init.Data.Nat.Linear | ∀ (fuel : ℕ) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly),
Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂ =
match fuel with
| 0 => (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
| fuel.succ =>
match m₁, m₂ with
| m₁, [] => (List.reverse r₁ ++ m₁, List.reverse r₂)
| [], m₂ => (List.reverse r₁, List.reverse r₂ ++ m₂)
| (k₁, v₁) :: m₁, (k₂, v₂) :: m₂ =>
bif Nat.blt v₁ v₂ then Nat.Linear.Poly.cancelAux fuel m₁ ((k₂, v₂) :: m₂) ((k₁, v₁) :: r₁) r₂
else
bif Nat.blt v₂ v₁ then Nat.Linear.Poly.cancelAux fuel ((k₁, v₁) :: m₁) m₂ r₁ ((k₂, v₂) :: r₂)
else
bif k₁.blt k₂ then Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ ((k₂.sub k₁, v₁) :: r₂)
else
bif k₂.blt k₁ then Nat.Linear.Poly.cancelAux fuel m₁ m₂ ((k₁.sub k₂, v₁) :: r₁) r₂
else Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂ |
BoxIntegral.IntegrationParams.RCond.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_2} (l : BoxIntegral.IntegrationParams) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
l.RCond r = (l.bRiemann = true → ∀ (x : ι → ℝ), r x = r 0) |
FirstOrder.Language.LHom.IsExpansionOn.map_onFunction._autoParam | Mathlib.ModelTheory.LanguageMap | Lean.Syntax |
Lean.Elab.Command.addInheritDocDefault | Lean.Elab.Notation | Lean.Term →
Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") →
Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") |
Lean.Elab.Term.Quotation.HeadCheck.slice.elim | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadCheck → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadCheck) →
t.ctorIdx = 2 →
((numPrefix numSuffix : ℕ) → motive (Lean.Elab.Term.Quotation.HeadCheck.slice numPrefix numSuffix)) → motive t |
LinearMap.prodMapRingHom_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂)),
(LinearMap.prodMapRingHom R M M₂) f = f.1.prodMap f.2 |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.expandIfWrap.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((b : Lean.Expr) → motive (some b)) → motive x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.