name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.TransformStep.toStep | Lean.Meta.Tactic.Simp.Types | Lean.TransformStep → Lean.Meta.Simp.Step | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnKey✝ → Sort u} →
((indName : Lean.Name) →
(ctors : Array Lean.Name) →
(isPrivate : Bool) → motive { indName := indName, ctors := ctors, isPrivate := isPrivate }) →
(t : Lean.Meta.SparseCasesOnKey✝¹) → motive t | false |
_private.Mathlib.Algebra.Order.Monovary.0.monovary_iff_forall_smul_nonneg._simp_1_2 | Mathlib.Algebra.Order.Monovary | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | false |
Lean.Parser.many1.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | true |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_one_lt._simp_1_2 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ b ≥ a, b ∈ s | false |
ConvexOn.monotoneOn_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, ConvexOn ℝ S f → (∀ x ∈ S, DifferentiableAt ℝ f x) → MonotoneOn (deriv f) S | true |
Std.DTreeMap.minKey!_insertIfNew_of_isEmpty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey! = k | true |
Algebra.TensorProduct.tensorQuotientEquiv._proof_9 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ (S : Type u_1) [inst : CommRing S], RingHomCompTriple (RingHom.id S) (RingHom.id S) (RingHom.id S) | false |
Submodule.Quotient.addCommGroup._proof_3 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
(a b c : M ⧸ p), a + b + c = a + (b + c) | false |
CategoryTheory.StructuredArrow.map₂_obj_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Fun... | true |
Aesop.Goal.setMVars | Aesop.Tree.Data | Aesop.UnorderedArraySet Lean.MVarId → Aesop.Goal → Aesop.Goal | true |
Positive.addRightCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddRightCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsRightCancelAdd { x // 0 < x } | false |
Lean.Meta.Grind.Goal | Lean.Meta.Tactic.Grind.Types | Type | true |
Std.TreeSet.Raw.compare_get?_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, Option.all (fun x => decide (cmp x k = Ordering.eq)) (t.get? k) = true | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.map_mul._simp_1_3 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.bullet.go | Lean.DocString.Parser | List Lean.Doc.Parser.UnorderedListType → Lean.Parser.ParserFn | true |
MeasureTheory.le_eLpNorm_of_bddBelow | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {F : Type u_3} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F],
p ≠ 0 →
p ≠ ⊤ →
∀ {f : α → F} (C : NNReal) {s : Set α},
MeasurableSet s → (∀ᵐ (x : α) ∂μ, x ∈ s → C ≤ ‖f x‖₊) → C • μ s ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ | true |
groupHomology.boundaries₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u, u, u} k G) → Submodule k (G × G →₀ ↑A) | true |
Asymptotics.IsLittleOTVS.fun_add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g ... | true |
AddMonoidHom.independent_range_of_coprime_order | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → Type u_3} [inst_1 : (i : ι) → AddGroup (H i)]
(ϕ : (i : ι) → H i →+ G),
(Pairwise fun i j => ∀ (x : H i) (y : H j), AddCommute ((ϕ i) x) ((ϕ j) y)) →
∀ [Finite ι] [inst_3 : (i : ι) → Fintype (H i)],
(Pairwise fun i j => (Fintype.card (H i)).Copr... | true |
LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] {g : G},
({x | g ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2) ↔ Nonempty (G ≃+o ℤ) | true |
ContinuousLinearMap.toSpanSingletonLE._proof_2 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] [inst_4 : TopologicalSpace R] [inst_5 : ContinuousSMul R M] (x : M),
(fun f => f 1) (ContinuousLinearMap.toSpanSingleton R x) = x | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.AffineSubspace.mem_direction_iff_eq_vsub_left.match_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_1} {P : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P} (v : V) (motive : v ∈ (fun x => p -ᵥ x) '' ↑s → Prop)
(x : v ∈ (fun x => p -ᵥ x) '' ↑s), (∀ (p₂ : P) (hp₂ : p₂ ∈ ↑s) (hv : (fun x => p -ᵥ x) p₂ = v... | false |
Set.Icc.convexCombo | Mathlib.Topology.UnitInterval | {a b : ℝ} → ↑(Set.Icc a b) → ↑(Set.Icc a b) → ↑unitInterval → ↑(Set.Icc a b) | true |
Digraph.sdiff_adj | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_2} (x y : Digraph V) (v w : V), (x \ y).Adj v w ↔ x.Adj v w ∧ ¬y.Adj v w | true |
smul_add | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • (b₁ + b₂) = a • b₁ + a • b₂ | true |
HomotopicalAlgebra.LeftHomotopyRel.rightHomotopy._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
{f g : X ⟶ Y} [inst_2 : HomotopicalAlgebra.IsCofibrant X] (h : HomotopicalAlgebra.LeftHomotopyRel f g)
(Q : HomotopicalAlgebra.PathObject Y) [inst_3 : Q.IsGood] (h_1 : ⋯.choose.LeftHomotopy f g) (h... | false |
Lean.IR.SimpleGroundExpr.recOn | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.IR.SimpleGroundExpr → Sort u} →
(t : Lean.IR.SimpleGroundExpr) →
((cidx : ℕ) →
(objArgs : Array Lean.IR.SimpleGroundArg) →
(usizeArgs : Array USize) →
(scalarArgs : Array UInt8) → motive (Lean.IR.SimpleGroundExpr.ctor cidx objArgs usizeArgs scalarArgs)) →
((data ... | false |
PNat.caseStrongInductionOn | Mathlib.Data.PNat.Basic | {p : ℕ+ → Sort u_1} → (a : ℕ+) → p 1 → ((n : ℕ+) → ((m : ℕ+) → m ≤ n → p m) → p (n + 1)) → p a | true |
Std.DTreeMap.Internal.Impl.View.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{size : ℕ} → (k : α) → β k → Std.DTreeMap.Internal.Impl.Tree α β size → Std.DTreeMap.Internal.Impl.View α β size | false |
Function.not_lt_argmin | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] [inst_2 : Nonempty α] (a : α),
¬f a < f (Function.argmin f) | true |
Ordinal.le_nfp | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (a : Ordinal.{u_1}), a ≤ Ordinal.nfp f a | true |
Finset.product_disjUnion | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : Disjoint t t'),
s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') ⋯ | true |
_private.Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber.0.CircleDeg1Lift.coe_pow.match_1_1 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Bundle.zeroSection_snd | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → Zero (E x)] (x : B),
(Bundle.zeroSection F E x).snd = 0 | true |
Std.ExtDTreeMap.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {l : List α} {k : α},
k ∈ t → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey! k = t.getKey! k | true |
MeasureTheory.measurePreserving_prod_div_swap | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [MeasurableMul₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] [MeasurableInv G] [μ.IsMulRightInvariant],
MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) | true |
Lean.RBNode.WellFormed.recOn | Lean.Data.RBMap | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}
{motive : (a : Lean.RBNode α β) → Lean.RBNode.WellFormed cmp a → Prop} {a : Lean.RBNode α β}
(t : Lean.RBNode.WellFormed cmp a),
motive Lean.RBNode.leaf ⋯ →
(∀ {n n' : Lean.RBNode α β} {k : α} {v : β k} (a : Lean.RBNode.WellFormed cmp n)
(a_1 : ... | false |
Nat.Subtype.orderIsoOfNat | Mathlib.Order.OrderIsoNat | (s : Set ℕ) → [Infinite ↑s] → ℕ ≃o ↑s | true |
_private.Mathlib.Algebra.MvPolynomial.Rename.0.MvPolynomial.killCompl_map._simp_1_1 | Mathlib.Algebra.MvPolynomial.Rename | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ⇑f = ⇑↑f | false |
CompleteSublattice.mem_sSup | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {𝒮 : Set ↥L} {x : X}, x ∈ sSup 𝒮 ↔ ∃ T ∈ 𝒮, x ∈ T | true |
Multiset.coe_attach | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).attach = ↑l.attach | true |
_private.Mathlib.Tactic.HigherOrder.0.Tactic.mkHigherOrderType._sparseCasesOn_1 | Mathlib.Tactic.HigherOrder | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
SemilinearIsometryEquivClass.mk | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {𝓕 : Type u_11} {R : outParam (Type u_12)} {R₂ : outParam (Type u_13)} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : outParam (R →+* R₂)} {σ₂₁ : outParam (R₂ →+* R)} [inst_2 : RingHomInvPair σ₁₂ σ₂₁]
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] {E : outParam (Type u_14)} {E₂ : outParam (Type u_15)}
[inst_4 : Seminorm... | true |
StieltjesFunction.measure_univ | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] [Nonempty R] {l u : ℝ},
Filter.Tendsto (↑f) ... | true |
Lean.ParseImports.keyword | Lean.Elab.ParseImportsFast | String → Lean.ParseImports.Parser | true |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
CategoryTheory.CategoryStruct.id X.obj₁ | true |
Preorder.frestrictLe₂.congr_simp | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a b : α} (hab : a ≤ b)
(f f_1 : (i : ↥(Finset.Iic b)) → π ↑i),
f = f_1 → ∀ (i : ↥(Finset.Iic a)), Preorder.frestrictLe₂ hab f i = Preorder.frestrictLe₂ hab f_1 i | true |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory.0.CategoryTheory.Functor.cartesianMonoidalCategory._simp_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z),
(CategoryTheory.CategoryStruct.comp f g.hom = CategoryTheory.CategoryStruct.comp f' g.hom) = (f = f') | false |
Matroid.uniqueBaseOn_restrict | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I : Set α},
I ⊆ E → ∀ (R : Set α), (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R | true |
FirstOrder.Language.Term.realize_var | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} (v : α → M) (k : α),
FirstOrder.Language.Term.realize v (FirstOrder.Language.var k) = v k | true |
GromovHausdorff.instInhabitedGHSpace._proof_2 | Mathlib.Topology.MetricSpace.GromovHausdorff | {0}.Nonempty | false |
Substring.Raw.ValidFor.dropWhile | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (p : Char → Bool) {s : Substring.Raw},
Substring.Raw.ValidFor l m r s →
Substring.Raw.ValidFor (l ++ List.takeWhile p m) (List.dropWhile p m) r (s.dropWhile p) | true |
CategoryTheory.GrothendieckTopology.plusMap_toPlus | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functo... | true |
ZMod.eq_one_or_isUnit_sub_one | Mathlib.FieldTheory.Finite.Basic | ∀ {n p k : ℕ} [Fact (Nat.Prime p)], n = p ^ k → ∀ (a : ZMod n), (orderOf a).Coprime n → a = 1 ∨ IsUnit (a - 1) | true |
Lean.Compiler.LCNF.SpecEntry.alreadySpecialized | Lean.Compiler.LCNF.SpecInfo | Lean.Compiler.LCNF.SpecEntry → Bool | true |
NumberField.IsCMField.starRing._proof_2 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x x_1 : K),
(NumberField.IsCMField.complexConj K) (x + x_1) =
(NumberField.IsCMField.complexConj K) x + (NumberField.IsCMField.complexConj K) x_1 | false |
MeasurableSpace.DynkinSystem.ext | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {d₁ d₂ : MeasurableSpace.DynkinSystem α}, (∀ (s : Set α), d₁.Has s ↔ d₂.Has s) → d₁ = d₂ | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox.0.ContinuousMap.dense_setOf_contDiff._simp_1_2 | Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
CategoryTheory.Abelian.PreservesCoimageImageComparison.iso_inv_left | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
... | true |
CategoryTheory.Idempotents.Karoubi.decompId_i_f | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C),
P.decompId_i.f = P.p | true |
_private.Mathlib.Combinatorics.SimpleGraph.VertexCover.0.SimpleGraph.isVertexCover_empty._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u} {G : SimpleGraph V}, (G = ⊥) = ∀ (a b : V), ¬G.Adj a b | false |
CategoryTheory.Limits.yonedaCompLimIsoCocones_inv_app | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor J C) (X : C) (a : F.cocones.obj X),
(CategoryTheory.Limits.yonedaCompLimIsoCocones F).inv.app X a =
(CategoryTheory.Limits.Types.limitEquivSections (F.op.comp (CategoryTheo... | true |
CategoryTheory.ShortComplex.opcyclesMap'_neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.ShortComplex.opcyclesMap' (-φ) h₁ h₂ = -CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h... | true |
Mathlib.Tactic.Monoidal.Context | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Type | true |
toModuleCatFromModuleCatLinearEquiv._proof_3 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_3) {ι : Type u_1} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : ModuleCat (Matrix ι ι R)) (j : ι) (x x_1 : ↑M),
(fun i => ⟨Matrix.single j i 1 • (x + x_1), ⋯⟩) =
(fun i => ⟨Matrix.single j i 1 • x, ⋯⟩) + fun i => ⟨Matrix.single j i 1 • x_1, ⋯⟩ | false |
ContinuousLinearMap.isometry_iff_adjoint_comp_self | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (u : H →L[𝕜] K), Isometry ⇑u ↔ (ContinuousLinearMap.adjoint u)... | true |
_private.Lean.Compiler.IR.EmitUtil.0.Lean.IR.CollectUsedDecls.collectFnBody._sparseCasesOn_4 | Lean.Compiler.IR.EmitUtil | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive_2 (... | false |
Nat.EqResult.false.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (p p_1 : Lean.Expr), (Nat.EqResult.false p = Nat.EqResult.false p_1) = (p = p_1) | true |
OrderDual.instIsLeftCancelAdd | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [h : IsLeftCancelAdd α], IsLeftCancelAdd αᵒᵈ | true |
Int.add | Init.Data.Int.Basic | ℤ → ℤ → ℤ | true |
CategoryTheory.GrothendieckTopology.Cover.instInhabited | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → Inhabited (J.Cover X) | true |
Std.Do.SPred.entails_3._simp_1 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
(P ⊢ₛ Q) = ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down | false |
List.forall₂_reverse_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
List.Forall₂ R l₁.reverse l₂.reverse ↔ List.Forall₂ R l₁ l₂ | true |
Lean.Elab.Tactic.TacticParsedSnapshot.below | Lean.Elab.Term.TermElabM | {motive_1 : Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_3 : Array (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_4 : Lean.Language.SnapshotTask Lean.Elab.Ta... | false |
ENat.iSup_add_iSup_of_monotone | Mathlib.Data.ENat.Lattice | ∀ {ι : Type u_4} [inst : Preorder ι] [IsDirectedOrder ι] {f g : ι → ℕ∞},
Monotone f → Monotone g → iSup f + iSup g = ⨆ a, f a + g a | true |
Aesop.Frontend.Parser.«feature(_)» | Aesop.Frontend.RuleExpr | Lean.ParserDescr | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_4 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Std.ExtTreeSet.get!_min! | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α],
t ≠ ∅ → t.get! t.min! = t.min! | true |
Subgroup.subgroupOf_inj._simp_2 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K : Subgroup G}, (H₁.subgroupOf K = H₂.subgroupOf K) = (H₁ ⊓ K = H₂ ⊓ K) | false |
LinearIsometry.coe_toSpanSingleton | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] {v : E} (hv : ‖v‖ = 1),
(LinearIsometry.toSpanSingleton 𝕜 E hv).toLinearMap = LinearMap.toSpanSingleton 𝕜 E v | true |
HasDerivWithinAt.mono | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜},
HasDerivWithinAt f f' t x → s ⊆ t → HasDerivWithinAt f f' s x | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIoc.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ (α : Type u_1) [inst : Preorder α] {x y : α} (motive : ↑(Set.Ioc x y) → Prop) (x_1 : ↑(Set.Ioc x y)),
(∀ (a : α) (ha : a ∈ Set.Ioc x y), motive ⟨a, ha⟩) → motive x_1 | false |
List.Perm.pairwise_iff | Init.Data.List.Perm | ∀ {α : Type u_1} {R : α → α → Prop},
(∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, l₁.Perm l₂ → (List.Pairwise R l₁ ↔ List.Pairwise R l₂) | true |
Set.Ioo.pos | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Ioo 0 1)), 0 < ↑x | true |
IsFractionRing.algHom_commutes | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_4} [inst : CommRing A] {B : Type u_6} [inst_1 : CommRing B] [inst_2 : Algebra A B] {K₁ : Type u_8}
{K₂ : Type u_9} [inst_3 : Field K₁] [inst_4 : Field K₂] [inst_5 : Algebra A K₁] [inst_6 : Algebra A K₂]
[IsFractionRing A K₁] {L₁ : Type u_10} {L₂ : Type u_11} [inst_8 : Field L₁] [inst_9 : Field L₂]
[... | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M2.branch | Lean.Meta.Tactic.FunInd | {α : Type} → Lean.Tactic.FunInd.M2✝ α → Lean.Tactic.FunInd.M2✝¹ α | true |
OrderIso.smulRight_symm_apply | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : MulAction α β] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β] {a : α} (ha : 0 < a) (b : β),
(RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b | true |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.isMaximal_of_isIntegral_of_isMaximal_comap.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {S : Type u_1} [inst : CommRing S] (I x : Ideal S) (motive : (I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I) → Prop)
(x_1 : I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I),
(∀ (I_le_J : I ≤ x) (x_2 : S) (hxJ : x_2 ∈ x) (hxI : x_2 ∉ I), motive ⋯) → motive x_1 | false |
MultilinearMap.freeFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {ι' : Type u_1} {R : Type u_2} [inst : CommSemiring R], LinearMap.CompatibleSMul (Π₀ (x : ι'), R) (ι' →₀ R) R R | false |
Lean.Elab.Term.mkNoImplicitLambdaAnnotation | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Expr | true |
MeasureTheory.piContent_eq_measure_pi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] [inst : Fintype ι] {s : Set ((i : ι) → X i)},
MeasurableSet s → (MeasureTheory.piContent μ) s = (MeasureTheory.Measure.pi μ) s | true |
Matrix.transpose_eq_natCast | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddMonoidWithOne α] {M : Matrix n n α} {d : ℕ},
M.transpose = ↑d ↔ M = ↑d | true |
Lean.Elab.Do.ContInfo.toContInfoRef | Lean.Elab.Do.Basic | Lean.Elab.Do.ContInfo → Lean.Elab.Do.ContInfoRef | true |
Batteries.UnionFind.recOn | Batteries.Data.UnionFind.Basic | {motive : Batteries.UnionFind → Sort u} →
(t : Batteries.UnionFind) →
((arr : Array Batteries.UFNode) →
(parentD_lt : ∀ {i : ℕ}, i < arr.size → Batteries.UnionFind.parentD arr i < arr.size) →
(rankD_lt :
∀ {i : ℕ},
Batteries.UnionFind.parentD arr i ≠ i →
... | false |
derivationOfSectionOfKerSqZero_apply_coe | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra R S] (f : P →ₐ[R] S) (hf' : RingHom.ker f ^ 2 = ⊥) (g : S →ₐ[R] P)
(hg : f.comp g = AlgHom.id R S) (x : P), ↑((derivationOfSectionOfKerSqZero f hf' g hg) x) = x - g... | true |
Finset.coe_zero | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Zero α], ↑0 = 0 | true |
«term_≃⋆+*_» | Mathlib.Algebra.Star.StarRingHom | Lean.TrailingParserDescr | true |
_private.Mathlib.RingTheory.Smooth.IntegralClosure.0.exists_derivative_mul_eq_and_isIntegral_coeff._simp_1_8 | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | false |
CategoryTheory.CosimplicialObject.augmentOfIsInitial_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {T : C}
(hT : CategoryTheory.Limits.IsInitial T), (X.augmentOfIsInitial hT).right = X | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.