name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
NormedField.edist._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(dist : α → α → ℝ) →
(∀ (x : α), dist x x = 0) →
(∀ (x y : α), dist x y = dist y x) → (∀ (x y z : α), dist x z ≤ dist x y + dist y z) → α → α → ENNReal |
Finset.inter_singleton_of_mem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → s ∩ {a} = {a} |
CategoryTheory.Limits.MultispanShape.prod_R | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ (ι : Type w), (CategoryTheory.Limits.MultispanShape.prod ι).R = ι |
Northcott.finite_le | Mathlib.NumberTheory.Height.Northcott | ∀ {α : Type u_1} {β : Type u_2} {h : α → β} {inst : LE β} [self : Northcott h] (b : β), {a | h a ≤ b}.Finite |
CircularPartialOrder.ctorIdx | Mathlib.Order.Circular | {α : Type u_1} → CircularPartialOrder α → ℕ |
Set.mul_iInter₂_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : Mul α] (s : Set α) (t : (i : ι) → κ i → Set α),
s * ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s * t i j |
Int.getElem?_toList_roc_eq_none_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m<...=n).toList[i]? = none) = ((n - m).toNat ≤ i) |
_private.Mathlib.Algebra.Polynomial.CoeffList.0.Polynomial.coeffList_eraseLead._proof_1_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] {P : Polynomial R},
¬P.natDegree = 0 →
P.eraseLead.degree.succ = P.eraseLead.natDegree + 1 →
P.eraseLead.natDegree ≤ P.natDegree - 1 →
P.natDegree = P.eraseLead.natDegree + 1 + (P.natDegree - P.eraseLead.natDegree - 1) ∧
P.natDegree - P.eraseLead.natDegree - 1 = P.natDegree - P.eraseLead.degree.succ |
_private.Mathlib.Logic.Encodable.Basic.0.Encodable.decidable_good._proof_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} (n : Option α), n = none → none = n |
Set.preimage_const_mul_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b c : α),
(fun x => a * x) ⁻¹' Set.Ioo b c = Set.Ioo (b / a) (c / a) |
HomologicalComplex.evalCompCoyonedaCorepresentative._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {ι : Type u_1} (c : ComplexShape ι) (j : ι) (hj : ∃ k, c.Rel j k), c.Rel j hj.choose |
Quiver.SingleObj.pathToList._sunfold | Mathlib.Combinatorics.Quiver.SingleObj | {α : Type u_1} → {x : Quiver.SingleObj α} → Quiver.Path (Quiver.SingleObj.star α) x → List α |
AlgebraicGeometry.Scheme.Opens.mem_basicOpen_toScheme._simp_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} {V : (↑U).Opens} {r : ↑((↑U).presheaf.obj (Opposite.op V))} {x : ↥U},
(x ∈ (↑U).basicOpen r) = (↑x ∈ X.basicOpen r) |
IsUltrametricDist.algNormOfAlgEquiv_extends | Mathlib.Analysis.Normed.Unbundled.InvariantExtension | ∀ {K : Type u_1} [inst : NormedField K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hu : IsUltrametricDist K] (σ : Gal(L/K)) (x : K),
(IsUltrametricDist.algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ |
ULift.instT5Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T5Space X], T5Space (ULift.{u_3, u_1} X) |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.0.AlgebraicGeometry.homogeneousLocalizationToStalk_stalkToFiberRingHom._simp_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ |
RelIso.mk.sizeOf_spec | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_5} {β : Type u_6} {r : α → α → Prop} {s : β → β → Prop} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : (a a_1 : α) → SizeOf (r a a_1)] [inst_3 : (a a_1 : β) → SizeOf (s a a_1)] (toEquiv : α ≃ β)
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b),
sizeOf { toEquiv := toEquiv, map_rel_iff' := map_rel_iff' } = 1 + sizeOf toEquiv |
OrderedFinpartition.eraseLeft._proof_7 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (i : Fin (c.length - 1)), 0 < c.partSize (Fin.cast ⋯ i.succ) |
CategoryTheory.Functor.closedSieves_map_coe | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J₁ : CategoryTheory.GrothendieckTopology C) {X Y : Cᵒᵖ}
(f : X ⟶ Y) (S : { S // J₁.IsClosed S }),
↑((CategoryTheory.Functor.closedSieves J₁).map f S) = CategoryTheory.Sieve.pullback f.unop ↑S |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_signExtend._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, ¬w ≥ v → v - w = 0 → False |
AddMonoidHom.injective_codRestrict._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f |
List.any_toArray | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, l.toArray.any p = l.any p |
_private.Mathlib.Data.Option.NAry.0.Option.map₂_eq_some_iff._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ},
Option.map₂ f a b = some c ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c |
Lean.Compiler.LCNF.ToMonoM.State.noConfusionType | Lean.Compiler.LCNF.ToMono | Sort u → Lean.Compiler.LCNF.ToMonoM.State → Lean.Compiler.LCNF.ToMonoM.State → Sort u |
_private.Mathlib.Logic.IsEmpty.Basic.0.leftTotal_iff_isEmpty_left._simp_1_2 | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∃ a, p a) = False |
CategoryTheory.NatTrans.ext | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F G : CategoryTheory.Functor C D} {x y : CategoryTheory.NatTrans F G}, x.app = y.app → x = y |
Ordnode.Bounded.mem_lt | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o : WithBot α} {x : α},
t.Bounded o ↑x → Ordnode.All (fun x_1 => x_1 < x) t |
Lean.Meta.MatcherApp.mk._flat_ctor | Lean.Meta.Match.MatcherApp.Basic | ℕ →
ℕ →
Array Lean.Meta.Match.AltParamInfo →
Option ℕ →
Array Lean.Meta.Match.DiscrInfo →
Lean.Meta.Match.Overlaps →
Lean.Name →
Array Lean.Level →
Array Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.MatcherApp |
Real.normedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (a b : ℝ), a + b = b + a |
Units.liftRight._proof_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (g : M → Nˣ),
(∀ (x : M), ↑(g x) = f x) → g 1 = 1 |
SSet.RelativeMorphism.Homotopy.h₀._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | Lean.Syntax |
List.ranges._sunfold | Mathlib.Data.List.Range | List ℕ → List (List ℕ) |
Turing.PartrecToTM2.contSupp.eq_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.contSupp (Turing.PartrecToTM2.Cont'.comp f k) =
Turing.PartrecToTM2.codeSupp' f k ∪ Turing.PartrecToTM2.contSupp k |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.Tree.unop.inj | Lean.Elab.Extra | ∀ {ref : Lean.Syntax} {f : Lean.Expr} {arg : Lean.Elab.Term.Op.Tree✝} {ref_1 : Lean.Syntax} {f_1 : Lean.Expr}
{arg_1 : Lean.Elab.Term.Op.Tree✝¹},
Lean.Elab.Term.Op.Tree.unop✝ ref f arg = Lean.Elab.Term.Op.Tree.unop✝¹ ref_1 f_1 arg_1 →
ref = ref_1 ∧ f = f_1 ∧ arg = arg_1 |
Stream'.WSeq.productive_tail | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s : Stream'.WSeq α) [s.Productive], s.tail.Productive |
Matrix.conjTranspose_list_sum | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddMonoid α] [inst_1 : StarAddMonoid α] (l : List (Matrix m n α)),
l.sum.conjTranspose = (List.map Matrix.conjTranspose l).sum |
SimpleGraph.ConnectedComponent.connected_toSubgraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent), C.toSubgraph.Connected |
WeierstrassCurve.Jacobian.Point.instAddCommGroup._proof_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (n : ℕ) (a : W.Point),
zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a |
Fin.succ_lt_succ_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, (a.succ < b.succ) = (a < b) |
Std.TreeMap.Raw.contains_ofList | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (Std.TreeMap.Raw.ofList l cmp).contains k = (List.map Prod.fst l).contains k |
CategoryTheory.CartesianClosed.curry_id_eq_coev | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A X : C)
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj A ((CategoryTheory.Functor.id C).obj X))) =
(CategoryTheory.ihom.coev A).app X |
FirstOrder.Language.ElementaryEmbedding.noConfusion | Mathlib.ModelTheory.ElementaryMaps | {P : Sort u} →
{L : FirstOrder.Language} →
{M : Type u_1} →
{N : Type u_2} →
{inst : L.Structure M} →
{inst_1 : L.Structure N} →
{t : L.ElementaryEmbedding M N} →
{L' : FirstOrder.Language} →
{M' : Type u_1} →
{N' : Type u_2} →
{inst' : L'.Structure M'} →
{inst'_1 : L'.Structure N'} →
{t' : L'.ElementaryEmbedding M' N'} →
L = L' →
M = M' →
N = N' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
t ≍ t' → FirstOrder.Language.ElementaryEmbedding.noConfusionType P t t' |
antivaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
AntivaryOn (-f) (-g) s ↔ AntivaryOn f g s |
Ordnode.splitMax | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Option (Ordnode α × α) |
CategoryTheory.Comma.leftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L₁ : CategoryTheory.Functor A T} →
{R₁ : CategoryTheory.Functor B T} → {X Y : CategoryTheory.Comma L₁ R₁} → (X ≅ Y) → (X.left ≅ Y.left) |
Matroid.ext_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M M' : Matroid α}, M.E = M'.E → (∀ S ⊆ M.E, M.Spanning S ↔ M'.Spanning S) → M = M' |
Nat.Linear.PolyCnstr.mk | Init.Data.Nat.Linear | Bool → Nat.Linear.Poly → Nat.Linear.Poly → Nat.Linear.PolyCnstr |
_private.Std.Time.Format.Basic.0.Std.Time.instReprFormatPart.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.FormatPart → Sort u_1) →
(x : Std.Time.FormatPart) →
((a : String) → motive (Std.Time.FormatPart.string a)) →
((a : Std.Time.Modifier) → motive (Std.Time.FormatPart.modifier a)) → motive x |
Function.locallyFinsuppWithin.instMaxOfSemilatticeSup | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} → {Y : Type u_2} → [SemilatticeSup Y] → [inst_2 : Zero Y] → Max (Function.locallyFinsuppWithin U Y) |
WithCStarModule.inner_single_right | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [inst_7 : StarOrderedRing A]
[inst_8 : DecidableEq ι] (x : WithCStarModule A ((i : ι) → E i)) {i : ι} (y : E i),
inner A x ((WithCStarModule.equiv A ((i : ι) → E i)).symm (Pi.single i y)) = inner A (x i) y |
Aesop.MVarClusterData.goals | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp → Array (IO.Ref Goal) |
ProofWidgets.CheckRequestResponse.noConfusion | ProofWidgets.Cancellable | {P : Sort u} →
{t t' : ProofWidgets.CheckRequestResponse} → t = t' → ProofWidgets.CheckRequestResponse.noConfusionType P t t' |
_private.Init.Data.Vector.Basic.0.Vector.mapM.go._unary._proof_4 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k < n, k + 1 ≤ n |
_private.Lean.Server.Completion.CompletionItemCompression.0.Lean.Lsp.ResolvableCompletionList.compressEditFast | Lean.Server.Completion.CompletionItemCompression | String → Lean.Lsp.InsertReplaceEdit → String |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.fundCircuit_eq_sInter._simp_1_2 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) |
ULift.mul | Mathlib.Algebra.Group.ULift | {α : Type u} → [Mul α] → Mul (ULift.{u_1, u} α) |
LowerSemicontinuousWithinAt.le_liminf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {x : α} {γ : Type u_4} [inst_1 : CompleteLinearOrder γ]
{f : α → γ}, LowerSemicontinuousWithinAt f s x → f x ≤ Filter.liminf f (nhdsWithin x s) |
Int.Nonneg.mul | Init.Data.Int.OfNat | ∀ (a b : ℤ), a ≥ 0 → b ≥ 0 → a * b ≥ 0 |
Finset.Ico_subset_Iio_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Iio b |
measurable_to_countable' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [Countable α] [inst_2 : MeasurableSpace β] {f : β → α},
(∀ (x : α), MeasurableSet (f ⁻¹' {x})) → Measurable f |
«_aux_Mathlib_NumberTheory_Padics_Complex___macroRules_term𝓞_ℂ_[_]_1» | Mathlib.NumberTheory.Padics.Complex | Lean.Macro |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_13 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (c : C)
{c' c'' : C} (f : c' ⟶ c'') (d : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f) d =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator c c' d).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft c (CategoryTheory.MonoidalCategoryStruct.whiskerRight f d))
(CategoryTheory.MonoidalCategoryStruct.associator c c'' d).inv) |
CancelCommMonoidWithZero.mk.sizeOf_spec | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [inst : SizeOf M₀] (toCommMonoidWithZero : CommMonoidWithZero M₀)
(toIsLeftCancelMulZero : IsLeftCancelMulZero M₀),
sizeOf { toCommMonoidWithZero := toCommMonoidWithZero, toIsLeftCancelMulZero := toIsLeftCancelMulZero } =
1 + sizeOf toCommMonoidWithZero + sizeOf toIsLeftCancelMulZero |
lipschitzOnWith_iff_norm_inv_mul_le | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F] {s : Set E} {f : E → F}
{C : NNReal}, LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖(f x)⁻¹ * f y‖ ≤ ↑C * ‖x⁻¹ * y‖ |
BitVec.umulOverflow.eq_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.umulOverflow y = decide (x.toNat * y.toNat ≥ 2 ^ w) |
_private.Mathlib.Data.List.Nodup.0.List.nodup_iff_count_eq_one._proof_1_4 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} [inst : BEq α] (x : α),
(List.count x l ≤ 1) = ¬(1 ≤ List.count x l → List.count x l = 1) →
List.count x l ≤ 1 → 0 < (List.filter (fun x_1 => x_1 == x) l).length |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ofIterate._simp_3 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
InnerProductGeometry.norm_add_eq_norm_sub_iff_angle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
‖x + y‖ = ‖x - y‖ ↔ InnerProductGeometry.angle x y = Real.pi / 2 |
CategoryTheory.ShortComplex.leftHomologyIso_hom_naturality_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ : S₁ ⟶ S₂) {Z : C}
(h : S₂.homology ⟶ Z),
CategoryTheory.CategoryStruct.comp S₁.leftHomologyIso.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap φ)
(CategoryTheory.CategoryStruct.comp S₂.leftHomologyIso.hom h) |
Lean.Meta.FindSplitImpl.Context.mk | Lean.Meta.Tactic.SplitIf | Lean.ExprSet → Lean.Meta.SplitKind → Lean.Meta.FindSplitImpl.Context |
Multiset.card_eq_countP_add_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
s.card = Multiset.countP p s + Multiset.countP (fun x => ¬p x) s |
Nat.and_left_comm | Batteries.Data.Nat.Bitwise | ∀ (x y z : ℕ), x &&& (y &&& z) = y &&& (x &&& z) |
Substring.Raw.Valid.next_stop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → s.next { byteIdx := s.bsize } = { byteIdx := s.bsize } |
_private.Init.Meta.0.Lean.Parser.Tactic._aux_Init_Meta___macroRules_Lean_Parser_Tactic_declareSimpLikeTactic_1.match_4 | Init.Meta | (motive : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command → Sort u_1) →
(__discr : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command) →
((kind tkn : Lean.TSyntax `term) → (stx : Lean.TSyntax `command) → motive (kind, tkn, stx)) → motive __discr |
WithBot.insertBot | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithBot α) |
Finset.preimage_subset | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset β} {t : Finset α}, s ⊆ Finset.map f t → s.preimage ⇑f ⋯ ⊆ t |
Lean.IR.ToIR.BuilderState.mk.inj | Lean.Compiler.IR.ToIR | ∀ {vars : Std.HashMap Lean.FVarId Lean.IR.Arg} {joinPoints : Std.HashMap Lean.FVarId Lean.IR.JoinPointId} {nextId : ℕ}
{vars_1 : Std.HashMap Lean.FVarId Lean.IR.Arg} {joinPoints_1 : Std.HashMap Lean.FVarId Lean.IR.JoinPointId}
{nextId_1 : ℕ},
{ vars := vars, joinPoints := joinPoints, nextId := nextId } =
{ vars := vars_1, joinPoints := joinPoints_1, nextId := nextId_1 } →
vars = vars_1 ∧ joinPoints = joinPoints_1 ∧ nextId = nextId_1 |
Algebra.semiringToRing._proof_1 | Mathlib.Algebra.Algebra.Basic | ∀ {A : Type u_1} (R : Type u_2) [inst : CommRing R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (z : ℕ),
(algebraMap R A) ↑↑z = ↑z |
BoundedContinuousFunction.natCast_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : PseudoMetricSpace β] [inst_2 : NatCast β] (n : ℕ)
(x : α), ↑n x = ↑n |
CategoryTheory.Functor.IsStronglyCocartesian.map_isHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsStronglyCocartesian f φ]
{S' : 𝒮} {b' : 𝒳} {g : S ⟶ S'} {f' : R ⟶ S'} (hf' : f' = CategoryTheory.CategoryStruct.comp f g) (φ' : a ⟶ b')
[inst_3 : p.IsHomLift f' φ'], p.IsHomLift g (CategoryTheory.Functor.IsStronglyCocartesian.map p f φ hf' φ') |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.elim | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{motive : Mathlib.Meta.Finset.ProveEmptyOrConsResult s → Sort u} →
(t : Mathlib.Meta.Finset.ProveEmptyOrConsResult s) →
t.ctorIdx = 0 → ((pf : Q(«$s» = ∅)) → motive (Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf)) → motive t |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Basic.0.ExteriorAlgebra.map_injective.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_3} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (motive : (∃ g, g ∘ₗ f = LinearMap.id) → Prop)
(hf : ∃ g, g ∘ₗ f = LinearMap.id), (∀ (w : N →ₗ[R] M) (hgf : w ∘ₗ f = LinearMap.id), motive ⋯) → motive hf |
_private.Lean.Meta.Coe.0.Lean.Meta.coerceSimple?.match_1 | Lean.Meta.Coe | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((result : Lean.Expr) → (snd : List Lean.Name) → motive (Lean.LOption.some (result, snd))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift |
AddActionSemiHomClass.mk | Mathlib.GroupTheory.GroupAction.Hom | ∀ {F : Type u_8} {M : outParam (Type u_9)} {N : outParam (Type u_10)} {φ : outParam (M → N)} {X : outParam (Type u_11)}
{Y : outParam (Type u_12)} [inst : VAdd M X] [inst_1 : VAdd N Y] [inst_2 : FunLike F X Y],
(∀ (f : F) (c : M) (x : X), f (c +ᵥ x) = φ c +ᵥ f x) → AddActionSemiHomClass F φ X Y |
Filter.smul.instNeBot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot], (f • g).NeBot |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_3 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), Module.Finite ℝ (WithLp 2 (Fin d → ℝ)) |
Asymptotics.SuperpolynomialDecay.add | Mathlib.Analysis.Asymptotics.SuperpolynomialDecay | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f g : α → β} [inst : TopologicalSpace β] [inst_1 : CommSemiring β]
[ContinuousAdd β],
Asymptotics.SuperpolynomialDecay l k f →
Asymptotics.SuperpolynomialDecay l k g → Asymptotics.SuperpolynomialDecay l k (f + g) |
Subgroup.quotientiInfSubgroupOfEmbedding._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (i : ι), iInf f ≤ f i |
EMetric.ball_disjoint | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
ε₁ + ε₂ ≤ edist x y → Disjoint (Metric.eball x ε₁) (Metric.eball y ε₂) |
_private.Init.Data.Order.Lemmas.0.Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax._simp_1 | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : Max α] [inst_1 : LE α] [Std.LawfulOrderSup α] {a b c : α}, (a ⊔ b ≤ c) = (a ≤ c ∧ b ≤ c) |
le_mul_of_one_le_left' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α] [MulRightMono α] {a b : α}, 1 ≤ b → a ≤ b * a |
Std.LawfulEqOrd.compare_eq_iff_eq._simp_1 | Init.Data.Order.Ord | ∀ {α : Type u} [inst : Ord α] [Std.LawfulEqOrd α] {a b : α}, (compare a b = Ordering.eq) = (a = b) |
Std.HashSet.Raw.WF.casesOn | Std.Data.HashSet.Raw | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{m : Std.HashSet.Raw α} → {motive : m.WF → Sort u_1} → (t : m.WF) → ((out : m.inner.WF) → motive ⋯) → motive t |
_private.Mathlib.Tactic.Simproc.ExistsAndEq.0.ExistsAndEq.withNestedExistsElim.match_1 | Mathlib.Tactic.Simproc.ExistsAndEq | (motive : List ExistsAndEq.VarQ → Sort u_1) →
(exs : List ExistsAndEq.VarQ) →
(Unit → motive []) →
((u : Lean.Level) → (β : Q(Sort u)) → (b : Q(«$β»)) → (tl : List ExistsAndEq.VarQ) → motive (⟨u, ⟨β, b⟩⟩ :: tl)) →
motive exs |
Configuration.HasPoints.lineCount_eq_pointCount | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasPoints P L] [inst_2 : Fintype P]
[inst_3 : Fintype L],
Fintype.card P = Fintype.card L →
∀ {p : P} {l : L}, p ∉ l → Configuration.lineCount L p = Configuration.pointCount P l |
Set.FiniteExhaustion._sizeOf_inst | Mathlib.Data.Set.FiniteExhaustion | {α : Type u_1} → (s : Set α) → [SizeOf α] → [(a : α) → SizeOf (s a)] → SizeOf s.FiniteExhaustion |
IntermediateField.induction_on_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E]
(P : IntermediateField F E → Prop),
P ⊥ →
(∀ (K : IntermediateField F E) (x : E), P K → P (IntermediateField.restrictScalars F (↥K)⟮x⟯)) →
∀ (K : IntermediateField F E), P K |
Lean.Sym.UInt16.lt_eq_true | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = true → (a < b) = True |
AddMonoidAlgebra.mapRangeRingHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_1} (M : Type u_2) [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddMonoid M]
(f : R →+* S), Finsupp.mapRange ⇑f ⋯ 1 = 1 |
Std.HashMap.Raw.getKey_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α} (h' : k ∈ m), m.getKey k h' = k |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.