name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LowerSet.instPartialOrder._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], Function.Injective SetLike.coe | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.succ_ascFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | false |
SimpleGraph.deleteEdges_sup | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G H : SimpleGraph V) (s : Set (Sym2 V)), (G ⊔ H).deleteEdges s = G.deleteEdges s ⊔ H.deleteEdges s | true |
LinearMap.BilinForm.isCompl_span_singleton_orthogonal | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{B : LinearMap.BilinForm K V} {x : V}, ¬B.IsOrtho x x → IsCompl (K ∙ x) (B.orthogonal (K ∙ x)) | true |
MonCat.FilteredColimits.colimitCocone.eq_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J],
MonCat.FilteredColimits.colimitCocone F =
{ pt := MonCat.FilteredColimits.colimit F,
ι := { app := MonCat.FilteredColimits.coconeMorphism F, naturality := ⋯ } } | true |
Std.Do.PredTrans.pure | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → α → Std.Do.PredTrans ps α | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.D2_mul._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [LeftDistribClass R] (a b c : R), a * b + a * c = a * (b + c) | false |
CategoryTheory.CountableCategory.instCountableHomAsType | Mathlib.CategoryTheory.Countable | ∀ (α : Type u) [inst : CategoryTheory.Category.{v, u} α] [inst_1 : CategoryTheory.CountableCategory α],
Countable (CategoryTheory.CountableCategory.HomAsType α) | true |
Mathlib.Tactic.TFAE.Parser.tfaeHaveDecl.formatter | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Formatter | true |
ContMDiffWithinAt.comp_of_eq | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] {E'' : Type u_8} [inst_9 : NormedAddCommGroup E''] [inst_10 : NormedSpace 𝕜 E'']
{H'' : Type u_9} [inst_11 : TopologicalSpace H''] {I'' : ModelWithCorners 𝕜 E'' H''} {M'' : Type u_10}
[inst_12 : TopologicalSpace M''] [inst_13 : ChartedSpace H M] [inst_14 : ChartedSpace H' M']
[inst_15 : ChartedSpace H'' M''] {f : M → M'} {s : Set M} {n : WithTop ℕ∞} {t : Set M'} {g : M' → M''} {x : M}
{y : M'},
ContMDiffWithinAt I' I'' n g t y →
ContMDiffWithinAt I I' n f s x → Set.MapsTo f s t → f x = y → ContMDiffWithinAt I I'' n (g ∘ f) s x | true |
Order.aleph0_le_cof_iff._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {α : Type u} [inst : LinearOrder α], (Cardinal.aleph0 ≤ Order.cof α) = (1 < Order.cof α) | false |
WittVector.IsPoly.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {g f : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hg : WittVector.IsPoly p g]
[hf : WittVector.IsPoly p f], WittVector.IsPoly p fun R _Rcr => g ∘ f | true |
_private.Mathlib.GroupTheory.GroupAction.ConjAct.0.ConjAct.fixedPoints_eq_center._simp_1_1 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_1} [inst : Group G] {z : G}, (z ∈ Subgroup.center G) = ∀ (g : G), g * z = z * g | false |
ENNReal.lintegral_Lp_add_le_of_le_one | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : ℝ} {f g : α → ENNReal},
AEMeasurable f μ →
0 ≤ p →
p ≤ 1 →
(∫⁻ (a : α), (f + g) a ^ p ∂μ) ^ (1 / p) ≤
2 ^ (1 / p - 1) * ((∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) + (∫⁻ (a : α), g a ^ p ∂μ) ^ (1 / p)) | true |
IsStarProjection.le_of_mul_eq_left | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R] {p q : R},
IsStarProjection p → IsStarProjection q → p * q = p → p ≤ q | true |
contMDiffAt_subtype_iff | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {n : WithTop ℕ∞}
{U : TopologicalSpace.Opens M} {f : M → M'} {x : ↥U}, ContMDiffAt I I' n (fun x => f ↑x) x ↔ ContMDiffAt I I' n f ↑x | true |
LeanSearchClient.SearchServer.searchTermSuggestions | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → Lean.Syntax → Lean.TSyntax `str → Lean.Elab.TermElabM Unit | true |
Std.DTreeMap.Internal.Impl.Balanced.below.leaf | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {motive : (a : Std.DTreeMap.Internal.Impl α β) → a.Balanced → Prop},
Std.DTreeMap.Internal.Impl.Balanced.below ⋯ | true |
BitVec.extractLsb_not_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {hi lo : ℕ}, lo ≤ hi → hi < w → BitVec.extractLsb hi lo (~~~x) = ~~~BitVec.extractLsb hi lo x | true |
MvPolynomial.pUnitAlgEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (p : MvPolynomial PUnit.{u_2 + 1} R),
(MvPolynomial.pUnitAlgEquiv R) p = MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X) p | true |
Lean.Elab.Tactic.Ext.applyExtTheoremAt | Lean.Elab.Tactic.Ext | Lean.MVarId → Lean.MetaM (List Lean.MVarId) | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_26 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | false |
ProbabilityTheory.gammaMeasure.eq_1 | Mathlib.Probability.Distributions.Gamma | ∀ (a r : ℝ), ProbabilityTheory.gammaMeasure a r = MeasureTheory.volume.withDensity (ProbabilityTheory.gammaPDF a r) | true |
_private.Mathlib.FieldTheory.KrullTopology.0.krullTopology_mem_nhds_one_iff_of_normal.match_1_3 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (s : Set Gal(L/K))
(motive : (∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s) → Prop)
(x : ∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s),
(∀ (E : IntermediateField K L) (hE : FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s), motive ⋯) →
motive x | false |
MeasureTheory.ProgMeasurable.finset_sum | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] [inst_2 : MeasurableSpace ι] {γ : Type u_4} [inst_3 : AddCommMonoid β]
[ContinuousAdd β] {U : γ → ι → Ω → β} {s : Finset γ},
(∀ c ∈ s, MeasureTheory.ProgMeasurable f (U c)) → MeasureTheory.ProgMeasurable f fun i a => ∑ c ∈ s, U c i a | true |
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit._sparseCasesOn_19 | Lean.Meta.Check | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 1152 t.ctorIdx → motive t) → motive t | false |
Diffeology.DSmooth.continuous' | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : DiffeologicalSpace X]
[Diffeology.IsDTopologyCompatible X] [inst_3 : TopologicalSpace Y] [inst_4 : DiffeologicalSpace Y]
[Diffeology.IsDTopologyCompatible Y] {f : X → Y}, Diffeology.DSmooth f → Continuous f | true |
CategoryTheory.Limits.ImageMap.map_uniq_aux | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
[inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g}
(map : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom),
autoParam
(CategoryTheory.CategoryStruct.comp map (CategoryTheory.Limits.image.ι g.hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f.hom) sq.right)
CategoryTheory.Limits.ImageMap.map_uniq_aux._auto_1 →
∀ (map' : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom),
CategoryTheory.CategoryStruct.comp map' (CategoryTheory.Limits.image.ι g.hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f.hom) sq.right →
map = map' | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr.0.Lean.Meta.Grind.Arith.Cutsat.LeCnstr.applySubsts.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr | (motive : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u_1) →
(__discr : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
((b : ℤ) → (x : Int.Linear.Var) → (c₁ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → motive (some (b, x, c₁))) →
((x : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) → motive x) → motive __discr | false |
SSet.spine.eq_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ), X.spine n = ((SSet.truncation (n + 1)).obj X).spine n ⋯ | true |
Aesop.ForwardRule.instToString | Aesop.Rule.Forward | ToString Aesop.ForwardRule | true |
lt_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, a < |b| ↔ a < b ∨ a < -b | true |
Lean.Parser.Term.let_fun._regBuiltin.Lean.Parser.Term.let_fun.formatter_9 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_of_one_to_one.match_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin ((SimplexCategory.mk 1).len + 1) → Prop) (i : Fin ((SimplexCategory.mk 1).len + 1)),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i | false |
Finset.Colex.isInitSeg_empty | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : LinearOrder α] {r : ℕ}, Finset.Colex.IsInitSeg ∅ r | true |
CategoryTheory.PreZeroHypercover.restrictIndex_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : C} (E : CategoryTheory.PreZeroHypercover T) {ι : Type w'}
(f : ι → E.I₀), (E.restrictIndex f).I₀ = ι | true |
CategoryTheory.Limits.Cone.functoriality_obj_π_app | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F) (j : J),
((CategoryTheory.Limits.Cone.functoriality F G).obj A).π.app j = G.map (A.π.app j) | true |
MLList.fix?._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → (α → m (Option α)) → α → MLList m α | false |
CategoryTheory.Limits.MultispanIndex.SymmStruct._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{ι : Type w} →
(I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C) →
[SizeOf C] → [SizeOf ι] → SizeOf I.SymmStruct | false |
Differentiable.cosh._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ},
Differentiable ℝ f → (Differentiable ℝ fun x => Real.cosh (f x)) = True | false |
_private.Mathlib.Data.Holor.0.Holor._aux_Mathlib_Data_Holor___unexpand_Holor_mul_1 | Mathlib.Data.Holor | Lean.PrettyPrinter.Unexpander | false |
Function.Even.add | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] [inst_1 : Add β] {f g : α → β},
Function.Even f → Function.Even g → Function.Even (f + g) | true |
CategoryTheory.adjunctionOfStructuredArrowInitials | Mathlib.CategoryTheory.Adjunction.Comma | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor D C) →
[inst_2 : ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] →
CategoryTheory.leftAdjointOfStructuredArrowInitials G ⊣ G | true |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.glueData._simp_5 | Mathlib.AlgebraicGeometry.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(f = CategoryTheory.CategoryStruct.comp α.hom g) = (CategoryTheory.CategoryStruct.comp α.inv f = g) | false |
Int.bitwise.eq_2 | Mathlib.Data.Int.Bitwise | ∀ (f : Bool → Bool → Bool) (m n : ℕ),
Int.bitwise f (Int.ofNat m) (Int.negSucc n) = Int.natBitwise (fun x y => f x !y) m n | true |
Std.IterM.findSome?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β]
[inst_2 : Std.IteratorLoop α m m] [LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m]
{it : Std.IterM m β} {f : β → Option γ},
it.findSome? f = do
let __do_lift ← it.step
match ↑__do_lift.inflate with
| Std.IterStep.yield it' out =>
match f out with
| none => it'.findSome? f
| some fx => pure (some fx)
| Std.IterStep.skip it' => it'.findSome? f
| Std.IterStep.done => pure none | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftActionOfOppositeLeftAction_actionUnitIso | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction Cᵒᵖ Dᵒᵖ] (x : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso x =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso (Opposite.op x)).symm.unop | true |
Ideal.stabilizerEquiv | Mathlib.RingTheory.Ideal.Pointwise | {M : Type u_1} →
{R : Type u_2} →
[inst : Group M] →
[inst_1 : Semiring R] →
[inst_2 : MulSemiringAction M R] →
{N : Type u_3} →
[inst_3 : Group N] →
[inst_4 : MulSemiringAction N R] →
(I : Ideal R) →
(e : M ≃* N) →
(∀ (m : M) (x : R), e m • x = m • x) → ↥(MulAction.stabilizer M I) ≃* ↥(MulAction.stabilizer N I) | true |
MeasureTheory.ComplexMeasure.HaveLebesgueDecomposition.recOn | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | {α : Type u_1} →
{m : MeasurableSpace α} →
{c : MeasureTheory.ComplexMeasure α} →
{μ : MeasureTheory.Measure α} →
{motive : c.HaveLebesgueDecomposition μ → Sort u} →
(t : c.HaveLebesgueDecomposition μ) →
((rePart : (MeasureTheory.ComplexMeasure.re c).HaveLebesgueDecomposition μ) →
(imPart : (MeasureTheory.ComplexMeasure.im c).HaveLebesgueDecomposition μ) → motive ⋯) →
motive t | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_insert._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
AlgebraicGeometry.Scheme.Pullback.Triplet.specTensorTo_snd | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
CategoryTheory.CategoryStruct.comp T.SpecTensorTo (CategoryTheory.Limits.pullback.snd f g) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map T.tensorInr) (Y.fromSpecResidueField T.y) | true |
Std.ExtDTreeMap.Const.get!_inter_of_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited β] {k : α},
k ∈ t₂ → Std.ExtDTreeMap.Const.get! (t₁ ∩ t₂) k = Std.ExtDTreeMap.Const.get! t₁ k | true |
Polynomial.Bivariate.Transcendental.algEquivAdjoin_apply | Mathlib.RingTheory.Adjoin.Polynomial.Bivariate | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {x : A}
(hx : Transcendental R x) (p : Polynomial (Polynomial R)),
(Polynomial.Bivariate.Transcendental.algEquivAdjoin hx) p = (Polynomial.mapAlgHom (Polynomial.aeval ⟨x, ⋯⟩)) p | true |
Std.Internal.IO.Async.Signal.toCtorIdx | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal → ℕ | false |
UniformSpace.completelyNormalSpace_of_isCountablyGenerated_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] [(uniformity α).IsCountablyGenerated], CompletelyNormalSpace α | true |
CategoryTheory.Limits.cokernel.mapIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {X' Y' : C} (f' : X' ⟶ Y')
[inst_3 : CategoryTheory.Limits.HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y')
(w : CategoryTheory.CategoryStruct.comp f q.hom = CategoryTheory.CategoryStruct.comp p.hom f'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.map f' f p.inv q.inv ⋯)
(CategoryTheory.Limits.cokernel.map f f' p.hom q.hom w) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.cokernel f') | false |
Module.Presentation.directSum_relation | Mathlib.Algebra.Module.Presentation.DirectSum | ∀ {A : Type u} [inst : Ring A] {ι : Type w} [inst_1 : DecidableEq ι] {M : ι → Type v}
[inst_2 : (i : ι) → AddCommGroup (M i)] [inst_3 : (i : ι) → Module A (M i)]
(pres : (i : ι) → Module.Presentation A (M i)) (x : (i : ι) × ((fun i => (pres i).toRelations) i).R),
(Module.Presentation.directSum pres).relation x =
Finsupp.embDomain (Function.Embedding.sigmaMk x.fst) ((pres x.fst).relation x.snd) | true |
MeasureTheory.IsSetSemiring.rec | Mathlib.MeasureTheory.SetSemiring | {α : Type u_1} →
{C : Set (Set α)} →
{motive : MeasureTheory.IsSetSemiring C → Sort u} →
((empty_mem : ∅ ∈ C) →
(inter_mem : ∀ s ∈ C, ∀ t ∈ C, s ∩ t ∈ C) →
(diff_eq_sUnion' : ∀ s ∈ C, ∀ t ∈ C, ∃ I, ↑I ⊆ C ∧ (↑I).PairwiseDisjoint id ∧ s \ t = ⋃₀ ↑I) → motive ⋯) →
(t : MeasureTheory.IsSetSemiring C) → motive t | false |
CStarMatrix.instNonUnitalNonAssocRing | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {n : Type u_2} → {A : Type u_5} → [Fintype n] → [NonUnitalNonAssocRing A] → NonUnitalNonAssocRing (CStarMatrix n n A) | true |
Ideal.qoutMapEquivTensorQout | Mathlib.LinearAlgebra.TensorProduct.Quotient | {R : Type u_1} →
[inst : CommRing R] →
(S : Type u_4) →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] → {I : Ideal R} → (S ⧸ Ideal.map (algebraMap R S) I) ≃ₗ[S] TensorProduct R S (R ⧸ I) | true |
_private.Mathlib.Data.FinEnum.0.List.pfunFinEnum._simp_2 | Mathlib.Data.FinEnum | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
LinearEquiv.det_coe_symm | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {𝕜 : Type u_5} [inst_1 : Field 𝕜] [inst_2 : Module 𝕜 M] (f : M ≃ₗ[𝕜] M),
LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹ | true |
Filter.EventuallyEq.hasFDerivAtFilter_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f₀' f₁' : E →L[𝕜] F} {L : Filter (E × E)},
Prod.map f₀ f₀ =ᶠ[L] Prod.map f₁ f₁ →
(∀ (x : E), f₀' x = f₁' x) → (HasFDerivAtFilter f₀ f₀' L ↔ HasFDerivAtFilter f₁ f₁' L) | true |
Projectivization.rep | Mathlib.LinearAlgebra.Projectivization.Basic | {K : Type u_1} →
{V : Type u_2} →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → Projectivization K V → V | true |
GrpCat.FilteredColimits.colimitGroup._proof_2 | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J GrpCat) (a : ↑(GrpCat.FilteredColimits.G F)), zpowRec npowRec 0 a = 1 | false |
PosNum.isOne._sparseCasesOn_1 | Mathlib.Data.Num.Basic | {motive : PosNum → Sort u} → (t : PosNum) → motive PosNum.one → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Ordinal.one_add_of_omega0_le | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {o : Ordinal.{u_4}}, Ordinal.omega0 ≤ o → 1 + o = o | true |
Orientation.oangle_eq_angle_or_eq_neg_angle | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V},
x ≠ 0 → y ≠ 0 → o.oangle x y = ↑(InnerProductGeometry.angle x y) ∨ o.oangle x y = -↑(InnerProductGeometry.angle x y) | true |
_private.Mathlib.Algebra.Notation.Support.0.Function.range_subset_insert_image_mulSupport._simp_1_2 | Mathlib.Algebra.Notation.Support | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | false |
Real.surjOn_log' | Mathlib.Analysis.SpecialFunctions.Log.Basic | Set.SurjOn Real.log (Set.Iio 0) Set.univ | true |
LinearEquiv.ofLeftInverse | Mathlib.Algebra.Module.Submodule.Equiv | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{module_M : Module R M} →
{module_M₂ : Module R₂ M₂} →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
{f : M →ₛₗ[σ₁₂] M₂} →
[inst_4 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_5 : RingHomInvPair σ₂₁ σ₁₂] →
{g : M₂ → M} → Function.LeftInverse g ⇑f → M ≃ₛₗ[σ₁₂] ↥f.range | true |
Int.toList_roc_eq_singleton_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, (m<...=n).toList = [k] ↔ n = m + 1 ∧ m + 1 = k | true |
Array.append_eq_toArray_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {as : List α}, xs ++ ys = as.toArray ↔ xs.toList ++ ys.toList = as | true |
_private.Mathlib.Tactic.Variable.0.Mathlib.Command.Variable.completeBinders'._proof_9 | Mathlib.Tactic.Variable | ∀ (gas : ℕ) (binders : Lean.TSyntaxArray `Lean.Parser.Term.bracketedBinder) (i : ℕ),
0 < gas ∧ i < Array.size binders → ¬i ≤ Array.size binders → False | false |
AlgebraicGeometry.LocallyRingedSpace.restrictStalkIso_inv_eq_germ | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U ⟶ X.toTopCat}
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) (V : TopologicalSpace.Opens ↑U) (x : ↑U)
(hx : x ∈ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.germ (h.functor.obj V) ((CategoryTheory.ConcreteCategory.hom f) x) ⋯)
(X.restrictStalkIso h x).inv =
(X.restrict h).presheaf.germ V x hx | true |
CategoryTheory.Grothendieck.pre._proof_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C CategoryTheory.Cat)
(G : CategoryTheory.Functor D C) (X : CategoryTheory.Grothendieck (G.comp F)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
{ base := G.map (CategoryTheory.CategoryStruct.id X).base,
fiber := (CategoryTheory.CategoryStruct.id X).fiber }.fiber =
(CategoryTheory.CategoryStruct.id { base := G.obj X.base, fiber := X.fiber }).fiber | false |
Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) →
((p : Lean.Grind.CommRing.Poly) →
(h : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) → motive_2 h → motive_1 { p := p, h := h }) →
((a b : Lean.Expr) →
(ra rb : Lean.Grind.CommRing.Expr) →
motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.core a b ra rb)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) →
motive_1 c → motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm c)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive_1 c → motive_2 (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.cancelDen c val x n)) →
motive_2 t | false |
PFunctor.M.corecOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type u_2} → X → (X → ↑F X) → F.M | true |
Lean.MonadError.toMonadExceptOf | Lean.Exception | {m : Type → Type} → [self : Lean.MonadError m] → MonadExceptOf Lean.Exception m | true |
NumberField.RingOfIntegers.withValEquiv_symm_apply | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {K : Type u_3} [inst_1 : Field K] (v : Valuation K Γ₀)
(R : Type u_4) [inst_2 : CommRing R] [inst_3 : Algebra R K] [inst_4 : IsIntegralClosure R ℤ K] (a : R),
(NumberField.RingOfIntegers.withValEquiv v R).symm a =
(IsIntegralClosure.equiv ℤ R (WithVal v) (NumberField.RingOfIntegers (WithVal v))) a | true |
CategoryTheory.RegularMono._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.RegularMono f) | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUSize_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
Std.DTreeMap.contains_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ ∩ t₂).contains k = (t₁.contains k && t₂.contains k) | true |
WeakDual.CharacterSpace.homeoEval._proof_1 | Mathlib.Topology.ContinuousMap.Ideals | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 | false |
Std.HashMap.Raw.size_add_size_eq_size_union_add_size_inter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.size + m₂.size = (m₁ ∪ m₂).size + (m₁ ∩ m₂).size | true |
List.finite_toSet | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (l : List α), {x | x ∈ l}.Finite | true |
CategoryTheory.Retract.refl_r | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.Retract.refl X).r = CategoryTheory.CategoryStruct.id X | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.alts._default | Lean.Elab.Tactic.Induction | Array Lean.Elab.Tactic.ElimApp.Alt | false |
TensorProduct.map_comp_comm_eq | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_7}
{N : Type u_8} {M₂ : Type u_12} {N₂ : Type u_14} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R M] [inst_7 : Module R N]
[inst_8 : Module R₂ M₂] [inst_9 : Module R₂ N₂] (f : M →ₛₗ[σ₁₂] M₂) (g : N →ₛₗ[σ₁₂] N₂),
TensorProduct.map f g ∘ₛₗ ↑(TensorProduct.comm R N M) = ↑(TensorProduct.comm R₂ N₂ M₂) ∘ₛₗ TensorProduct.map g f | true |
Lean.Meta.Grind.Arith.Linear.EqCnstr.brecOn.go | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Linear.IneqCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Linear.DiseqCnstr → Sort u} →
{motive_6 : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof → Sort u} →
{motive_7 : Lean.Meta.Grind.Arith.Linear.UnsatProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.EqCnstr) →
((t : Lean.Meta.Grind.Arith.Linear.EqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Arith.Linear.EqCnstrProof) → t.below → motive_2 t) →
((t : Lean.Meta.Grind.Arith.Linear.IneqCnstr) → t.below → motive_3 t) →
((t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) → t.below → motive_4 t) →
((t : Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → t.below → motive_5 t) →
((t : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof) → t.below → motive_6 t) →
((t : Lean.Meta.Grind.Arith.Linear.UnsatProof) → t.below → motive_7 t) →
motive_1 t ×' t.below | true |
CommAlgCat.instMonoidalCategory | Mathlib.Algebra.Category.CommAlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.MonoidalCategory (CommAlgCat R) | true |
SimpleGraph.Walk.mem_support_nil_iff | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ∈ SimpleGraph.Walk.nil.support ↔ u = v | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.liftRel_bind.match_1_9 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_3} {γ : Type u_1} {δ : Type u_2} (S : γ → δ → Prop) {f1 : α → Computation γ} {x : δ} (w : α)
(motive : (∃ a ∈ f1 w, S a x) → Prop) (x_1 : ∃ a ∈ f1 w, S a x),
(∀ (w_1 : γ) (c₂ : w_1 ∈ f1 w) (cd : S w_1 x), motive ⋯) → motive x_1 | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.inj | Lean.Server.ProtocolOverview | ∀ {method : String} {direction : Lean.JsonRpc.MessageDirection}
{kinds : Array Lean.Server.Overview.ProtocolExtensionKind✝} {parameterType : Type} {description method_1 : String}
{direction_1 : Lean.JsonRpc.MessageDirection} {kinds_1 : Array Lean.Server.Overview.ProtocolExtensionKind✝¹}
{parameterType_1 : Type} {description_1 : String},
{ method := method, direction := direction, kinds := kinds, parameterType := parameterType,
description := description } =
{ method := method_1, direction := direction_1, kinds := kinds_1, parameterType := parameterType_1,
description := description_1 } →
method = method_1 ∧
direction = direction_1 ∧ kinds = kinds_1 ∧ parameterType = parameterType_1 ∧ description = description_1 | true |
Lean.Doc.Inline.linebreak.noConfusion | Lean.DocString.Types | {i : Type u} →
{P : Sort u_1} →
{string string' : String} →
Lean.Doc.Inline.linebreak string = Lean.Doc.Inline.linebreak string' → (string = string' → P) → P | false |
Ordinal.CNF.coeff_zero_right | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_1}), Ordinal.CNF.coeff b 0 = 0 | true |
IntervalIntegrable.comp_add_left_iff | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b : ℝ}
[TopologicalSpace.PseudoMetrizableSpace ε] {c : ℝ},
autoParam (‖f (min a b)‖ₑ ≠ ⊤) IntervalIntegrable.comp_add_left_iff._auto_1 →
(IntervalIntegrable (fun x => f (c + x)) MeasureTheory.volume (a - c) (b - c) ↔
IntervalIntegrable f MeasureTheory.volume a b) | true |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.sSup_eq_eqvGen._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r s : Setoid α}, (r ≤ s) = ∀ {x y : α}, r x y → s x y | false |
MulOpposite.instNonUnitalSemiring._proof_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (a b c : Rᵐᵒᵖ), a * b * c = a * (b * c) | false |
Cardinal.ofNat_eq_toENat | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}} {n : ℕ} [inst : n.AtLeastTwo], OfNat.ofNat n = Cardinal.toENat c ↔ OfNat.ofNat n = c | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.