name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.preimage_Ioo | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] {a b : R},
Int.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉ | null | true |
Real.Angle.sign | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → SignType | The sign of a `Real.Angle` is `0` if the angle is `0` or `π`, `1` if the angle is strictly
between `0` and `π` and `-1` is the angle is strictly between `-π` and `0`. It is defined as the
sign of the sine of the angle. | true |
Lean.ScopedEnvExtension.Descr._sizeOf_1 | Lean.ScopedEnvExtension | {α β σ : Type} → [SizeOf α] → [SizeOf β] → [SizeOf σ] → Lean.ScopedEnvExtension.Descr α β σ → ℕ | null | false |
continuousOn_const_smul_iff₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {β : Type u_3} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀]
[inst_2 : MulAction G₀ α] [ContinuousConstSMul G₀ α] [inst_4 : TopologicalSpace β] {f : β → α} {c : G₀} {s : Set β},
c ≠ 0 → (ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s) | null | true |
PointedCone.isFaceOf_comap_iff | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C F : PointedCone R M} [inst_5 : AddCommGroup N]
[inst_6 : Module R N] {f : N →ₗ[R] M},
Function.Surjective ⇑f → ((PointedCone.comap f F).IsFaceO... | The comap of a cone `F` under a surjective linear map is a face of the
comap of another cone `F` if and only if `F` is a face of `C`. | true |
DirectLimit.instCommRingOfRingHomClass | Mathlib.Algebra.Colimit.DirectLimit | {ι : Type u_2} →
[inst : Preorder ι] →
{G : ι → Type u_3} →
{T : ⦃i j : ι⦄ → i ≤ j → Type u_6} →
{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)] →
... | null | true |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False | null | false |
NormedGroup.toGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → [self : NormedGroup E] → Group E | null | true |
Derivation.compAEval_eq | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (a : A)
(d : Derivation R A M) (f : Polynomial R), (d.compAEval a) f = Polynomial.derivative f... | A form of the chain rule: if `f` is a polynomial over `R`
and `d : A → M` is an `R`-derivation then for all `a : A` we have
$$ d(f(a)) = f' (a) d a. $$
The equation is in the `R[X]`-module `Module.AEval R M a`.
For the same equation in `M`, see `Derivation.compAEval_eq`.
| true |
IsPicardLindelof.mk | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E → E} {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E}
{a r L K : NNReal},
(∀ t ∈ Set.Icc tmin tmax, LipschitzOnWith K (f t) (Metric.closedBall x₀ ↑a)) →
(∀ x ∈ Metric.closedBall x₀ ↑a, ContinuousOn (fun x_1 => f x_1 x) (Set.Icc tmin tmax)) →
(∀... | null | true |
_private.Mathlib.Tactic.Relation.Symm.0.Lean.Expr.relSidesIfSymm?.match_6 | Mathlib.Tactic.Relation.Symm | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 rhs : Lean.Expr) → motive (some (fst, lhs, fst_1, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
RingQuot.instMonoidWithZero._proof_7 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), 0 * a = 0 | null | false |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_6 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | null | true |
Ring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {R : Type u} → R → (R → R → R) → R → ℕ → R | null | false |
Matrix.mulAction._proof_2 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} {α : Type u_3} [inst : Monoid R] [inst_1 : MulAction R α]
(b : Matrix m n α), 1 • b = b | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.mem_shadow_iterate_iff_exists_card._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} [inst : DecidableEq α],
(s.card = n + 1) = ∃ a t, a ∉ t ∧ insert a t = s ∧ t.card = n | null | false |
SeparationQuotient.instAddGroup._proof_5 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
(a : SeparationQuotient G), -a + a = 0 | null | false |
CategoryTheory.ComposableArrows.instIsIsoOfNatNatTwoδ₁Toδ₀ | Mathlib.CategoryTheory.ComposableArrows.Two | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i j k : C} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) [CategoryTheory.IsIso f],
CategoryTheory.IsIso (CategoryTheory.ComposableArrows.twoδ₁Toδ₀ f g fg h) | null | true |
Lean.Grind.CommRing.Poly.mulC_nc.go._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | false |
CategoryTheory.Limits.MulticospanIndex.sections.property | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)}
(self : I.sections) (r : J.R),
(CategoryTheory.ConcreteCategory.hom (I.fst r)) (self.val (J.fst r)) =
(CategoryTheory.ConcreteCategory.hom (I.snd r)) (self.val (J.snd r)) | null | true |
PrimeMultiset.coe_coePNatMonoidHom | Mathlib.Data.PNat.Factors | ⇑PrimeMultiset.coePNatMonoidHom = PrimeMultiset.toPNatMultiset | null | true |
Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {M : Submodule R S},
M.LinearDisjoint M → ∀ [Module.Flat R ↥M], (∀ (m n : ↥M), Commute ↑m ↑n) → Module.rank R ↥M ≤ 1 | If `M` and itself are linearly disjoint, if `M` is flat,
if any two elements of `M` are commutative, then the rank of `M` is at most one. | true |
WithLp.fstₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.fstₗ p 𝕜 α β) x = x.fst | null | true |
LindelofSpace | Mathlib.Topology.Compactness.Lindelof | (X : Type u_2) → [TopologicalSpace X] → Prop | X is a Lindelöf space iff every open cover has a countable subcover. | true |
chudnovskySum._proof_1 | Mathlib.Analysis.Real.Pi.Chudnovsky | (11 + 1).AtLeastTwo | null | false |
Finset.prod_ite_index | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s t : Finset ι) (f : ι → M),
∏ x ∈ if p then s else t, f x = if p then ∏ x ∈ s, f x else ∏ x ∈ t, f x | null | true |
Nat.strongRec._unsafe_rec | Batteries.Data.Nat.Basic | {motive : ℕ → Sort u_1} → ((n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) → (t : ℕ) → motive t | null | false |
CategoryTheory.Cokleisli.Adjunction.adj._proof_6 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C)
{X : CategoryTheory.Cokleisli U} {Y x : C} (f : (CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).obj X ⟶ Y)
(g : Y ⟶ x),
{ toFun := fun f => { of := f }, invFun := fun f => f.of, left_inv := ⋯, right_inv := ⋯ }
... | null | false |
BesselPotentialSpace.ext | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
{f g ... | null | true |
WithBot.instMonoidWithZero.match_1 | Mathlib.Algebra.Order.Ring.WithTop | {α : Type u_1} →
(motive : WithBot α → ℕ → Sort u_2) →
(a : WithBot α) →
(n : ℕ) →
((a : α) → (n : ℕ) → motive (some a) n) → (Unit → motive none 0) → ((_n : ℕ) → motive none _n.succ) → motive a n | null | false |
OrderedFinpartition.partSize_pos | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (self : OrderedFinpartition n) (m : Fin self.length), 0 < self.partSize m | null | true |
univLE_iff_exists_embedding | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} ↔ Nonempty (Ordinal.{u} ↪ Ordinal.{v}) | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.LinearMap.linearIndependent_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a ⊥ = True | null | false |
HomotopicalAlgebra.PrepathObject.map_P | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.PrepathObject X) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D), (P.map F).P = F.obj P.P | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition._simp_1_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ | null | false |
SSet.Truncated.Path₁.ext_iff | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet.Truncated 1} {n : ℕ} {x y : X.Path₁ n}, x = y ↔ x.vertex = y.vertex ∧ x.arrow = y.arrow | null | true |
LinearMap.norm_map_iff_inner_map_map | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{E' : Type u_4} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] {F : Type u_5}
[inst_5 : FunLike F E E'] [LinearMapClass F 𝕜 E E'] (f : F),
(∀ (x : E), ‖f x‖ = ‖x‖) ↔ ... | A linear map is an isometry if and it preserves the inner product. | true |
Graph.Compatible.edgeSet_inf | Mathlib.Combinatorics.Graph.Lattice | ∀ {α : Type u_1} {β : Type u_2} {G H : Graph α β}, G.Compatible H → (G ⊓ H).edgeSet = G.edgeSet ∩ H.edgeSet | null | true |
CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_obj_obj_obj | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {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] [inst_2 : CategoryTheory.Precoherent C] (A : Type u_3)
[inst_3 : CategoryTheory.Category.{v_3, u_3} A] (e : C ≌ D)
(X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A) (X_1 : C... | null | true |
Finset.card_inter_smul | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B).card = A.convolution B⁻¹ x | null | true |
Submodule.torsionBySet_isTorsionBySet | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R (↥(Submodule.torsionBySet R M s)) s | null | true |
CategoryTheory.AddMon.monMonoidal._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X₁ X₂ : CategoryTheory.AddMon C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂)... | null | false |
Filter.Eventually.and_frequently | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∃ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x | null | true |
LatticeHom.fst | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) α | Natural projection homomorphism from `α × β` to `α`. | true |
Function.dcomp_def | Mathlib.Logic.Function.Defs | ∀ {ι : Sort u_3} {β : ι → Sort u_1} {φ : {i : ι} → β i → Sort u_2} (f : {i : ι} → (y : β i) → φ y) (g : (i : ι) → β i),
f ∘' g = fun i => f (g i) | null | true |
PseudoMetric._sizeOf_inst | Mathlib.Topology.MetricSpace.BundledFun | (X : Type u_1) →
(R : Type u_2) →
{inst : Zero R} → {inst_1 : Add R} → {inst_2 : LE R} → [SizeOf X] → [SizeOf R] → SizeOf (PseudoMetric X R) | null | false |
Lean.Meta.Grind.instBEqEMatchTheoremKind.beq | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheoremKind → Lean.Meta.Grind.EMatchTheoremKind → Bool | null | true |
PUnit.commGroup.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.commGroup =
{ one := PUnit.unit, mul := fun x x_1 => PUnit.unit, mul_assoc := PUnit.commGroup._proof_7,
one_mul := PUnit.commGroup._proof_8, mul_one := PUnit.commGroup._proof_9, npow_zero := PUnit.commGroup._proof_1,
npow_succ := PUnit.commGroup._proof_2, inv := fun x => PUnit.unit, div_eq_mul_inv := PU... | null | true |
Vector.mapFinIdxM._proof_7 | Init.Data.Vector.Basic | ∀ {n : ℕ}, 0 = n - n | null | false |
Nat.div2_bit1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), (2 * n + 1).div2 = n | null | true |
TotalComplexShape.symm.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_2} →
{I₂ : Type u_1} → (motive : I₂ × I₁ → Sort u_3) → (x : I₂ × I₁) → ((i₂ : I₂) → (i₁ : I₁) → motive (i₂, i₁)) → motive x | null | false |
Batteries.PairingHeap.deleteMin | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → Batteries.PairingHeap α le → Option (α × Batteries.PairingHeap α le) | Amortized `O(log n)`. Remove and return the minimum element from the heap. | true |
PProd | Init.Prelude | Sort u → Sort v → Sort (max (max 1 u) v) | A product type in which the types may be propositions, usually written `α ×' β`.
This type is primarily used internally and as an implementation detail of proof automation. It is
rarely useful in hand-written code.
Conventions for notations in identifiers:
* The recommended spelling of `×'` in identifiers is `PPro... | true |
TrivSqZeroExt.addGroup | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → [AddGroup R] → [AddGroup M] → AddGroup (TrivSqZeroExt R M) | null | true |
GroupAlgebra.mul_average_left | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : Invertible ↑(Fintype.card G)] (g : G),
MonoidAlgebra.single g 1 * GroupAlgebra.average k G = GroupAlgebra.average k G | `average k G` is invariant under left multiplication by elements of `G`. | true |
Lean.Widget.eraseWidgetSpec | Lean.Widget.Commands | Lean.ParserDescr | null | true |
Quaternion.instDivisionRing._proof_8 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (a : Quaternion R),
a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | null | true |
Semiring.toGrindSemiring._proof_12 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (n : ℕ), OfNat.ofNat (n + 2 + 1) = OfNat.ofNat (n + 2) + 1 | null | false |
HomologicalComplex.homologyπ_extendHomologyIso_inv_assoc | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (K : HomologicalComplex C c) (e : c.Embedding c') {j : ι} {j' : ι'}
(hj' : ... | null | true |
_private.Mathlib.GroupTheory.Nilpotent.0.Group.IsNilpotent.commute_of_orderOf_coprime._simp_1_5 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] {g₁ g₂ : G}, (⁅g₁, g₂⁆ = 1) = Commute g₁ g₂ | null | false |
Lean.LLVM.i1Type | Lean.Compiler.IR.LLVMBindings | (ctx : Lean.LLVM.Context) → BaseIO (Lean.LLVM.LLVMType ctx) | null | true |
Bundle.TotalSpace.mk' | Mathlib.Data.Bundle | {B : Type u_1} → {E : B → Type u_3} → (F : Type u_4) → (x : B) → E x → Bundle.TotalSpace F E | null | true |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.iterate_toEnd_mem_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True | null | false |
IsBaseChange.equiv._proof_2 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S | null | false |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.exists_basis_of_pairing_eq_zero._simp_1_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M} {s : Set M},
(x ∈ Submodule.span R (insert y s)) = ∃ a, x + a • y ∈ Submodule.span R s | null | false |
List.getElem_getElem_idxsOf._proof_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (h : i < (List.idxsOf x xs).length),
(List.idxsOf x xs)[i] < xs.length | null | false |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | null | false |
Unitization.instNeg | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Neg R] → [Neg A] → Neg (Unitization R A) | null | true |
List.SortedGE.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → List.IsChain (fun x1 x2 => x1 ≥ x2) l | **Alias** of the forward direction of `List.sortedGE_iff_isChain`. | true |
Mathlib.Tactic.BicategoryLike.MonadMor₁.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{id₁M : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{id₁M' : Mathlib.Tactic.BicategoryL... | null | false |
HomologicalComplex.instHasColimitDiscreteWalkingPairCompPairEval | Mathlib.Algebra.Homology.HomologicalComplexBiprod | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K L : HomologicalComplex C c)
[∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (L.X i)] (i : ι),
CategoryTheory.Limits.HasColimit ((CategoryTheory.Limits.pair K L... | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferConstType | Lean.Meta.InferType | Lean.Name → List Lean.Level → Lean.MetaM Lean.Expr | null | true |
_private.Mathlib.Order.Setoid.Partition.0.Setoid.rel_iff_exists_classes.match_1_1 | Mathlib.Order.Setoid.Partition | ∀ {α : Type u_1} (r : Setoid α) {x y : α} (motive : (∃ c ∈ r.classes, x ∈ c ∧ y ∈ c) → Prop)
(x_1 : ∃ c ∈ r.classes, x ∈ c ∧ y ∈ c),
(∀ (c : Set α) (z : α) (hz : c = {x | r x z}) (hx : x ∈ c) (hy : y ∈ c), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Endofunctor.Coalgebra.ctorIdx | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C C} → CategoryTheory.Endofunctor.Coalgebra F → ℕ | null | false |
convexHull.eq_1 | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], convexHull 𝕜 = ClosureOperator.ofCompletePred (Convex 𝕜) ⋯ | null | true |
_private.Lean.Meta.TryThis.0.Lean.Meta.Tactic.TryThis.Suggestion.processEdit.match_1 | Lean.Meta.TryThis | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((indent column : ℕ) → motive (indent, column)) → motive x | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_eq_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ},
(∃ k',
k ≤ k' ∧
k' ≤ stackPos ∧ String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1)) →
∀ (k' : ℕ), k ≤ k' → ¬k < k' → ¬k = k' → False | null | false |
CategoryTheory.Over.fst_left | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
{R S : CategoryTheory.Over X},
CategoryTheory.Over.Hom.left (CategoryTheory.SemiCartesianMonoidalCategory.fst R S) =
CategoryTheory.Limits.pullback.fst R.hom S.hom | null | true |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.Finset.aemeasurable_sum.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {ι : Type u_1} {α : Type u_3} {f : ι → α → M} (s : Finset ι) (_g : α → M)
(motive : (∃ a ∈ s.val, f a = _g) → Prop) (x : ∃ a ∈ s.val, f a = _g),
(∀ (_i : ι) (hi : _i ∈ s.val) (hg : f _i = _g), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.inr_comp_pushoutComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : X ⟶ Y) (g : X ⟶ Z)
[inst_2 : CategoryTheory.Limits.HasPushout f g] [inst_3 : CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
{Z_1 : D} (h : G... | null | true |
CommRingCat.Under.tensorProductFan' | Mathlib.Algebra.Category.Ring.Under.Limits | {R : CommRingCat} →
(S : CommRingCat) →
[inst : Algebra ↑R ↑S] →
{ι : Type u} →
(P : ι → CategoryTheory.Under R) →
CategoryTheory.Limits.Fan fun i => S.mkUnder (TensorProduct ↑R ↑S ↑(P i).right) | The fan on `i ↦ S ⊗[R] P i` given by `∀ i, S ⊗[R] P i` | true |
Std.TreeMap.contains_iff_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α}, t.contains k = true ↔ k ∈ t | null | true |
Pi.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Mathlib.Tactic.LinearCombination.expandLinearCombo._unsafe_rec | Mathlib.Tactic.LinearCombination | Option Lean.Expr → Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.LinearCombination.Expanded | null | false |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.A_c_eq_zero | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} {A : FixedDetMatrix (Fin 2) ℤ m}, ↑A 1 0 = 0 → ↑A 0 0 * ↑A 1 1 = m | null | true |
Lean.Doc.DeferredCheckSite.decl.inj | Lean.DocString.DeferredCheck | ∀ {name name_1 : Lean.Name},
Lean.Doc.DeferredCheckSite.decl name = Lean.Doc.DeferredCheckSite.decl name_1 → name = name_1 | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift_self | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (h : D.IsTerminal e),
h.lift ⋯ = CategoryTheory.CategoryStruct.id e | null | true |
Lean.Elab.ConfigEval.EvalConfigItem.evalSetOptions | Lean.Elab.ConfigEval.Extra | Lean.Name → Lean.Options → Lean.Elab.ConfigEval.ConfigItem → Lean.Elab.TermElabM Lean.Options | Uses global option declarations with the prefix `optionPrefix` when setting `Options`.
Assumes that `item` is shifted, with the rest of the item being the option name suffix to use.
| true |
Lean.Meta.Simp.Methods.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {pre post : Lean.Meta.Simp.Simproc} {dpre dpost : Lean.Meta.Simp.DSimproc}
{discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge : Bool}
{pre_1 post_1 : Lean.Meta.Simp.Simproc} {dpre_1 dpost_1 : Lean.Meta.Simp.DSimproc}
{discharge?_1 : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)... | null | true |
Lean.ReducibilityHints.opaque.sizeOf_spec | Lean.Declaration | sizeOf Lean.ReducibilityHints.opaque = 1 | null | true |
Std.Time.Modifier.z.noConfusion | Std.Time.Format.Modifier | {P : Sort u} →
{presentation presentation' : Std.Time.ZoneName} →
Std.Time.Modifier.z presentation = Std.Time.Modifier.z presentation' → (presentation = presentation' → P) → P | null | false |
CategoryTheory.equivSmallModel._proof_1 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.EssentiallySmall.{u_1, u_3, u_2} C], Nonempty (C ≌ Classical.choose ⋯) | null | false |
Polynomial.revAt_le | Mathlib.Algebra.Polynomial.Reverse | ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termY₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | null | true |
MvPowerSeries.truncTotalAlgHom._proof_4 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ (σ : Type u_1) (R : Type u_2) [inst : Finite σ] [inst_1 : CommRing R] (n : ℕ) (x x_1 : MvPowerSeries σ R),
(Ideal.Quotient.mk (MvPolynomial.idealOfVars σ R ^ n)) ((MvPowerSeries.truncTotal n) (x + x_1)) =
(Ideal.Quotient.mk (MvPolynomial.idealOfVars σ R ^ n)) ((MvPowerSeries.truncTotal n) x) +
(Ideal.Quot... | null | false |
AddEquiv.strictMono_subsemigroupCongr | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddCommMonoid G] [inst_1 : Preorder G] {S T : AddSubsemigroup G} (h : S = T),
StrictMono ⇑(AddEquiv.subsemigroupCongr h) | null | true |
IsEmpty.oriented._proof_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], 1 ≠ 0 | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.