name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Aesop.Rule.Name.0.Aesop.instHashablePhaseName.hash.match_1 | Aesop.Rule.Name | (motive : Aesop.PhaseName → Sort u_1) →
(x : Aesop.PhaseName) →
(Unit → motive Aesop.PhaseName.norm) →
(Unit → motive Aesop.PhaseName.safe) → (Unit → motive Aesop.PhaseName.unsafe) → motive x | false |
Lean.Meta.forallTelescopeCompatible | Lean.Elab.DeclUtil | {m : Type → Type u_1} →
{α : Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] → Lean.Expr → Lean.Expr → ℕ → (Array Lean.Expr → Lean.Expr → Lean.Expr → m α) → m α | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_489 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | false |
_private.Batteries.Data.String.Legacy.0.String.Legacy.mapAux._unary._proof_1 | Batteries.Data.String.Legacy | ∀ (f : Char → Char) (i : String.Pos.Raw) (s : String),
(String.Pos.Raw.set s i (f (String.Pos.Raw.get s i))).rawEndPos.byteIdx -
(String.Pos.Raw.next (String.Pos.Raw.set s i (f (String.Pos.Raw.get s i))) i).byteIdx <
s.rawEndPos.byteIdx - i.byteIdx →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.... | false |
DivInvMonoid.measurableZPow | Mathlib.MeasureTheory.Group.Arithmetic | ∀ (G : Type u) [inst : DivInvMonoid G] [inst_1 : MeasurableSpace G] [MeasurableMul₂ G] [MeasurableInv G],
MeasurablePow G ℤ | true |
Nat.getElem_toList_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...n).toList.length), (m<...n).toList[i] = m + 1 + i | true |
Matrix.vec3_eq | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {a₀ a₁ a₂ b₀ b₁ b₂ : α}, a₀ = b₀ → a₁ = b₁ → a₂ = b₂ → ![a₀, a₁, a₂] = ![b₀, b₁, b₂] | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.inc | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice} {stackPos needlePos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos →
∀ (h₁ : needlePos < pat.rawEndPos) (h₂ : stackPos < s.rawEndPos),
pat.getUTF8Byte needlePos h₁ = s.getUTF8Byte stackPos h₂ →
String.Slice.Pattern.Mod... | true |
ProofWidgets.RpcEncodablePacket.mk.inj._@.ProofWidgets.Component.FilterDetails.2598060976._hygCtx._hyg.1 | ProofWidgets.Component.FilterDetails | ∀ {summary filtered all initiallyFiltered summary_1 filtered_1 all_1 initiallyFiltered_1 : Lean.Json},
{ summary := summary, filtered := filtered, all := all, initiallyFiltered := initiallyFiltered } =
{ summary := summary_1, filtered := filtered_1, all := all_1, initiallyFiltered := initiallyFiltered_1 } →
... | false |
USize.lt_one_iff | Init.Data.UInt.Lemmas | ∀ {a : USize}, a < 1 ↔ a = 0 | true |
_private.Batteries.Data.Fin.Basic.0.Fin.dfoldlM._proof_1 | Batteries.Data.Fin.Basic | ∀ (n i : ℕ), i < n + 1 → ¬i < n → ¬i = n → False | false |
TopologicalSpace.Opens.forall | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {p : TopologicalSpace.Opens α → Prop},
(∀ (U : TopologicalSpace.Opens α), p U) ↔ ∀ (U : Set α) (hU : IsOpen U), p { carrier := U, is_open' := hU } | true |
Fin.cycleRange | Mathlib.GroupTheory.Perm.Fin | {n : ℕ} → Fin n → Equiv.Perm (Fin n) | true |
isNoetherian_def | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsNoetherian R M ↔ ∀ (s : Submodule R M), s.FG | true |
Std.DHashMap.Internal.Raw₀.containsThenInsert | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[BEq α] → [Hashable α] → Std.DHashMap.Internal.Raw₀ α β → (a : α) → β a → Bool × Std.DHashMap.Internal.Raw₀ α β | true |
Lean.Compiler.LCNF.Code.let.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (decl : Lean.Compiler.LCNF.LetDecl pu) (k : Lean.Compiler.LCNF.Code pu),
sizeOf (Lean.Compiler.LCNF.Code.let decl k) = 1 + sizeOf decl + sizeOf k | true |
NNReal.nndist_zero_eq_val' | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ (z : NNReal), nndist z 0 = z | true |
_private.Mathlib.Algebra.Ring.IsFormallyReal.0.IsFormallyReal.of_eq_zero_of_eq_zero_of_mul_self_add._proof_1_1 | Mathlib.Algebra.Ring.IsFormallyReal | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R], (∀ (x : R), IsSumNonzeroSq x → x ≠ 0) → ¬IsSumNonzeroSq 0 | false |
ContDiffOn.smul_const | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{A : Type u_4} [inst_5 : NormedRing A] [inst_6 : NormedAlgebra 𝕜 A] [inst_7 : Module A F] [IsSca... | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Decl.inlineIfReduceAttr._sparseCasesOn_1 | Lean.Compiler.LCNF.Basic | {motive : Lean.Compiler.InlineAttributeKind → Sort u} →
(t : Lean.Compiler.InlineAttributeKind) →
motive Lean.Compiler.InlineAttributeKind.inlineIfReduce → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
mem_closure_iff_frequently | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, x ∈ closure s ↔ ∃ᶠ (x : X) in nhds x, x ∈ s | true |
mul_lt_mul_iff_of_pos_left | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [PosMulStrictMono α]
[PosMulReflectLT α], 0 < a → (a * b < a * c ↔ b < c) | true |
CategoryTheory.SimplicialObject.IsCoskeletal.casesOn | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : CategoryTheory.SimplicialObject C} →
{n : ℕ} →
{motive : X.IsCoskeletal n → Sort u_1} →
(t : X.IsCoskeletal n) →
((isRightKanExtension :
CategoryTheory.Functor.IsRightKanExtension X
... | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqcs.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : List Lean.Expr → Sort u_1) →
(x : List Lean.Expr) →
((e : Lean.Expr) → (es : List Lean.Expr) → motive (e :: es)) → ((x : List Lean.Expr) → motive x) → motive x | false |
one_le_of_le_mul_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α] [MulLeftReflectLE α] {a b : α}, a ≤ a * b → 1 ≤ b | true |
CategoryTheory.ShortComplex.ShortExact.comp_δ | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (hS : S.ShortExact) (i j : ι)
(hij : c.Rel i j), CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap S.g i)... | true |
Real.sinh_eq | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sinh x = (Real.exp x - Real.exp (-x)) / 2 | true |
_private.Init.Grind.ToInt.0.Lean.Grind.IntInterval.wrap_eq_bmod._proof_1_12 | Init.Grind.ToInt | ∀ {x : ℤ} {i : ℤ} (i : ℕ), ¬x - 2 * ↑i * (x / (2 * ↑i)) + ↑i - (x + ↑i) = -(2 * ↑i * (x / (2 * ↑i))) → False | false |
CategoryTheory.LocallyDiscrete.mkPseudofunctor._proof_5 | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {B₀ : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_5, u_4} B₀] [inst_1 : CategoryTheory.Bicategory C]
(obj : B₀ → C) (map : {b b' : B₀} → (b ⟶ b') → (obj b ⟶ obj b')) {b₀ b₁ : CategoryTheory.LocallyDiscrete B₀}
(x : b₀ ⟶ b₁), map (CategoryTheory.CategoryStruct.comp x.as (CategoryTheory.CategoryStru... | false |
Std.ExtTreeSet.getD_insertMany_list_of_not_mem_of_contains_eq_false | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k fallback : α},
k ∉ t → l.contains k = false → (t.insertMany l).getD k fallback = fallback | true |
Mathlib.instToExprRaw_mathlib_1.toExpr | Mathlib.Tactic.ToExpr | Substring.Raw → Lean.Expr | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.whiskerRight.injEq | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (f g : Mathlib.Tactic.BicategoryLike.Mor₁) (η : Mathlib.Tactic.BicategoryLike.Mor₂Iso)
(h : Mathlib.Tactic.BicategoryLike.Mor₁) (e_1 : Lean.Expr) (f_1 g_1 : Mathlib.Tactic.BicategoryLike.Mor₁)
(η_1 : Mathlib.Tactic.BicategoryLike.Mor₂Iso) (h_1 : Mathlib.Tactic.BicategoryLike.Mor₁),
(Mathlib.Tact... | true |
LinearEquiv.lTensor_trans_rTensor | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} {Q : Type u_10}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (f : M ≃ₗ[R] P)
... | true |
OreLocalization.instSMulOfIsScalarTower | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
{M : Type u_3} →
{X : Type u_4} →
[inst : Monoid M] →
{S : Submonoid M} →
[inst_1 : OreLocalization.OreSet S] →
[inst_2 : MulAction M X] →
[inst_3 : SMul R X] →
[inst_4 : SMul R M] → [IsScalarTower R M X] → [IsScalarTower R M M] → ... | true |
_private.Mathlib.ModelTheory.Substructures.0.FirstOrder.Language.LHom.substructureReduct._simp_2 | Mathlib.ModelTheory.Substructures | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (↑p = ↑q) = (p = q) | false |
Homotopy.mkInductiveAux₁._proof_1 | Mathlib.Algebra.Homology.Homotopy | IsRightCancelAdd ℕ | false |
CategoryTheory.Limits.Bicone.IsBilimit.isColimit | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{F : J → C} → {B : CategoryTheory.Limits.Bicone F} → B.IsBilimit → CategoryTheory.Limits.IsColimit B.toCocone | true |
Lean.Elab.Term.MutualClosure.ClosureState.exprArgs._default | Lean.Elab.MutualDef | Array Lean.Expr | false |
SummationFilter.instIsCountablyGeneratedFinsetFilterUnconditionalOfCountable | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ (β : Type u_2) [Countable β], (SummationFilter.unconditional β).filter.IsCountablyGenerated | true |
CategoryTheory.Discrete.functor_map | Mathlib.CategoryTheory.Discrete.Basic | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) {i : CategoryTheory.Discrete I}
(f : i ⟶ i), (CategoryTheory.Discrete.functor F).map f = CategoryTheory.CategoryStruct.id (F i.as) | true |
Function.Injective.subtractionMonoid._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Add M₁] [inst_1 : Zero M₁] [inst_2 : SMul ℕ M₁] [inst_3 : Neg M₁]
[inst_4 : Sub M₁] [inst_5 : SMul ℤ M₁] [inst_6 : SubtractionMonoid M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(zero : f 0 = 0) (add : ∀ (x y : M₁), f (x + y) = f x + f y) (neg : ∀ (x : M₁), f (-x) = -f x)
... | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.udiv_def._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : BitVec n}, ¬x.toNat < 2 ^ n → False | false |
FreeAddMonoid.of_vadd | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β → β) (x : α) (y : β), FreeAddMonoid.of x +ᵥ y = f x y | true |
LinearOrderedField.inducedMap_add | Mathlib.Algebra.Order.CompleteField | ∀ (α : Type u_2) (β : Type u_3) [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Field β]
[inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [Archimedean α] (x y : α),
ConditionallyCompleteLinearOrderedField.inducedMap α β (x + y) =
ConditionallyCompleteLinearOrdere... | true |
Codisjoint.inf_left | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderTop α] {a b c : α},
Codisjoint a c → Codisjoint b c → Codisjoint (a ⊓ b) c | true |
Lean.Meta.mkSizeOfSpecLemmaInstance | Lean.Meta.SizeOf | Lean.Expr → Lean.MetaM Lean.Expr | true |
Ideal.Quotient.factorₐ.congr_simp | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] {I J : Ideal A}
[inst_3 : I.IsTwoSided] [inst_4 : J.IsTwoSided] (hIJ : I ≤ J),
Ideal.Quotient.factorₐ R₁ hIJ = Ideal.Quotient.factorₐ R₁ hIJ | true |
ExtremallyDisconnected.casesOn | Mathlib.Topology.ExtremallyDisconnected | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : ExtremallyDisconnected X → Sort u_1} →
(t : ExtremallyDisconnected X) →
((open_closure : ∀ (U : Set X), IsOpen U → IsOpen (closure U)) → motive ⋯) → motive t | false |
_private.Mathlib.Topology.Order.Hom.Esakia.0.PseudoEpimorphismClass.toTopHomClass.match_1 | Mathlib.Topology.Order.Hom.Esakia | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : PartialOrder α] [inst_2 : OrderTop α]
[inst_3 : Preorder β] [inst_4 : OrderTop β] (f : F) (motive : (∃ c, ⊤ ≤ c ∧ f c = ⊤) → Prop)
(x : ∃ c, ⊤ ≤ c ∧ f c = ⊤), (∀ (b : α) (h : ⊤ ≤ b ∧ f b = ⊤), motive ⋯) → motive x | false |
RingSeminorm.ext | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : NonUnitalRing R] {p q : RingSeminorm R}, (∀ (x : R), p x = q x) → p = q | true |
Set.Ioo_add_one_right_eq_Ioc_of_not_isMax | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Add α] [SuccAddOrder α] {b : α},
¬IsMax b → ∀ (a : α), Set.Ioo a (b + 1) = Set.Ioc a b | true |
Function.mulSupport_extend_one | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {N : Type u_4} [inst : One N] {f : ι → κ} {g : ι → N},
Function.Injective f → Function.mulSupport (Function.extend f g 1) = f '' Function.mulSupport g | true |
IsCompact.mul_closedBall | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] {δ : ℝ} {s : Set E},
IsCompact s → 0 ≤ δ → ∀ (x : E), s * Metric.closedBall x δ = x • Metric.cthickening δ s | true |
Lean.ConstantInfo.value? | Lean.Declaration | Lean.ConstantInfo → optParam Bool false → Option Lean.Expr | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.link2._proof_36 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l r : Std.DTreeMap.Internal.Impl α β) (szl : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szl k' v' l' r').Balanced →
l = Std.DTreeMap.Internal.Impl.inner szl k' v' l' r' →
∀ (szr : ℕ) (k'' : α) (v'' : β k'') (l'' ... | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.replaceLPsWithVars._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.Name) → motive (Lean.Level.param a)) → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.divCoeffs.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.divCoeffs c =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.divCoeffs c_1) =
(c = c_1) | true |
Lean.Meta.Simp.State.congrCache._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.CongrCache | false |
CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit_unitIso_hom_app_hom_app | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{w + 1}) C)
(X_1 : CategoryTheory.Discrete PUnit.{w + 1}),
(CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit.unitIso.hom.app X).hom.app X_1 ... | true |
Submodule.quotientEquivPiZMod._proof_1 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | RingHomInvPair (RingHom.id ℤ) (RingHom.id ℤ) | false |
_private.Lean.Widget.UserWidget.0.Lean.Widget.initFn._@.Lean.Widget.UserWidget.2369312278._hygCtx._hyg.2 | Lean.Widget.UserWidget | IO Unit | false |
WithOne.cases_on | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} {P : WithOne α → Prop} (x : WithOne α), P 1 → (∀ (a : α), P ↑a) → P x | true |
CategoryTheory.ObjectProperty.preservesMonomorphisms_ι_of_isNormalEpiCategory | Mathlib.CategoryTheory.Abelian.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFiniteCoproducts C]
[CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] [CategoryTheory.IsNormalEpiCategory C]
... | true |
AlgebraicGeometry.Scheme.germ_residue | Mathlib.AlgebraicGeometry.ResidueField | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (x : ↥X) (hx : x ∈ U),
CategoryTheory.CategoryStruct.comp (X.presheaf.germ U x hx) (X.residue x) = X.evaluation U x hx | true |
Path.cast_rfl_rfl | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), γ.cast ⋯ ⋯ = γ | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.IdealSheafData.glueData._proof_24 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (i j : ↑X.affineOpens),
AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.pullback.fst (I.glueDataObjι (i, j).1) (X.homOfLE ⋯)) | false |
VectorFourier.fourierIntegral | Mathlib.Analysis.Fourier.FourierTransform | {𝕜 : Type u_1} →
[inst : CommRing 𝕜] →
{V : Type u_2} →
[inst_1 : AddCommGroup V] →
[inst_2 : Module 𝕜 V] →
[inst_3 : MeasurableSpace V] →
{W : Type u_3} →
[inst_4 : AddCommGroup W] →
[inst_5 : Module 𝕜 W] →
{E : Type u_4} →
... | true |
Composition.ones._proof_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (n : ℕ) {i : ℕ}, i ∈ List.replicate n 1 → 0 < i | false |
iteratedFDerivWithin_comp_sub | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} (n : ℕ) (a : E),
iteratedFDerivWithin 𝕜 n (fun z => f (z - a)) s x = iteratedFDer... | true |
_private.Std.Internal.Http.Data.Body.Stream.0.Std.Http.Body.Stream.forIn'.loop._unsafe_rec | Std.Internal.Http.Data.Body.Stream | {β : Type} →
(Std.Http.Chunk → β → Std.Internal.IO.Async.ContextAsync (ForInStep β)) →
Std.Http.Body.Stream → β → Std.Internal.IO.Async.ContextAsync β | false |
MulOpposite.instDiscreteTopology | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_1} [inst : TopologicalSpace M] [DiscreteTopology M], DiscreteTopology Mᵐᵒᵖ | true |
IsAddUnit.add_sub_add_left | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : SubtractionCommMonoid α] {c : α}, IsAddUnit c → ∀ (a b : α), c + a - (c + b) = a - b | true |
Nat.card_zmod | Mathlib.SetTheory.Cardinal.Finite | ∀ (n : ℕ), Nat.card (ZMod n) = n | true |
List.pmap_congr_left | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {p q : α → Prop} {f : (a : α) → p a → β} {g : (a : α) → q a → β} (l : List α)
{H₁ : ∀ a ∈ l, p a} {H₂ : ∀ a ∈ l, q a},
(∀ a ∈ l, ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → List.pmap f l H₁ = List.pmap g l H₂ | true |
Finset.sdiff_inter_right_comm | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] (s t u : Finset α), s \ t ∩ u = (s ∩ u) \ t | true |
Std.LawfulLeftIdentity.recOn | Init.Core | {α : Sort u} →
{β : Sort u_1} →
{op : α → β → β} →
{o : α} →
{motive : Std.LawfulLeftIdentity op o → Sort u_2} →
(t : Std.LawfulLeftIdentity op o) →
([toLeftIdentity : Std.LeftIdentity op o] → (left_id : ∀ (a : β), op o a = a) → motive ⋯) → motive t | false |
PresheafOfModules.instFaithfulFunctorOppositeAbToPresheaf | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat},
(PresheafOfModules.toPresheaf R).Faithful | true |
_private.Mathlib.Order.CompleteLattice.Lemmas.0.iSup_iInf_ge_nat_add._simp_1_1 | Mathlib.Order.CompleteLattice.Lemmas | ∀ (n m k : ℕ), n + (m + k) = n + m + k | false |
_private.Init.System.IO.0.IO.CancelToken.mk._flat_ctor | Init.System.IO | IO.Ref Bool → IO.CancelToken | false |
LieEquiv.ofSubalgebras_symm_apply | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (L₁' : LieSubalgebra R L₁) (L₂' : LieSubalgebra R L₂)
(e : L₁ ≃ₗ⁅R⁆ L₂) (h : LieSubalgebra.map e.toLieHom L₁' = L₂') (x : ↥L₂'),
↑((LieEquiv.ofSubalgebra... | true |
MulHom.map_multiset_ne_zero_prod | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} {N : Type u_6} [inst : CommMonoid M] [inst_1 : CommMonoid N] (f : M →ₙ* N) (s : Multiset M),
s ≠ 0 → f s.prod = (Multiset.map (⇑f) s).prod | true |
_private.Lean.Message.0.Lean.MessageData.isTrace._sparseCasesOn_1 | Lean.Message | {motive_1 : Lean.MessageData → Sort u} →
(t : Lean.MessageData) →
((a : Lean.MessageDataContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.withContext a a_1)) →
((a : Lean.NamingContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.withNamingContext a a_1)) →
((a : Lean.Name... | false |
ENNReal.ofNat_lt_top | Mathlib.Data.ENNReal.Basic | ∀ {n : ℕ} [inst : n.AtLeastTwo], OfNat.ofNat n < ⊤ | true |
ProbabilityTheory.Kernel.measure_zero_or_one_of_measurableSet_limsup_atBot | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {s : ι → MeasurableSpace Ω}
{m0 : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μα : MeasureTheory.Measure α} [inst : SemilatticeInf ι]
[NoMinOrder ι] [Nonempty ι],
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.Kernel.iIndep s κ μα ... | true |
Zsqrtd.gcd_eq_zero_iff | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (a : ℤ√d), a.re.gcd a.im = 0 ↔ a = 0 | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective._proof_1_6 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(L : CochainComplex C ℤ) (d : ℤ) [inst_2 : L.IsStrictlyGE d] {K : CochainComplex C ℤ} (f : K ⟶ L) (p q : ℤ)
(hpq : p + 0 = q),
p ≤ ↑0 + d - 1 →
(CochainComplex.HomComplex.δ (-1) 0 0).v p q hpq = (CochainComplex.... | false |
AEMeasurable.mk.congr_simp | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : MeasurableSpace β] {μ μ_1 : MeasureTheory.Measure α}
(e_μ : μ = μ_1) (f f_1 : α → β) (e_f : f = f_1) (h : AEMeasurable f μ) (a a_1 : α),
a = a_1 → AEMeasurable.mk f h a = AEMeasurable.mk f_1 ⋯ a_1 | true |
CategoryTheory.MorphismProperty.Comma.Hom.mk.injEq | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | true |
Filter.distribMulActionFilter._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_1} [inst : Monoid α] [inst_1 : AddMonoid β] [inst_2 : DistribMulAction α β] (x : α),
pure (x • 0) = 0 | false |
CategoryTheory.MorphismProperty.instHasPushoutInrHomDiscretePUnitOfHasPushoutsAlongOfIsStableUnderCobaseChangeAlong | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q : CategoryTheory.MorphismProperty T) {X Y Z : T}
(f : Y ⟶ X) (g : Z ⟶ Y) [P.HasPushoutsAlong f] [inst_2 : P.HasPushoutsAlong g] [P.IsStableUnderCobaseChangeAlong g]
(A : P.Under Q Z), CategoryTheory.Limits.HasPushout (CategoryTheory.Limits.pushout.... | true |
List.decidableBExistsUnique._proof_7 | Mathlib.Logic.ExistsUnique | ∀ {α : Type u_1} (p : α → Prop) (x : α) (xs : List α),
p x →
(∀ y ∈ xs, p y → x = y) →
(fun x_1 => x_1 ∈ x :: xs ∧ p x_1) x ∧ ∀ (y : α), (fun x_1 => x_1 ∈ x :: xs ∧ p x_1) y → y = x | false |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.wittStructureInt_prop._simp_1_1 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] (f : R →+* S₁) (g : σ → S₂) (φ : S₁ →+* S₂) (p : MvPolynomial σ R),
(MvPolynomial.eval₂Hom (φ.comp f) g) p = (MvPolynomial.eval₂Hom φ g) ((MvPolynomial.map f) p) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Util.0.Lean.Grind.Linarith.Poly.gcdCoeffs.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Util | (motive : Lean.Grind.Linarith.Poly → Sort u_1) →
(p : Lean.Grind.Linarith.Poly) →
((k : ℤ) →
(v : Lean.Grind.Linarith.Var) → (p : Lean.Grind.Linarith.Poly) → motive (Lean.Grind.Linarith.Poly.add k v p)) →
(Unit → motive Lean.Grind.Linarith.Poly.nil) → motive p | false |
MeasureTheory.IntegrableOn.integrable_of_ae_notMem_eq_zero | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {mα : MeasurableSpace α} {s : Set α} {μ : MeasureTheory.Measure α} {ε' : Type u_7}
[inst : TopologicalSpace ε'] [inst_1 : ENormedAddMonoid ε'] [TopologicalSpace.PseudoMetrizableSpace ε'] {f : α → ε'},
MeasureTheory.IntegrableOn f s μ → (∀ᵐ (x : α) ∂μ, x ∉ s → f x = 0) → MeasureTheory.Integrable f μ | true |
MeasurableInf.measurable_const_inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} {inst : MeasurableSpace M} {inst_1 : Min M} [self : MeasurableInf M] (c : M), Measurable fun x => c ⊓ x | true |
iInf_psigma' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_8} {κ : ι → Sort u_9} (f : (i : ι) → κ i → α),
⨅ i, ⨅ j, f i j = ⨅ ij, f ij.fst ij.snd | true |
CategoryTheory.Grp.limitAux._proof_10 | Mathlib.CategoryTheory.Monoidal.Cartesian.GrpLimits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J (CategoryTheory.Grp C))
(X : C),
CategoryTheory.Limits.HasLimit
(F.comp
(CategoryTheory.shrink... | false |
ModularGroup.coe_fd | Mathlib.NumberTheory.Modular | UpperHalfPlane.coe '' ModularGroup.fd = {z | 0 < z.im ∧ 1 ≤ ‖z‖ ∧ |z.re| ≤ 1 / 2} | true |
ByteArray.utf8Decode?._proof_1 | Init.Data.String.Basic | ∀ (b : ByteArray), 0 ≤ b.size | false |
Mathlib.Tactic.Ring.Common.ExProdNat.rec | Mathlib.Tactic.Ring.Common | {motive_1 : (e : Q(ℕ)) → Mathlib.Tactic.Ring.Common.ExBaseNat e → Sort u} →
{motive_2 : (e : Q(ℕ)) → Mathlib.Tactic.Ring.Common.ExProdNat e → Sort u} →
{motive_3 : (e : Q(ℕ)) → Mathlib.Tactic.Ring.Common.ExSumNat e → Sort u} →
({e : Q(ℕ)} → (id : ℕ) → motive_1 e (Mathlib.Tactic.Ring.Common.ExBaseNat.atom id... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.