name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.ShortComplex.rightHomologyMap'_op | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
(CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂).op =
CategoryTheory.ShortCompl... | null | true |
Pell.eq_of_xn_modEq_lem1 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) {i n j : ℕ}, i < j → j < n → Pell.xn a1 i % Pell.xn a1 n < Pell.xn a1 j % Pell.xn a1 n | null | true |
Float32.beq_self_iff._simp_1 | Batteries.Data.Float.Lemmas | ∀ {f : Float32}, ((f == f) = true) = (f ≠ Float32.nan) | null | false |
Lean.Elab.Tactic.iterateAtMost._f | Mathlib.Tactic.Core | {m : Type → Type u} →
[Monad m] →
[MonadExcept Lean.Exception m] → (x : ℕ) → Nat.below (motive := fun x => m Unit → m Unit) x → m Unit → m Unit | null | false |
Subgroup.IsComplement.equiv_mul_right | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {K : Subgroup G} {S : Set G} (hSK : Subgroup.IsComplement S ↑K) (g : G) (k : ↥K),
hSK.equiv (g * ↑k) = ((hSK.equiv g).1, (hSK.equiv g).2 * k) | null | true |
Int.Internal.Linear.Poly.mul' | Init.Data.Int.Linear | Int.Internal.Linear.Poly → ℤ → Int.Internal.Linear.Poly | `p.mul k` multiplies all coefficients and constant of the polynomial `p` by `k`.
| true |
HomogeneousLocalization.NumDenSameDeg.den_neg | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : NegMemClass σ A]
{𝒜 : ι → σ} (x : Submonoid A) (c : HomogeneousLocalization.NumDenSameDeg 𝒜 x), ↑(-c).den = ↑c.den | null | true |
exists_lt_of_lt_ciSup₂' | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : ConditionallyCompleteLinearOrderBot α] {a : α}
{f : (i : ι) → κ i → α}, a < ⨆ i, ⨆ j, f i j → ∃ i j, a < f i j | null | true |
_private.Std.Time.Format.DateFormat.0.Std.Time.DateFormat.enUS._proof_1 | Std.Time.Format.DateFormat | 0 ≤ 1 ∧ 1 ≤ 6 | null | false |
CategoryTheory.ShortComplex.Exact.mono_g | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.f = 0 → CategoryTheory.Mono S.g | null | true |
CategoryTheory.Quotient.natTransLift_id | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor (CategoryTheory.Quotient r) D),
CategoryTheory.Quotient.natTransLift r
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Quotient.functor r)... | null | true |
_private.Mathlib.CategoryTheory.Galois.Basic.0.CategoryTheory.PreGaloisCategory.nonempty_fiber_of_isConnected.match_1 | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (X : C)
(motive : Nonempty (CategoryTheory.Limits.IsInitial X) → Prop) (x : Nonempty (CategoryTheory.Limits.IsInitial X)),
(∀ (hin : CategoryTheory.Limits.IsInitial X), motive ⋯) → motive x | null | false |
SchauderBasis.succSub._proof_1 | Mathlib.Analysis.Normed.Module.Bases | ∀ {X : Type u_1} [inst : NormedAddCommGroup X], IsTopologicalAddGroup X | null | false |
asymptoticCone_asymptoticCone | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] (s : ... | null | true |
SymbolicDynamics.FullShift.isOpen_mulOccursInAt | Mathlib.Dynamics.SymbolicDynamics.Basic | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : Inhabited A] {G : Type u_2} [inst_2 : Monoid G]
[IsLeftCancelMul G] [DiscreteTopology A] (p : SymbolicDynamics.FullShift.Pattern A G) (g : G),
IsOpen {x | p.mulOccursInAt x g} | Occurrence sets are open. | true |
isMin_toDual_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] {a : α}, IsMin (OrderDual.toDual a) ↔ IsMax a | null | true |
mul_le_mul_iff_of_pos_right | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosMono α] [MulPosReflectLE α],
0 < a → (b * a ≤ c * a ↔ b ≤ c) | **Alias** of `mul_le_mul_iff_left₀`. | true |
Rat.valuation_le_one_iff_den | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Algebra R ℚ] [inst_3 : IsFractionRing R ℚ]
{𝔭 : IsDedekindDomain.HeightOneSpectrum R} {x : ℚ},
(IsDedekindDomain.HeightOneSpectrum.valuation ℚ 𝔭) x ≤ 1 ↔ ↑x.den ∉ 𝔭.asIdeal | null | true |
ContDiffMapSupportedIn.instAddCommGroup._proof_11 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (a b : ContDiffMapSupportedIn E F n K),
a + b = b + a | null | false |
HomotopicalAlgebra.Precylinder.op._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A : C} (P : HomotopicalAlgebra.Precylinder A),
CategoryTheory.CategoryStruct.comp P.π.op P.i₀.op = CategoryTheory.CategoryStruct.id (Opposite.op A) | null | false |
Int.dvd_sub | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b → a ∣ c → a ∣ b - c | null | true |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.single_eq_same._proof_1_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] {i : ι} {b : β i},
(fun₀ | i => b) i = b | null | false |
CategoryTheory.Comon._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} → [SizeOf C] → CategoryTheory.Comon C → ℕ | null | false |
OrderDual.instBoundedOrder | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → [inst : LE α] → [BoundedOrder α] → BoundedOrder αᵒᵈ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceNeg.declare_48._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4161481366._hygCtx._hyg.26 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Lean.Lsp.instToJsonCreateFile | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.CreateFile | null | true |
AlgebraicGeometry.PresheafedSpace.GlueData.f_invApp_f_app | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C)
(i j k : D.J) (U : TopologicalSpace.Opens ↑↑(D.V (i, j))),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (D.f i j) U)
((D.f i k).c.app
(Opposite.op... | The red and the blue arrows in  commute. | true |
_private.Lean.Elab.ElabRules.0.Lean.Elab.Command.elabElab.match_3 | Lean.Elab.ElabRules | (motive : Array (Lean.TSyntax `stx) × Array Lean.Term → Sort u_1) →
(x : Array (Lean.TSyntax `stx) × Array Lean.Term) →
((stxParts : Array (Lean.TSyntax `stx)) → (patArgs : Array Lean.Term) → motive (stxParts, patArgs)) → motive x | null | false |
MulOpposite.instCommSemiring | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [CommSemiring R] → CommSemiring Rᵐᵒᵖ | null | true |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], BoundedAdd F | null | false |
RootPairing.coxeterWeightIn_eq_zero_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [CharZero R]
[inst_6 : P.IsCrystallographic] (i j : ι) [IsDomain R], P.coxeterWeightIn ℤ i j = 0 ↔ P.pairingIn ℤ... | null | true |
CategoryTheory.Limits.BinaryFan.π_app_left | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (s : CategoryTheory.Limits.BinaryFan X Y),
s.π.app { as := CategoryTheory.Limits.WalkingPair.left } = s.fst | null | true |
Fin.predAbove_right_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [inst : NeZero n] {i : Fin n}, i.predAbove 0 = 0 | null | true |
ContinuousAlternatingMap.map_update_add | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f : M [⋀^ι]→L[R] N) [inst_7 : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),... | null | true |
CategoryTheory.Functor.RightLinear.instIsIsoδᵣ | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_1} {D' : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} D]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] (F : CategoryTheory.Functor D D') {C : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] [inst_3 : CategoryTheory.MonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalCategory.Mo... | null | true |
DirectSum.gsmulHom_apply_apply | Mathlib.Algebra.Module.GradedModule | ∀ {ιA : Type u_1} {ιB : Type u_2} (A : ιA → Type u_3) (M : ιB → Type u_4) [inst : AddMonoid ιA] [inst_1 : VAdd ιA ιB]
[inst_2 : (i : ιA) → AddCommMonoid (A i)] [inst_3 : (i : ιB) → AddCommMonoid (M i)] [inst_4 : GradedMonoid.GMonoid A]
[inst_5 : DirectSum.Gmodule A M] {i : ιA} {j : ιB} (a : A i) (b : M j),
((Dire... | null | true |
AlgebraicGeometry.LocallyRingedSpace.GlueData.noConfusion | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | {P : Sort u} →
{t t' : AlgebraicGeometry.LocallyRingedSpace.GlueData} →
t = t' → AlgebraicGeometry.LocallyRingedSpace.GlueData.noConfusionType P t t' | null | false |
Vector.any_eq_false' | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs : Vector α n}, xs.any p = false ↔ ∀ x ∈ xs, ¬p x = true | Variant of `any_eq_false` in terms of membership rather than an array index. | true |
SubMulAction.stabilizer_of_subMul | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : Group R] [inst_1 : MulAction R M] {p : SubMulAction R M} (m : ↥p),
MulAction.stabilizer R m = MulAction.stabilizer R ↑m | Stabilizers in group SubMulAction coincide with stabilizers in the ambient space | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hamiltonian.0.SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_support_count_tail_eq_one._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsHamiltonianCycle = (p.IsCycle ∧ p.tail.IsHamiltonian) | null | false |
MaxTropical.instCommMonoidOfAddCommMonoid.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : AddCommMonoid R],
MaxTropical.instCommMonoidOfAddCommMonoid = { toMonoid := MaxTropical.instMonoidOfAddMonoid, mul_comm := ⋯ } | null | true |
instCompleteLatticeStructureGroupoid | Mathlib.Geometry.Manifold.StructureGroupoid | {H : Type u_1} → [inst : TopologicalSpace H] → CompleteLattice (StructureGroupoid H) | null | true |
Metric.isClosed_eball_top | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_2} [inst : PseudoEMetricSpace α] {x : α}, IsClosed (Metric.eball x ⊤) | null | true |
CategoryTheory.Functor.preservesInitialObject_of_preservesZeroMorphisms | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : Categ... | Preserving zero morphisms implies preserving terminal objects. | true |
Subfield.topologicalClosure_minimal | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α] (s : Subfield α)
{t : Subfield α}, s ≤ t → IsClosed ↑t → s.topologicalClosure ≤ t | null | true |
_private.Lean.LocalContext.0.Lean.LocalDecl.setType.match_1 | Lean.LocalContext | (motive : Lean.LocalDecl → Lean.Expr → Sort u_1) →
(x : Lean.LocalDecl) →
(x_1 : Lean.Expr) →
((idx : ℕ) →
(id : Lean.FVarId) →
(n : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(k : Lean.LocalDeclKind) → (t : Lean.Expr) → m... | null | false |
FreeAlgebra.algebraMap_inj | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] (x y : R),
(algebraMap R (FreeAlgebra R X)) x = (algebraMap R (FreeAlgebra R X)) y ↔ x = y | null | true |
Mathlib.Tactic.Widget.StringDiagram.AtomNode.mk.injEq | Mathlib.Tactic.Widget.StringDiagram | ∀ (vPos hPosSrc hPosTar : ℕ) (atom : Mathlib.Tactic.BicategoryLike.Atom) (vPos_1 hPosSrc_1 hPosTar_1 : ℕ)
(atom_1 : Mathlib.Tactic.BicategoryLike.Atom),
({ vPos := vPos, hPosSrc := hPosSrc, hPosTar := hPosTar, atom := atom } =
{ vPos := vPos_1, hPosSrc := hPosSrc_1, hPosTar := hPosTar_1, atom := atom_1 }) =
... | null | true |
Rat.mkRat_zero | Init.Data.Rat.Lemmas | ∀ (n : ℤ), mkRat n 0 = 0 | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Basic.0.IsDedekindDomainInv.dimensionLEOne | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDomain A], IsDedekindDomainInv✝ A → Ring.DimensionLEOne A | null | true |
Batteries.CodeAction.TacticCodeActions.onTactic._default | Batteries.CodeAction.Attr | Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction) | null | false |
Lean.IR.EmitLLVM.RefcountKind.noConfusion | Lean.Compiler.IR.EmitLLVM | {P : Sort v✝} → {x y : Lean.IR.EmitLLVM.RefcountKind} → x = y → Lean.IR.EmitLLVM.RefcountKind.noConfusionType P x y | null | false |
Std.ExtHashSet.contains_empty | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {a : α},
∅.contains a = false | null | true |
NonUnitalStarSubalgebra.center | Mathlib.Algebra.Star.NonUnitalSubalgebra | (R : Type u) →
(A : Type v) →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : StarRing A] →
[inst_3 : Module R A] → [IsScalarTower R A A] → [SMulCommClass R A A] → NonUnitalStarSubalgebra R A | The center of a non-unital star algebra is the set of elements which commute with every element.
They form a non-unital star subalgebra. | true |
Int.ediv_le_ediv | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, 0 < c → a ≤ b → a / c ≤ b / c | null | true |
PUnit.vadd.eq_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_1}, PUnit.vadd = { vadd := fun x x_1 => PUnit.unit } | null | true |
Set.EqOn.deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {s : Set 𝕜}, Set.EqOn f g s → IsOpen s → Set.EqOn (deriv f) (deriv g) s | null | true |
CalcPanel.rpc | Mathlib.Tactic.Widget.Calc | CalcParams → Lean.Server.RequestM (Lean.Server.RequestTask ProofWidgets.Html) | Rpc function for the calc widget. | true |
Lean.Widget.instRpcEncodableDiagnosticWith | Lean.Widget.InteractiveDiagnostic | {α : Type} → [Lean.Server.RpcEncodable α] → Lean.Server.RpcEncodable (Lean.Lsp.DiagnosticWith α) | null | true |
unitInterval.mul_le_right | Mathlib.Topology.UnitInterval | ∀ {x y : ↑unitInterval}, x * y ≤ y | null | true |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.valuedCompletion._simp_3 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {α : Type u_1} [inst : LT α] {a b : α}, (↑a < ↑b) = (a < b) | null | false |
CategoryTheory.Functor.totalLeftDerived.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Derives | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
(F F_1 : CategoryTheory.Functor C H) (e_F : F = F_1) (L L_1 : CategoryTheory.Functor C D) (e_L : L = L_1)
(W W_1 : CategoryTh... | null | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux._sparseCasesOn_3 | Mathlib.Tactic.TermCongr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name... | null | false |
_private.Lean.Expr.0.Lean.Expr.getBoundedAppFn.match_1 | Lean.Expr | (motive : ℕ → Lean.Expr → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Expr) →
((maxArgs' : ℕ) → (f arg : Lean.Expr) → motive maxArgs'.succ (f.app arg)) →
((x : ℕ) → (e : Lean.Expr) → motive x e) → motive x x_1 | null | false |
_private.Mathlib.Analysis.Analytic.Linear.0.ContinuousLinearMap.hasFiniteFPowerSeriesOnBall.match_1_6 | Mathlib.Analysis.Analytic.Linear | ∀ (motive : (m : ℕ) → 2 ≤ m → Prop) (m : ℕ) (hm : 2 ≤ m),
(∀ (hm : 2 ≤ 0), motive 0 hm) →
(∀ (hm : 2 ≤ 1), motive 1 hm) → (∀ (n : ℕ) (hm : 2 ≤ n + 2), motive n.succ.succ hm) → motive m hm | null | false |
Finset.attach_eq_empty_iff | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} {s : Finset α}, s.attach = ∅ ↔ s = ∅ | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric.0.CovariantDerivative.IsMetricCompatible._proof_7 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] (i : M),
ContinuousAdd (TangentSpace I i →L[ℝ] ℝ) | null | false |
Preord.hom_id | Mathlib.Order.Category.Preord | ∀ {X : Preord}, Preord.Hom.hom (CategoryTheory.CategoryStruct.id X) = OrderHom.id | null | true |
jacobsonSpace_iff_locallyClosed | Mathlib.Topology.JacobsonSpace | ∀ {X : Type u_1} [inst : TopologicalSpace X],
JacobsonSpace X ↔ ∀ (Z : Set X), Z.Nonempty → IsLocallyClosed Z → (Z ∩ closedPoints X).Nonempty | null | true |
AddEquiv.coprodAssoc_apply_inl_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddMonoid P]
(x : N),
(AddEquiv.coprodAssoc M N P) (AddMonoid.Coprod.inl (AddMonoid.Coprod.inr x)) =
AddMonoid.Coprod.inr (AddMonoid.Coprod.inl x) | null | true |
DMatrix.instAddCommSemigroup._proof_1 | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type u_3} [inst : (i : m) → (j : n) → AddCommSemigroup (α i j)]
(a b : DMatrix m n α), a + b = b + a | null | false |
CochainComplex.mappingCocone.lift_f_snd_v | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
(α : M ⟶ K) (β : CochainComplex.HomComplex.Cochain M L (-1))
(hαβ :
CochainComplex.HomComple... | null | true |
limsup_finset_sup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : ConditionallyCompleteLinearOrder β] [inst_1 : OrderBot β]
{f : Filter α} {F : ι → α → β} {s : Finset ι},
autoParam (∀ i ∈ s, Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f (F i)) limsup_finset_sup._auto_1 →
autoParam (∀ i ∈ s, Filter.IsBoundedUnder (fun x... | null | true |
Lean.instInhabitedAttributeKind.default | Lean.Attributes | Lean.AttributeKind | null | true |
SubAddAction.addConjMap_ofFixingAddSubgroup.match_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | {M : Type u_2} →
{α : Type u_1} →
[inst : AddGroup M] →
[inst_1 : AddAction M α] →
{t : Set α} →
(motive : ↥(SubAddAction.ofFixingAddSubgroup M t) → Sort u_3) →
(x : ↥(SubAddAction.ofFixingAddSubgroup M t)) →
((x : α) → (hx : x ∈ SubAddAction.ofFixingAddSubgroup M... | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem.0.ValueDistribution.isBigO_characteristic_sub_characteristic_moebius._simp_1_5 | Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
SSetPair.homologyπ | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasCoproducts C] →
[inst_2 : CategoryTheory.Preadditive C] →
(P : SSetPair) →
(R : C) → [inst_3 : CategoryTheory.CategoryWithHomology C] → (n : ℕ) → P.right.homology R n ⟶ P.homology R n | Given a pair of simplicial sets corresponding to a monomorphism `i : X ⟶ Y`,
this is the morphism from the homology of `Y` to the relative homology of the pair. | true |
CategoryTheory.CostructuredArrow.instCreatesLimitsOfShapeProjOfIsConnected | Mathlib.CategoryTheory.Limits.Constructions.Over.Connected | {J : Type u'} →
[inst : CategoryTheory.Category.{v', u'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] →
{K : CategoryTheory.Functor C D} →
[CategoryTheory.IsConnected J] →
... | The projection from `CostructuredArrow K B` to `C` creates any connected limit. | true |
CategoryTheory.MorphismProperty.Comma.changeProp._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_3, u_6} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) {P P' : CategoryTheory.MorphismProperty T}
{Q Q' : Category... | null | false |
String.Pos.offset_toSlice | Init.Data.String.Basic | ∀ {s : String} {pos : s.Pos}, pos.toSlice.offset = pos.offset | null | true |
nhdsKer_sInter_subset | Mathlib.Topology.NhdsKer | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set (Set X)}, nhdsKer (⋂₀ s) ⊆ ⋂ x ∈ s, nhdsKer x | null | true |
Lean.Grind.AddCommMonoid.zero_add | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.AddCommMonoid M] (a : M), 0 + a = a | null | true |
_private.Mathlib.Data.Finset.Union.0.Finset.biUnion_subset_iff_forall_subset._proof_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → Finset β},
s.biUnion f ⊆ t ↔ ∀ x ∈ s, f x ⊆ t | null | false |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.List.NodupKeys.eq_1 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {α : Type u} {β : α → Type v} (l : List (Sigma β)), l.NodupKeys = l.keys.Nodup | null | true |
HasDistribNeg.recOn | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
[inst : Mul α] →
{motive : HasDistribNeg α → Sort u} →
(t : HasDistribNeg α) →
([toInvolutiveNeg : InvolutiveNeg α] →
(neg_mul : ∀ (x y : α), -x * y = -(x * y)) →
(mul_neg : ∀ (x y : α), x * -y = -(x * y)) →
motive { toInvolutiveNeg := toInv... | null | false |
IsUniformInducing.comp | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : UniformSpace γ]
{g : β → γ}, IsUniformInducing g → ∀ {f : α → β}, IsUniformInducing f → IsUniformInducing (g ∘ f) | null | true |
Lean.Compiler.LCNF.Simp.Context.mk | Lean.Compiler.LCNF.Simp.SimpM | Lean.Name →
Lean.Compiler.LCNF.Simp.Config → List Lean.Name → Lean.PHashMap Lean.Name ℕ → Lean.Compiler.LCNF.Simp.Context | null | true |
_private.Init.Data.List.Notation.0.Lean.«_aux_Init_Data_List_Notation___macroRules_term[_]_1».expandListLit._unsafe_rec | Init.Data.List.Notation | Lean.Syntax.TSepArray `term "," → ℕ → Bool → Lean.TSyntax `term → Lean.MacroM Lean.Syntax | null | false |
Part.getOrElse_some | Mathlib.Data.Part | ∀ {α : Type u_1} (a d : α) [inst : Decidable (Part.some a).Dom], (Part.some a).getOrElse d = a | null | true |
CategoryTheory.Pairwise.instCategory._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} {X Y : CategoryTheory.Pairwise ι} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f | null | false |
_private.Lean.Compiler.LCNF.Closure.0.Lean.Compiler.LCNF.Closure.collectFVar.match_1 | Lean.Compiler.LCNF.Closure | (motive : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure)) →
((letDecl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → motive (some letDecl)) →
((x : Option (Lean.Compiler.LCNF.Let... | null | false |
Rat.evalRound | Mathlib.Data.Rat.Floor | Mathlib.Meta.NormNum.NormNumExt | `norm_num` extension for `round` | true |
AddCommMonCat.of.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ (M : Type u) [inst : AddCommMonoid M], ↧M = { carrier := M, str := inst } | null | true |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go._unary | Lean.Data.RArray | {α : Type u_1} → {n : ℕ} → (Fin n → α) → (lb : ℕ) ×' (ub : ℕ) ×' (_ : lb < ub) ×' ub ≤ n → Lean.RArray α | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.hasInfoHoleFor | Lean.Elab.Term.TermElabM | Lean.MVarId → Lean.Elab.TermElabM Bool | Returns `true` if the `InfoTree`s produced by the elaboration that is currently being wrapped in an
`Info` node already contain an `InfoTree.hole` for `mvarId`, i.e. if the hole was emitted by a
nested elaboration rather than by the current one.
| true |
Lean.Server.CodeActionResolveData.mk.noConfusion | Lean.Server.CodeActions.Basic | {P : Sort u} →
{params : Lean.Lsp.CodeActionParams} →
{providerName : Lean.Name} →
{providerResultIndex : ℕ} →
{params' : Lean.Lsp.CodeActionParams} →
{providerName' : Lean.Name} →
{providerResultIndex' : ℕ} →
{ params := params, providerName := providerName, prov... | null | false |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.popMax_wf._proof_1_5 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} [inst : Ord α] {heap : Batteries.BinaryHeap α} (h : ¬heap.size = 0),
¬0 < heap.size - 1 → Batteries.BinaryHeap.WF.TopDown (heap.vector.swap 0 (heap.size - 1) ⋯ ⋯).pop | null | false |
CategoryTheory.CoverPreserving.casesOn | Mathlib.CategoryTheory.Sites.CoverPreserving | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
{G : CategoryTheory.Functor C D} →
{motive : C... | null | false |
Representation.trivial | Mathlib.RepresentationTheory.Basic | (k : Type u_1) →
(G : Type u_2) →
(V : Type u_3) →
[inst : Semiring k] →
[inst_1 : Monoid G] → [inst_2 : AddCommMonoid V] → [inst_3 : Module k V] → Representation k G V | The trivial representation of `G` on a `k`-module V.
| true |
Quiver.isStronglyConnected_iff | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_2) [inst : Quiver V], Quiver.IsStronglyConnected V ↔ ∀ (i j : V), Nonempty (Quiver.Path i j) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.