name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WeierstrassCurve.valuation_Δ_aux.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W : WeierstrassCurve K),
WeierstrassCurve.valuation_Δ_aux R W =
if h : WeierstrassCurve.IsIntegral R W then
⟨(IsDedekindDo... | true |
NonUnitalCommCStarAlgebra.rec | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedSpace : NormedSpace ℂ A] →
... | false |
AlgHom.liftOfSurjective._proof_4 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f).IsTwoSided | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_2 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | false |
HDiv.hDiv | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HDiv α β γ] → α → β → γ | true |
Valuation.toMonoidWithZeroHom | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : LinearOrderedCommMonoidWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → R →*₀ Γ₀ | true |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_inst | Lean.Meta.Tactic.Grind.EMatch | SizeOf Lean.Meta.Grind.EMatch.SearchState | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessReorder.visit._sparseCasesOn_11 | Mathlib.Tactic.Translate.Reorder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuse_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Tactic.Tactic | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) →
motive Lean.Elab.ComputeKind.noncomputable → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_85 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
MeasureTheory.Measure.addHaarMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (K₀ : TopologicalSpace.PositiveCompacts G),
MeasureTheory.Measure.addHaarMeasure K₀ =
((MeasureTheory.Measure.haar.addHaarContent K₀).measure ↑K₀)⁻¹ •
... | true |
CategoryTheory.Functor.HomObj.naturality_assoc | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {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} {A : CategoryTheory.Functor C (Type w)} (self : F.HomObj G A) {c d : C} (f : c ⟶ d)
(a : A.obj c) {Z : D} (h : G.obj d ⟶ Z),
CategoryTheory.CategoryStruct.comp (F... | true |
Lean.Meta.getElimExprInfo | Lean.Meta.Tactic.ElimInfo | Lean.Expr → optParam (Option Lean.Name) none → Lean.MetaM Lean.Meta.ElimInfo | true |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.disjoint_withBotCoe._simp_1_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) | false |
TopologicalSpace.IrreducibleCloseds.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isIrreducible' : IsIrreducible carrier)
(isClosed' : IsClosed carrier) (carrier_1 : Set α) (isIrreducible'_1 : IsIrreducible carrier_1)
(isClosed'_1 : IsClosed carrier_1),
({ carrier := carrier, isIrreducible' := isIrreducible', isClosed' := isClosed... | true |
TopologicalSpace.IsTopologicalBasis.nhds_hasBasis | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → ∀ {a : α}, (nhds a).HasBasis (fun t => t ∈ b ∧ a ∈ t) fun t => t | true |
Int.divisorsAntidiag_neg_natCast._proof_1 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
Disjoint
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
n.divisorsAntidiagonal)
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
n.divisorsAntidiagonal) | false |
AddMonoidHom.compHom'_apply_apply | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} {P : Type uP} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] [inst_2 : AddCommMonoid P]
(f : M →+ N) (y : N →+ P) (x : M), (f.compHom' y) x = y (f x) | true |
Lean.MetavarContext.incDepth | Lean.MetavarContext | Lean.MetavarContext → optParam Bool false → Lean.MetavarContext | true |
Matrix.circulant_col_zero_eq | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : SubtractionMonoid n] (v : n → α) (i : n), Matrix.circulant v i 0 = v i | true |
CategoryTheory.toSkeleton | Mathlib.CategoryTheory.Skeletal | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → C → CategoryTheory.Skeleton C | true |
Homotopy.mkInductiveAux₂._proof_4 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(su... | false |
Ideal.radical_le_jacobson | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical ≤ I.jacobson | true |
Lean.DataValue.ofString.injEq | Lean.Data.KVMap | ∀ (v v_1 : String), (Lean.DataValue.ofString v = Lean.DataValue.ofString v_1) = (v = v_1) | true |
Lean.Elab.Term.PostponeBehavior.partial.sizeOf_spec | Lean.Elab.SyntheticMVars | sizeOf Lean.Elab.Term.PostponeBehavior.partial = 1 | true |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_15 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α} (h : xs.Perm ys) (w : Fin ys.length)
(h_1 : List.countBefore xs[⋯.idxBij w] xs ↑(⋯.idxBij w) + 1 ≤ (List.filter (fun x => x == xs[⋯.idxBij w]) ys).length),
(List.findIdxs (fun x => x == xs[⋯.idxBij w]) ys)[List.countBefore xs[⋯.idxBij w] xs ↑(⋯... | false |
AddCommGrpCat.instCreatesColimitsOfSizeUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.CreatesColimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} AddCommGrpCat.uliftFunctor | true |
FloorRing.ofFloor._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ (α : Type u_1) [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (floor : α → ℤ),
GaloisConnection Int.cast floor → ∀ (a : α) (z : ℤ), (fun a => -floor (-a)) a ≤ z ↔ a ≤ ↑z | false |
Units.coe_smul | Mathlib.Algebra.Group.Action.Units | ∀ {M : Type u_6} {N : Type u_7} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : MulDistribMulAction M N] (m : M)
(u : Nˣ), ↑(m • u) = m • ↑u | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processAssignmentFOApproxAux | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool | true |
UpperHalfPlane.measurableEmbedding_coe | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | MeasurableEmbedding UpperHalfPlane.coe | true |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.applyCoe | Lean.Elab.Extra | Lean.Elab.Term.Op.Tree✝ → Lean.Expr → Bool → Lean.Elab.TermElabM Lean.Elab.Term.Op.Tree✝¹ | true |
Nat.lt_sum_ge | Batteries.Data.Nat.Lemmas | (a b : ℕ) → a < b ⊕' b ≤ a | true |
CategoryTheory.ShortComplex.SnakeInput.functorL₃_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorL₃.obj S = S.L₃ | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremAndSuggest.match_5 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Unit × Lean.Meta.Grind.SelectM.State✝ → Sort u_1) →
(__discr : Unit × Lean.Meta.Grind.SelectM.State✝¹) →
((fst : Unit) → (s : Lean.Meta.Grind.SelectM.State✝²) → motive (fst, s)) → motive __discr | false |
CircleDeg1Lift.monotone | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Monotone ⇑f | true |
CategoryTheory.Pretriangulated.Triangle.functorHomMk._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(hom₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ⟶ B.comp Categ... | false |
Ideal.map_pi | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] [Finite ι] (x : ι → R),
(∀ (i : ι), x i ∈ I) → ∀ (f : (ι → R) →ₗ[R] ι' → R) (i : ι'), f x i ∈ I | true |
ENat.pow_ne_top_iff | Mathlib.Data.ENat.Basic | ∀ {a : ℕ∞} {n : ℕ}, a ^ n ≠ ⊤ ↔ a ≠ ⊤ ∨ n = 0 | true |
Nat.count_strict_mono | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {m n : ℕ}, p m → m < n → Nat.count p m < Nat.count p n | true |
DirectSum.lequivCongrLeft_symm_lof | Mathlib.Algebra.DirectSum.Module | ∀ (R : Type u) [inst : Semiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {κ : Type u_1} [inst_3 : DecidableEq ι] [inst_4 : DecidableEq κ] {h : ι ≃ κ}
{k : κ} {x : M (h.symm k)},
(DirectSum.lequivCongrLeft R h).symm ((DirectSum.lof R κ (fun k => ... | true |
Function.Embedding.twoEmbeddingEquiv.match_1 | Mathlib.Data.Fin.Tuple.Embedding | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x | false |
EMetric.ball_subset | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
edist x y + ε₁ ≤ ε₂ → edist x y ≠ ⊤ → Metric.eball x ε₁ ⊆ Metric.eball y ε₂ | true |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_5 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∃ y ∈ f '' s, p y) = ∃ x ∈ s, p (f x) | false |
_private.Mathlib.Tactic.NormNum.Eq.0.Mathlib.Meta.NormNum.evalEq.match_8 | Mathlib.Tactic.NormNum.Eq | (u : Lean.Level) →
(α :
have u := u;
Q(Type u)) →
(dsα : Q(DivisionSemiring «$α»)) →
(motive : Option Q(CharZero «$α») → Sort u_1) →
(__do_lift : Option Q(CharZero «$α»)) →
((_i : Q(CharZero «$α»)) → motive (some _i)) → ((x : Option Q(CharZero «$α»)) → motive x) → motive __do_l... | false |
CochainComplex.Lifting.coe_cocycle₁'_v_comp_eq_zero | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) (n m : ℤ)
(hnm : autoParam (n + 1 = m) CochainComplex.Lifting.coe_co... | true |
Vector.findSomeRev? | Init.Data.Vector.Basic | {α : Type u_1} → {β : Type u_2} → {n : ℕ} → (α → Option β) → Vector α n → Option β | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_succ_left_eq_erase_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
ProofWidgets.RpcEncodablePacket.mk.injEq._@.ProofWidgets.Presentation.Expr.3227936355._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | ∀ (expr expr_1 : Lean.Json), ({ expr := expr } = { expr := expr_1 }) = (expr = expr_1) | false |
_private.Mathlib.Topology.Algebra.Module.PointwiseConvergence.0.PointwiseConvergenceCLM.tendsto_iff_forall_tendsto._simp_1_1 | Mathlib.Topology.Algebra.Module.PointwiseConvergence | ∀ {Y : Type v} {ι : Type u_5} {A : ι → Type u_6} [T : (i : ι) → TopologicalSpace (A i)] {f : Y → (i : ι) → A i}
{g : (i : ι) → A i} {u : Filter Y},
Filter.Tendsto f u (nhds g) = ∀ (x : ι), Filter.Tendsto (fun i => f i x) u (nhds (g x)) | false |
HasSum.smul_eq | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_5} {κ : Type u_6} {R : Type u_7} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace M] [T3Space M] [ContinuousAdd M]
[ContinuousSMul R M] {f : ι → R} {g : κ → M} {s : R} {t u : M},
HasSum f s → HasSum g t → Has... | true |
NormedStarGroup.rec | Mathlib.Analysis.CStarAlgebra.Basic | {E : Type u_1} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : StarAddMonoid E] →
{motive : NormedStarGroup E → Sort u} →
((norm_star_le : ∀ (x : E), ‖star x‖ ≤ ‖x‖) → motive ⋯) → (t : NormedStarGroup E) → motive t | false |
HomotopicalAlgebra.Precylinder.mk.inj | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {A I : C} {i₀ i₁ : A ⟶ I} {π : I ⟶ A}
{i₀_π :
autoParam (CategoryTheory.CategoryStruct.comp i₀ π = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₀_π._autoParam}
{i₁_π :
autoParam (CategoryTheory.CategoryStruct.comp i₁ π = C... | true |
HasCardinalLT.Set.cocone_ι_app | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u) (κ : Cardinal.{u}) (x : HasCardinalLT.Set X κ) (self : { x_1 // x_1 ∈ ⋯.functor.obj x }),
(HasCardinalLT.Set.cocone X κ).ι.app x self = ↑self | true |
Equiv.prodUnique_symm_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} [inst : Unique β] (x : α), (Equiv.prodUnique α β).symm x = (x, default) | true |
MeasureTheory.Measure.sum_eq_zero | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} {f : ι → MeasureTheory.Measure α},
MeasureTheory.Measure.sum f = 0 ↔ ∀ (i : ι), f i = 0 | true |
Turing.PartrecToTM2.natEnd | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.Γ' → Bool | true |
Lean.addTraceAsMessages | Lean.Util.Trace | {m : Type → Type} →
[Lean.MonadOptions m] → [Monad m] → [Lean.MonadRef m] → [Lean.MonadLog m] → [Lean.MonadTrace m] → m Unit | true |
Real.exp_one_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), Real.exp 1 ^ x = Real.exp x | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv' | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{ℰ : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ] →
(A : CategoryTheory.Functor C ℰ) →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) →
(E : ℰ) →
((CategoryTheory.CostructuredArrow.pr... | true |
AddCon.pi.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_4} {f : ι → Type u_5} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)),
AddCon.pi C = { toSetoid := piSetoid, add' := ⋯ } | true |
CategoryTheory.ShortComplex.Homotopy.rec | 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₂} →
{motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Sort u} →
((h₀ : S₁.X₁ ⟶ S₂.X₁) →
(h₀_... | false |
PEquiv.injective_of_forall_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {f : α ≃. β}, (∀ (a : α), (f a).isSome = true) → Function.Injective ⇑f | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_ε | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C),
CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A) =
CategoryTheory... | true |
List.sum | Init.Data.List.Basic | {α : Type u_1} → [Add α] → [Zero α] → List α → α | true |
HomotopyGroup.commGroup._proof_2 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : Nontrivial N], ∃ y, y ≠ Classical.arbitrary N | false |
Set.Finite.induction_on_subset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {motive : (s : Set α) → s.Finite → Prop} (s : Set α) (hs : s.Finite),
motive ∅ ⋯ →
(∀ {a : α} {t : Set α}, a ∈ s → ∀ (hts : t ⊆ s), a ∉ t → motive t ⋯ → motive (insert a t) ⋯) → motive s hs | true |
Lean.Meta.Simp.Result.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{expr : Lean.Expr} →
{proof? : Option Lean.Expr} →
{cache : Bool} →
{expr' : Lean.Expr} →
{proof?' : Option Lean.Expr} →
{cache' : Bool} →
{ expr := expr, proof? := proof?, cache := cache } =
{ expr := expr', proof? := proof?', cac... | false |
_private.Init.Data.String.Lemmas.Iterate.0.String.Model.revPositionsFrom._proof_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String}, WellFounded (invImage (fun x => x.down) String.Pos.instWellFoundedRelationDown).1 | false |
_private.Lean.ImportingFlag.0.Lean.initFn._@.Lean.ImportingFlag.2251799370._hygCtx._hyg.2 | Lean.ImportingFlag | IO (IO.Ref Bool) | false |
CategoryTheory.MonObj.one_associator | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] [inst_4 : CategoryTheory.MonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(Categor... | true |
Array.reverse_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {as : Array α} {bs : Array α_1},
as.size = bs.size → (Array.zipWith f as bs).reverse = Array.zipWith f as.reverse bs.reverse | true |
LinearPMap.inverse_apply_eq | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f : E →ₗ.[R] F},
f.toFun.ker = ⊥ → ∀ {y : ↥f.inverse.domain} {x : ↥f.domain}, ↑f x = ↑y → ↑f.inverse y = ↑x | true |
Lean.MonadCache.noConfusionType | Lean.Util.MonadCache | Sort u →
{α β : Type} →
{m : Type → Type} → Lean.MonadCache α β m → {α' β' : Type} → {m' : Type → Type} → Lean.MonadCache α' β' m' → Sort u | false |
Lean.Parser.Command.versoCommentBody.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
Polynomial.resultant_add_mul_right | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g p : Polynomial R) (m n : ℕ),
p.natDegree + m ≤ n → f.natDegree ≤ m → f.resultant (g + f * p) m n = f.resultant g m n | true |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan._proof_7 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{X_1 Y_1 Z_1 : CategoryTheory.Limits.PushoutCocone f g} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z_1),
{ hom := CategoryTheory.Under.homMk (CategoryTheory.CategoryStruct.comp f_1 g_1).hom ⋯, w := ⋯ } =
CategoryTheory.Catego... | false |
_private.Init.Data.Iterators.Consumers.Access.0.Std.Iter.atIdxSlow?.match_3.eq_2 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(property : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(property : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yie... | true |
_private.Init.Data.Order.FactoriesExtra.0.DecidableLE.ofOrd._simp_3 | Init.Data.Order.FactoriesExtra | ∀ {α : Type u} {inst : Ord α} {inst_1 : LE α} [self : Std.LawfulOrderOrd α] (a b : α),
((compare a b).isLE = true) = (a ≤ b) | false |
Subgroup.coe_subgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), ↑(H.subgroupOf K) = ⇑K.subtype ⁻¹' ↑H | true |
ProfiniteGrp.ProfiniteCompletion.adjunction._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X' X : GrpCat} {Y : ProfiniteGrp.{u_1}} (f : X' ⟶ X)
(g : X ⟶ (CategoryTheory.forget₂ ProfiniteGrp.{u_1} GrpCat).obj Y),
(ProfiniteGrp.ProfiniteCompletion.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (ProfiniteGrp.profiniteCompletion.map f)
((Profini... | false |
NonUnitalStarSubalgebra.coe_add | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) (x y : ↥S), ↑(x + y) = ↑x + ↑y | true |
inv_add_inv | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K] {a b : K}, a ≠ 0 → b ≠ 0 → a⁻¹ + b⁻¹ = (a + b) / (a * b) | true |
IsDedekindDomain.HeightOneSpectrum.instAlgebraSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._proof_6 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)),
{
toFun := fun r =>
... | false |
Polynomial.shiftedLegendre | Mathlib.RingTheory.Polynomial.ShiftedLegendre | ℕ → Polynomial ℤ | true |
ENat.top_sub_one | Mathlib.Data.ENat.Basic | ⊤ - 1 = ⊤ | true |
KaehlerDifferential.derivationQuotKerTotal._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
((KaehlerDifferential.kerTotal R S).mkQ fun₀ | 1 => 1) = 0 | false |
AlgebraicGeometry.IsClosedImmersion.comp_iff | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsClosedImmersion g],
AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) ↔ AlgebraicGeometry.IsClosedImmersion f | true |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens), ↑U ∈ X.affineOpens | false |
ContDiffMapSupportedIn.coe_of_support_subset | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {f : E → F} (hf : ContDiff ℝ (↑n) f)
(hsupp : Function.support f ⊆ ↑K) (a : E), (ContDiffMapSupportedIn.of_support_subset hf ... | true |
MulActionHom.instCoeTCOfMulActionSemiHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{F : Type u_8} [inst_2 : FunLike F X Y] [inst_3 : MulActionSemiHomClass F φ X Y],
MulActionHom.instCoeTCOfMulActionSemiHomClass = { coe := MulActionSemiHomClass.toMulActionHom } | true |
Bundle.Trivialization.zeroSection | Mathlib.Topology.VectorBundle.Basic | ∀ (R : Type u_1) {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E... | true |
AddAction.fixedPoints | Mathlib.GroupTheory.GroupAction.Defs | (M : Type u_1) → (α : Type u_3) → [inst : AddMonoid M] → [AddAction M α] → Set α | true |
finite_mulSupport_of_finprod_ne_one | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M}, ∏ᶠ (i : α), f i ≠ 1 → Function.HasFiniteMulSupport f | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {ka : ℤ} {ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {kb : ℕ}
{cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {ka_1 : ℤ} {ca?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr}
{kb_1 : ℕ} {cb?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb?... | true |
Mathlib.Tactic.ModCases.IntMod.proveOnModCases | Mathlib.Tactic.ModCases | {u : Lean.Level} →
(n : Q(ℕ)) →
(a : Q(ℤ)) →
(b : Q(ℕ)) →
(p : Q(Sort u)) →
Lean.MetaM (Q(Mathlib.Tactic.ModCases.IntMod.OnModCases «$n» «$a» «$b» «$p») × List Lean.MVarId) | true |
NormedAddCommGroup.toSeminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [NormedAddCommGroup E] → SeminormedAddCommGroup E | true |
PadicInt.modPart | Mathlib.NumberTheory.Padics.RingHoms | ℕ → ℚ → ℤ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.