name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
RestrictedProduct.homeoBot._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)},
Function.LeftInverse (fun f i => f i) fun f => ⟨fun i => f i, ⋯⟩ | false |
IsScalarTower.invertibleAlgebraCoeNat._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower ℕ R A | false |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_pow_sq_le_div_sq._simp_1_9 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
CategoryTheory.Limits.isColimitCoconeOfHasColimitCurryCompColim._proof_2 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} J]
[inst_1 : CategoryTheory.Category.{u_4, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | false |
IsMulFreimanHom.inv | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : DivisionCommMonoid β] {A : Set α} {B : Set β}
{f : α → β} {n : ℕ}, IsMulFreimanHom n A B f → IsMulFreimanHom n A B⁻¹ f⁻¹ | true |
_private.Mathlib.Algebra.Polynomial.Expand.0.Polynomial.contract_mul_expand._simp_1_2 | Mathlib.Algebra.Polynomial.Expand | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.lt_omega0._simp_1_2 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {c : Cardinal.{u_1}} {o : Ordinal.{u_1}}, (o < c.ord) = (o.card < c) | false |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.recOn | Init.Data.Format.Basic | {motive : Std.Format.SpaceResult✝ → Sort u} →
(t : Std.Format.SpaceResult✝¹) →
((foundLine foundFlattenedHardLine : Bool) →
(space : ℕ) →
motive { foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space }) →
motive t | false |
CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans_map_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (α : F ⟶ G)
{X Y : CategoryTheory.Endofunctor.Coalgebra F} (f : X ⟶ Y),
((CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans α).map f).f = f.f | true |
CategoryTheory.Limits.PreservesColimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | false |
CommRingCat.Colimits.Prequotient._sizeOf_inst | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
(F : CategoryTheory.Functor J CommRingCat) → [SizeOf J] → SizeOf (CommRingCat.Colimits.Prequotient F) | false |
Lean.Elab.Tactic.SimpKind.casesOn | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.SimpKind → Sort u} →
(t : Lean.Elab.Tactic.SimpKind) →
motive Lean.Elab.Tactic.SimpKind.simp →
motive Lean.Elab.Tactic.SimpKind.simpAll → motive Lean.Elab.Tactic.SimpKind.dsimp → motive t | false |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_thickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
PresheafOfModules.surjective_of_epi | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) [CategoryTheory.Epi f] (X : Cᵒᵖ),
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X)) | true |
iInf_lt_top._simp_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (⨅ i, s i < ⊤) = ∃ i, s i < ⊤ | false |
CategoryTheory.Limits.pushout_inl_inv_inr_of_right_isIso_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f] {Z_1 : C} (h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.Limits.push... | true |
SSet.oneTruncation₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {X Y Z : SSet.Truncated 2} (f : X ⟶ Y) (g : Y ⟶ Z),
SSet.OneTruncation₂.map (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (SSet.OneTruncation₂.map f) (SSet.OneTruncation₂.map g) | false |
Lean.Widget.instRpcEncodableInteractiveGoal.enc._@.Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal → StateM Lean.Server.RpcObjectStore Lean.Json | false |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.infer.getParamInfo.match_5 | Lean.Compiler.LCNF.InferBorrow | (motive : Option (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) → Sort u_1) →
(x : Option (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure))) →
((ps : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) → motive (some ps)) →
(Unit → motive none) → motive ... | false |
MulHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [Mul M] → [Mul N] → [FunLike F M N] → Prop | true |
Homeomorph.compStarAlgEquiv'._proof_10 | Mathlib.Topology.ContinuousMap.Star | ∀ {X : Type u_3} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (𝕜 : Type u_4)
[inst_2 : CommSemiring 𝕜] (A : Type u_2) [inst_3 : TopologicalSpace A] [inst_4 : Semiring A]
[inst_5 : IsTopologicalSemiring A] [inst_6 : StarRing A] [inst_7 : ContinuousStar A] [inst_8 : Algebra 𝕜 A]
(f : ... | false |
TopologicalSpace.OpenNhdsOf.mk.sizeOf_spec | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α} [inst_1 : SizeOf α] (toOpens : TopologicalSpace.Opens α)
(mem' : x ∈ toOpens.carrier), sizeOf { toOpens := toOpens, mem' := mem' } = 1 + sizeOf toOpens + sizeOf mem' | true |
Std.HashSet.Raw.contains_empty | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α}, ∅.contains a = false | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_bmod_eq_add_bmod_left._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {n : ℕ} {y : ℤ} (i : ℤ), ((i + x).bmod n = (i + y).bmod n) = (x.bmod n = y.bmod n) | false |
Lean.Parser.Term.ensureTypeOf | Lean.Parser.Term | Lean.Parser.Parser | true |
_private.Mathlib.Geometry.Manifold.Algebra.Monoid.0.contMDiffWithinAt_finset_prod._simp_1_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {ι : Type u_1} {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → CommMonoid (M a)] (a : α) (s : Finset ι)
(g : ι → (a : α) → M a), ∏ c ∈ s, g c a = (∏ c ∈ s, g c) a | false |
Int.tdiv_nonpos_of_nonneg_of_nonpos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → b ≤ 0 → a.tdiv b ≤ 0 | true |
ContinuousNeg.rec | Mathlib.Topology.Algebra.Group.Defs | {G : Type u} →
[inst : TopologicalSpace G] →
[inst_1 : Neg G] →
{motive : ContinuousNeg G → Sort u_1} →
((continuous_neg : Continuous fun a => -a) → motive ⋯) → (t : ContinuousNeg G) → motive t | false |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_19 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam
(∀ (a : X.EllAdicCohomology ℓ n), AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeInductiveDecl.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{decl : Lean.Declaration} →
{indFvars : Array Lean.Expr} →
{numParams : ℤ} →
{rs : Array Lean.Elab.Command.PreElabHeaderResult} →
{decl' : Lean.Declaration} →
{indFvars' : Array Lean.Expr} →
{numParams' : ℤ} →
{rs' : Array Lean.Elab.... | false |
AlgebraicGeometry.Scheme.pretopology.congr_simp | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P P_1 : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) (e_P : P = P_1) [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative], AlgebraicGeometry.Scheme.pretopology P = AlgebraicGeometry.Scheme.pretopology P_1 | true |
CFC.rpow_mul_rpow_neg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] {a : A} (x : ℝ),
autoParam (IsStrictlyPositive a) CFC.rpow... | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.append.match_1_9 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (x y : α) (a : Batteries.RBNode α) (x_1 : α) (b : Batteries.RBNode α)
(motive :
Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.red a x_1 b) ∧
Batteries.RBNode.All (fun x_2 => Batteries.RBNode.cmpLT cmp x x_2)
(Batteries.RBNode.no... | false |
HasProd.congr_cofinite₀ | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {K : Type u_4} [inst : CommGroupWithZero K] [inst_1 : TopologicalSpace K] [SeparatelyContinuousMul K]
{f g : α → K} {c : K},
HasProd f c →
∀ {s : Finset α}, (∀ a ∈ s, f a ≠ 0) → (∀ a ∉ s, f a = g a) → HasProd g (c * ((∏ i ∈ s, g i) / ∏ i ∈ s, f i)) | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_iff_pair_subset.match_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u_1} {s : Set α} (motive : (∃ x y, x ≠ y ∧ {x, y} ⊆ s) → Prop) (H : ∃ x y, x ≠ y ∧ {x, y} ⊆ s),
(∀ (w w_1 : α) (hxy : w ≠ w_1) (h : {w, w_1} ⊆ s), motive ⋯) → motive H | false |
_private.Mathlib.Topology.Homotopy.LocallyContractible.0.instStronglyLocallyContractibleSpaceProd.match_9 | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (x : X) (y : Y) (Ux : Set X)
(Uy : Set Y)
(motive :
(match (x, y) with
| (x, y) =>
match (Ux, Uy) with
| (Ux, Uy) => (Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) ∧ Uy ∈ nhds y ∧ ContractibleSpace ↑Uy) →
... | false |
Finite.Set.finite_range | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {ι : Sort w} (f : ι → α) [Finite ι], Finite ↑(Set.range f) | true |
Submodule.smithNormalFormOfLE._proof_8 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_3} {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (b : Module.Basis ι R M)
(N O : Submodule R M) (N_le_O : N ≤ O),
∃ o,
∃ (hno : Classical.choose ⋯ ≤ o),
∃ bO bN a... | false |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.isLimitFiniteSubproductsCone | Mathlib.CategoryTheory.Limits.Constructions.Filtered | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{α : Type w} →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
(f : α → C) →
[CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C] →
[inst_3 : CategoryTheory.Limits.HasProduct f] →
... | true |
BoxIntegral.unitPartition.mem_prepartition_iff | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] [inst_1 : Fintype ι] {B I : BoxIntegral.Box ι},
I ∈ BoxIntegral.unitPartition.prepartition n B ↔
∃ ν ∈ BoxIntegral.unitPartition.admissibleIndex n B, BoxIntegral.unitPartition.box n ν = I | true |
inner_conj_symm | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | true |
Submonoid.isLocalizationMap_of_group | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {S : Submonoid M} {f : M → G},
Function.Injective f → (∀ (g : G), ∃ x, ∃ y ∈ S, g = f x / f y) → S.IsLocalizationMap f | true |
Multiset.map_univ_coe | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map (fun x => x.fst) Finset.univ.val = m | true |
Quotient.hrecOn | Init.Core | {α : Sort u} →
{s : Setoid α} →
{motive : Quotient s → Sort v} →
(q : Quotient s) → (f : (a : α) → motive ⟦a⟧) → (∀ (a b : α), a ≈ b → f a ≍ f b) → motive q | true |
Mathlib.Tactic.BicategoryLike.Mor₁.tgt._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Obj | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso_hom_app | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso X Y... | true |
Lean.Compiler.LCNF.MonadCodeBind.rec | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)) →
motive { codeBind := codeBind }) ... | false |
Nat.nth_apply_eq_orderIsoOfNat | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ), Nat.nth p n = ↑((Nat.Subtype.orderIsoOfNat (setOf p)) n) | true |
_private.Mathlib.Data.Set.Function.0.Set.bijOn_singleton._simp_1_2 | Mathlib.Data.Set.Function | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Array.mkSlice_roi_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Roo.Sliceable.mkSlice xs lo<...xs.size | true |
SimplicialObject.Split.Hom.mk.injEq | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (F : S₁.X ⟶ S₂.X)
(f : (n : ℕ) → S₁.s.N n ⟶ S₂.s.N n)
(comm :
autoParam
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (S₁.s.ι n) (F.app (Opposite.op (SimplexCategory.mk n))) =
CategoryTheor... | true |
ProjectiveSpectrum | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] → [inst_2 : AddSubmonoidClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → Type u_1 | true |
mdifferentiableAt_add_left | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Add G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContMDiffAdd I 1 G] {... | true |
Ordnode.merge_nil_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (t : Ordnode α), Ordnode.nil.merge t = t | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_insert_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Fin.instMax_mathlib._proof_1 | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (x y : Fin n), max ↑x ↑y < n | false |
AlgHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [IsNoetherianRing A] {f : A →ₐ[R] B},
f.FiniteType ↔ f.FinitePresentation | true |
MeasureTheory.measure_preimage_add_right | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (g : G) (A : Set G), μ ((fun h => h + g) ⁻¹' A) = μ A | true |
LinearMap.IsPerfPair.restrictScalars_of_field | Mathlib.LinearAlgebra.PerfectPairing.Restrict | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module L M] [inst_6 : Module L N] [inst_7 : Module K M]
[inst_8 : Module K N] [inst_9 : IsScalarTower K L M] (p : M →ₗ[L] N →ₗ[L] L) ... | true |
Std.ExtTreeMap.maxKey.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeMap α β cmp)
(e_t : t = t_1) (h : t ≠ ∅), t.maxKey h = t_1.maxKey ⋯ | true |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstancesImpAux | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → Array Lean.Expr → ℕ → n α → n α | true |
Lean.Meta.Sym.ExprPtr.mk.inj | Lean.Meta.Sym.ExprPtr | ∀ {expr expr_1 : Lean.Expr}, { expr := expr } = { expr := expr_1 } → expr = expr_1 | true |
RestrictedProduct.instZSMul._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → SubNegMonoid (R i)] [∀ (i : ι), AddSubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (n : ℤ), ∀ᶠ (x_1 : ι) in 𝓕, n • x x_1 ∈ ↑(B... | false |
ComplexShape.down' | Mathlib.Algebra.Homology.ComplexShape | {α : Type u_2} → [inst : Add α] → [IsRightCancelAdd α] → α → ComplexShape α | true |
CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f], (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app none = g | true |
LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | true |
MulSemiringActionHomClass.toMulSemiringActionHom._proof_6 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_4} [inst : Monoid M] {N : Type u_5} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_2} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_1} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S] {F : Type u_3}
[inst_6 : FunLike F R S] [inst_7 : MulSemiringActionSemiHomClass F (⇑φ) R S] (... | false |
String.Pos.Raw.byteIdx_unoffsetBy | Init.Data.String.PosRaw | ∀ {p offset : String.Pos.Raw}, (p.unoffsetBy offset).byteIdx = p.byteIdx - offset.byteIdx | true |
Std.Sat.AIG.RefVec.fold.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Fold | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f]
(_x : (aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len) (idx : ℕ) (h1 : idx < _x.1.decls... | false |
Lean.Parser.Command.eoi._regBuiltin.Lean.Parser.Command.eoi.formatter_3 | Lean.Parser.Command | IO Unit | false |
Ordinal.iSup_eq_lsub_or_succ_iSup_eq_lsub | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (f : ι → Ordinal.{max u_5 u_4}), iSup f = Ordinal.lsub f ∨ Order.succ (iSup f) = Ordinal.lsub f | true |
one_div_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (1 / a < b ↔ 1 / b < a) | true |
Finset.ite_prod_one | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s : Finset ι) (f : ι → M),
(if p then ∏ x ∈ s, f x else 1) = ∏ x ∈ s, if p then f x else 1 | true |
DifferentiableWithinAt.insert' | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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 : E → F} {x : E} {s : Set E} [T1Space E] {y : E},
DifferentiableWithi... | true |
SemidirectProduct.lift | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : Group N] →
[inst_1 : Group G] →
[inst_2 : Group H] →
{φ : G →* MulAut N} →
(fn : N →* H) →
(fg : G →* H) →
(∀ (g : G),
fn.comp (MulEquiv.toMonoidHom ... | true |
List.getLast_replicate_succ | Mathlib.Data.List.Basic | ∀ {α : Type u} (m : ℕ) (a : α), (List.replicate (m + 1) a).getLast ⋯ = a | true |
FiberBundleCore.localTriv_symm_apply | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι) (p : B × F),
↑(Z.localTriv i).symm p = ⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_insert_self._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 |
Finset.sum_range_tsub | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [inst_2 : Sub M] [OrderedSub M] [AddLeftMono M]
[AddLeftReflectLE M] [ExistsAddOfLE M] {f : ℕ → M},
Monotone f → ∀ (n : ℕ), ∑ i ∈ Finset.range n, (f (i + 1) - f i) = f n - f 0 | true |
Set.Finite.exists_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s | true |
CategoryTheory.isPreconnected_op | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsPreconnected J],
CategoryTheory.IsPreconnected Jᵒᵖ | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.ComonObj A] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (A.map f) Categ... | false |
Module.Presentation.cokernel_relation | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁) (hg₁ : Submodule.span A (Set.range g₁) = ... | true |
SubAddAction.SMulMemClass.subtype._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_3} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] {A : Type u_2} [inst_2 : SetLike A M]
[hA : VAddMemClass A R M] (S' : A) (x : R) (x_1 : ↥S'), ↑(x +ᵥ x_1) = ↑(x +ᵥ x_1) | false |
Real.smoothTransition.one_of_one_le | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, 1 ≤ x → x.smoothTransition = 1 | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | true |
isStablyFiniteRing_iff | Mathlib.Data.Matrix.Mul | ∀ (R : Type u_10) [inst : MulOne R] [inst_1 : AddCommMonoid R],
IsStablyFiniteRing R ↔ ∀ (n : ℕ), IsDedekindFiniteMonoid (Matrix (Fin n) (Fin n) R) | true |
CompareReals.instCommRingQ._proof_7 | Mathlib.Topology.UniformSpace.CompareReals | ∀ (a : CompareReals.Q), a + 0 = a | false |
TopCommRingCat.forgetToTopCatCommRing | Mathlib.Topology.Category.TopCommRingCat | (R : TopCommRingCat) → CommRing ↑((CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | true |
_private.Mathlib.Topology.Compactness.CompactSystem.0.IsCompactSystem.insert_univ._proof_1_2 | Mathlib.Topology.Compactness.CompactSystem | ∀ {α : Type u_1} {S : Set (Set α)} (s : ℕ → Set α),
(∀ (i : ℕ), s i ∈ insert Set.univ S) →
∀ (h₀ : ∃ n, s n ∈ S) (x : α),
(∀ (i : ℕ), x ∈ s i) ↔ ∀ (i : ℕ), x ∈ (fun i => if s i ∈ S then s i else s (Nat.find h₀)) i | false |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq.match_1 | Std.Time.Time.PlainTime | (motive : Std.Time.PlainTime → Std.Time.PlainTime → Sort u_1) →
(x x_1 : Std.Time.PlainTime) →
((a : Std.Time.Hour.Ordinal) →
(a_1 : Std.Time.Minute.Ordinal) →
(a_2 : Std.Time.Second.Ordinal true) →
(a_3 : Std.Time.Nanosecond.Ordinal) →
(b : Std.Time.Hour.Ordinal) →
... | false |
instBialgebraCarrierUnopCommAlgCatOfMonObjOpposite._proof_10 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_1} [inst : CommRing R] (A : (CommAlgCat R)ᵒᵖ),
AlgHomClass (↑(Opposite.unop A) ≃ₐ[R] TensorProduct R R ↑(Opposite.unop A)) R (↑(Opposite.unop A))
(TensorProduct R R ↑(Opposite.unop A)) | false |
_private.Lean.Meta.Tactic.Grind.CollectParams.0.Lean.Meta.Grind.collectParams.match_1 | Lean.Meta.Tactic.Grind.CollectParams | (motive : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam → Sort u_1) →
(__discr : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam) →
((fst : Bool) → (params anchors : Array Lean.Meta.Grind.TParam) → motive (fst, params, anchors)) → motive __discr | false |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_4 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_2} {β : Type u_1} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ≤
AddSubgroup.comap ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩)
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) | false |
UInt32.toNat_toBitVec | Init.Data.UInt.Lemmas | ∀ (x : UInt32), x.toBitVec.toNat = x.toNat | true |
Int32.toInt_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt64.toInt = x.toInt | true |
CategoryTheory.ObjectProperty.full_ιOfLE | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P P' : CategoryTheory.ObjectProperty C} (h : P ≤ P'),
(CategoryTheory.ObjectProperty.ιOfLE h).Full | true |
String.Slice.Pattern.Model.SlicesFrom | Init.Data.String.Lemmas.Pattern.Split | {s : String.Slice} → s.Pos → Type | true |
NonemptyFinLinOrd.dualEquiv._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ (X : NonemptyFinLinOrd),
CategoryTheory.CategoryStruct.comp
(NonemptyFinLinOrd.dual.map
((CategoryTheory.NatIso.ofComponents (fun X => NonemptyFinLinOrd.Iso.mk (OrderIso.dualDual ↑X.toLinOrd))
@NonemptyFinLinOrd.dualEquiv._proof_1).hom.app
X))
((CategoryTheory.NatIso.of... | false |
Std.HashMap.getElem!_filter' | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] [inst : Inhabited β]
{f : α → β → Bool} {k : α}, (Std.HashMap.filter f m)[k]! = (Option.filter (f k) m[k]?).get! | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.