name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhss._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.MatchCond | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Quaternion.coe_real_complex_mul | Mathlib.Analysis.Quaternion | ∀ (r : ℝ) (z : ℂ), r • ↑z = ↑r * ↑z | true |
IsLocalization.instForallPiUniv | Mathlib.RingTheory.Localization.Pi | ∀ {ι : Type u_1} (R : ι → Type u_2) (S : ι → Type u_3) [inst : (i : ι) → CommSemiring (R i)]
[inst_1 : (i : ι) → CommSemiring (S i)] [inst_2 : (i : ι) → Algebra (R i) (S i)] (M : (i : ι) → Submonoid (R i))
[∀ (i : ι), IsLocalization (M i) (S i)], IsLocalization (Submonoid.pi Set.univ M) ((i : ι) → S i) | true |
Homotopy.nullHomotopicMap'_f_eq_zero | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {k₀ : ι},
(∀ (l : ι), ¬c.Rel k₀ l) →
(∀ (l : ι), ¬c.Rel l k₀) → ∀ (h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)), (Homotopy.nullHomotopicMap' h).f k₀... | true |
IsLocalization.AtPrime.coe_orderIsoOfPrime_symm_apply_coe | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (I : Ideal R)
[hI : I.IsPrime] [inst_3 : IsLocalization.AtPrime S I] (a : { p // p.IsPrime ∧ p ≤ I }),
↑↑((RelIso.symm (IsLocalization.AtPrime.orderIsoOfPrime S I)) a) =
⋂ s,
⋂ (_ :
↑↑((OrderIs... | true |
List.subset_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l ⊆ l.dedup | true |
Subring.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsSemitopologicalRing R] (S : Subring R)
{a b : R}, a ∈ S.topologicalClosure.carrier → b ∈ S.topologicalClosure.carrier → a * b ∈ S.topologicalClosure.carrier | false |
USize.ofFin_mk | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < USize.size), USize.ofFin ⟨n, hn⟩ = USize.ofNatLT n hn | true |
LawfulBitraversable.binaturality' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {F G : Type u → Type u}
[inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F] [LawfulApplicative G]
(η : ApplicativeTransformation F G) {α α' β β' : Type u} (f : α → F β) (f' : α' → F β'),
(fun {α} => η.app ... | true |
Finsupp.fst_sumFinsuppAddEquivProdFinsupp | Mathlib.Data.Finsupp.Basic | ∀ {M : Type u_5} [inst : AddMonoid M] {α : Type u_12} {β : Type u_13} (f : α ⊕ β →₀ M) (x : α),
(Finsupp.sumFinsuppAddEquivProdFinsupp f).1 x = f (Sum.inl x) | true |
List.scanrM_map | Init.Data.List.Scan.Lemmas | ∀ {m : Type u_1 → Type u_2} {α₁ : Type u_3} {α₂ : Type u_4} {β : Type u_1} {init : β} [inst : Monad m] [LawfulMonad m]
{f : α₁ → α₂} {g : α₂ → β → m β} {as : List α₁},
List.scanrM g init (List.map f as) = List.scanrM (fun a b => g (f a) b) init as | true |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkPropagateSelfEqFalseProofCore | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Expr → Lean.Meta.Grind.Order.OrderM Lean.Expr | true |
Representation.linearize._proof_2 | Mathlib.RepresentationTheory.Action | ∀ (k : Type u_1) (G : Type u_3) [inst : Monoid G] [inst_1 : Semiring k] (X : Action (Type u_2) G) (x x_1 : G),
Finsupp.lmapDomain k k (X.ρ (x * x_1)) = Finsupp.lmapDomain k k (X.ρ x) * Finsupp.lmapDomain k k (X.ρ x_1) | false |
ContinuousMap.instNonUnitalCommRingOfIsTopologicalRing._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalCommRing β] [IsTopologicalRing β], ContinuousSub β | false |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_8 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (curr : String.Pos.Raw),
¬len.byteIdx < curr.byteIdx → ¬len.byteIdx = curr.byteIdx + (len.byteIdx - curr.byteIdx) → False | false |
SeminormedAddCommGroup.toIsTopologicalAddGroup | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E], IsTopologicalAddGroup E | true |
_private.Lean.Elab.Tactic.Do.Spec.0.Lean.Elab.Tactic.Do.dischargeMGoal | Lean.Elab.Tactic.Do.Spec | {n : Type → Type u_1} →
[Monad n] → [MonadLiftT Lean.MetaM n] → Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.Name → Bool → n Lean.Expr | true |
FirstOrder.Language.BoundedFormula.realize_relabel._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} {m n : ℕ}
{φ : L.BoundedFormula α n} {g : α → β ⊕ Fin m} {v : β → M} {xs : Fin (m + n) → M},
(FirstOrder.Language.BoundedFormula.relabel g φ).Realize v xs =
φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAd... | false |
List.map_zip_eq_zipWith | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α × β → γ} {l : List α} {l' : List β},
List.map f (l.zip l') = List.zipWith (Function.curry f) l l' | true |
Matrix.kroneckerTMulAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | true |
Lean.Widget.HighlightedMsgEmbed._sizeOf_4_eq | Lean.Server.FileWorker.WidgetRequests | ∀ (x : Array (Lean.Widget.TaggedText Lean.Widget.HighlightedMsgEmbed)),
Lean.Widget.HighlightedMsgEmbed._sizeOf_4 x = sizeOf x | false |
tendsto_fib_succ_div_fib_atTop | Mathlib.Analysis.SpecificLimits.Fibonacci | Filter.Tendsto (fun n => ↑(Nat.fib (n + 1)) / ↑(Nat.fib n)) Filter.atTop (nhds Real.goldenRatio) | true |
CommGroup.subgroupOrderIsoSubgroupMonoidHom.eq_1 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_1) (M : Type u_2) [inst : CommGroup G] [inst_1 : Finite G] [inst_2 : CommMonoid M]
[hM : HasEnoughRootsOfUnity M (Monoid.exponent G)],
CommGroup.subgroupOrderIsoSubgroupMonoidHom G M =
{ toFun := fun H => OrderDual.toDual (MonoidHom.restrictHom H Mˣ).ker,
invFun := fun Φ =>
(CommGrou... | true |
Nat.lcm_eq_mul_iff | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = m * n ↔ m = 0 ∨ n = 0 ∨ m.gcd n = 1 | true |
CategoryTheory.Limits.WidePushoutShape.struct._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J}, Z = Z | false |
CategoryTheory.Functor.copyObj.eq_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (obj : C → D) (e : (X : C) → F.obj X ≅ obj X),
F.copyObj obj e =
{ obj := obj,
map := fun {X Y} f =>
CategoryTheory.CategoryStruct.comp (e X).inv... | true |
Basis.le_span'' | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [RankCondition R]
{ι : Type u_2} [inst_4 : Fintype ι] (b : Module.Basis ι R M) {w : Set M} [inst_5 : Fintype ↑w],
Submodule.span R w = ⊤ → Fintype.card ι ≤ Fintype.card ↑w | true |
Module.Baer.extensionOfMaxAdjoin._proof_2 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_2} [inst : Ring R] {Q : Type u_1} [inst_1 : AddCommGroup Q] [inst_2 : Module R Q] {M : Type u_3}
{N : Type u_4} [inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module R M] [inst_6 : Module R N]
(i : M →ₗ[R] N) (f : M →ₗ[R] Q) [inst_7 : Fact (Function.Injective ⇑i)] (h : Module.Baer R Q) ... | false |
List.Vector.get_replicate | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (i : Fin n), (List.Vector.replicate n a).get i = a | true |
Int.sign_eq_neg_one_iff_neg | Init.Data.Int.Order | ∀ {a : ℤ}, a.sign = -1 ↔ a < 0 | true |
ISize.toInt_inj | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, x.toInt = y.toInt ↔ x = y | true |
CategoryTheory.ChosenPullbacksAlong.isoInv_pullback_obj_left | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y X : C} (f : Y ≅ X) (Z : CategoryTheory.Over Y),
((CategoryTheory.ChosenPullbacksAlong.pullback f.inv).obj Z).left = Z.left | true |
Lean.Elab.Term.wrapAsyncAsSnapshot | Lean.Elab.Term.TermElabM | {α : Type} →
(α → Lean.Elab.TermElabM Unit) →
Option IO.CancelToken →
autoParam String Lean.Elab.Term.wrapAsyncAsSnapshot._auto_1 →
Lean.Elab.TermElabM (α → BaseIO Lean.Language.SnapshotTree) | true |
Mathlib.Tactic.Sat.Clause.expr | Mathlib.Tactic.Sat.FromLRAT | Mathlib.Tactic.Sat.Clause → Lean.Expr | true |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.Option.getD.match_1.eq_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match none with
| some x => h_1 x
| none => h_2 ()) =
h_2 () | true |
Real.Angle.abs_toReal_coe_eq_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : ℝ}, |(↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ Real.pi | true |
_private.Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy.0.HomotopicalAlgebra.FibrantObject.instHasQuotientWeakEquivalencesHomRel._simp_1 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.weakEquivalences C f = HomotopicalAlgebra.WeakEquivalence f | false |
Std.TreeSet.getD_max? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {km fallback : α},
t.max? = some km → t.getD km fallback = km | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Init.Tactics | Lean.Macro | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_15 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι} (hbc : b ≤ c) (val : ι)
(property : val ∈ Finset.Ioc a b), ¬val ≤ b → ↑⟨val, ⋯⟩ ∈ Finset.Ioc b c | false |
summable_of_hasFiniteSupport | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.HasSupport], Function.HasFiniteSupport f → Summable f L | true |
Std.Time.Modifier.ctorElimType | Std.Time.Format.Basic | {motive : Std.Time.Modifier → Sort u} → ℕ → Sort (max 1 u) | false |
Lean.IR.Decl.ctorElim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Decl) → ctorIdx = t.ctorIdx → Lean.IR.Decl.ctorElimType ctorIdx → motive t | false |
instIsPredArchimedeanOrderDualOfIsSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α], IsPredArchimedean αᵒᵈ | true |
MulEquiv.val_piUnits_apply | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (f : ((i : ι) → M i)ˣ) (i : ι),
↑(MulEquiv.piUnits f i) = ↑f i | true |
Equiv.isCancelAdd | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Add β] [IsCancelAdd β], IsCancelAdd α | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.uniformContinuous_union.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : Set (α × α)) (a : (Set α × Set α) × Set α × Set α)
(motive : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U) → Prop)
(h : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U)),
(∀ (h₁ : (a.1.1, a.2.1) ∈ hausdorffEntourage U) (h₂ : (a.1.2, a.2.2) ∈ hausdorffEntourag... | false |
_private.Mathlib.Order.UpperLower.Closure.0.IsAntichain.minimal_mem_upperClosure_iff_mem._simp_1_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LE α] {s : Set α} (hs : IsUpperSet s) {a : α}, (a ∈ { carrier := s, upper' := hs }) = (a ∈ s) | false |
_private.Batteries.Data.Array.Scan.0.Array.getElem_succ_scanl._proof_1_4 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {b : β} {as : Array α} {f : β → α → β},
i + 1 ≤ (List.scanl f b as.toList).length → i < (List.scanl f b as.toList).length | false |
RootPairing.RootPositiveForm.posForm._proof_5 | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {S : Type u_1} [inst : CommRing S], RingHomSurjective (RingHom.id S) | false |
_private.Init.Data.String.Basic.0.String.Pos.ofSliceTo_sliceTo._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | false |
Std.DHashMap.Const.get!_inter_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α}, k ∉ m₂ → Std.DHashMap.Const.get! (m₁.inter m₂) k = default | true |
Std.TreeMap.minKey_le_minKey_erase | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{he : (t.erase k).isEmpty = false}, (cmp (t.minKey ⋯) ((t.erase k).minKey he)).isLE = true | true |
contDiffGroupoid_prod | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : 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] {E' : Type u_5} {H' : Type u_6}
[inst_4 : NormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : TopologicalSpace H']
... | true |
LinOrd.hom_comp | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
LinOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (LinOrd.Hom.hom g).comp (LinOrd.Hom.hom f) | true |
_private.Mathlib.Data.Num.Basic.0.PosNum.sqrtAux._unsafe_rec | Mathlib.Data.Num.Basic | PosNum → Num → Num → Num | false |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew.match_1 | Mathlib.Util.WhatsNew | (motive : Lean.Name × Lean.ConstantInfo → Sort u_1) →
(x : Lean.Name × Lean.ConstantInfo) → ((c : Lean.Name) → (i : Lean.ConstantInfo) → motive (c, i)) → motive x | false |
Set.piecewise_preimage | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β) (t : Set β),
s.piecewise f g ⁻¹' t = s.ite (f ⁻¹' t) (g ⁻¹' t) | true |
Submodule.hasDistribPointwiseNeg._proof_3 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] (S : Submodule R A),
(-S).toAddSubmonoid = -S.toAddSubmonoid | false |
Polynomial.normUnit_X | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] [inst_1 : NoZeroDivisors R] [inst_2 : NormalizationMonoid R],
normUnit Polynomial.X = 1 | true |
ProofWidgets.FilterDetailsProps.recOn | ProofWidgets.Component.FilterDetails | {motive : ProofWidgets.FilterDetailsProps → Sort u} →
(t : ProofWidgets.FilterDetailsProps) →
((summary filtered all : ProofWidgets.Html) →
(initiallyFiltered : Bool) →
motive { summary := summary, filtered := filtered, all := all, initiallyFiltered := initiallyFiltered }) →
motive t | false |
CategoryTheory.Limits.functorCategoryHasLimitsOfShape | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Functor K C) | true |
AddSubsemigroup.prod_eq_top_iff | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] [Nonempty M] [Nonempty N] {s : AddSubsemigroup M}
{t : AddSubsemigroup N}, s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ | true |
WeierstrassCurve.Jacobian.Point.toAffineAddEquiv_symm_apply | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] (W : WeierstrassCurve.Jacobian F) [inst_1 : DecidableEq F] (a : W.toAffine.Point),
(WeierstrassCurve.Jacobian.Point.toAffineAddEquiv W).symm a = WeierstrassCurve.Jacobian.Point.fromAffine a | true |
Lean.Server.Snapshots.Snapshot.mk.injEq | Lean.Server.Snapshots | ∀ (stx : Lean.Syntax) (mpState : Lean.Parser.ModuleParserState) (cmdState : Lean.Elab.Command.State)
(stx_1 : Lean.Syntax) (mpState_1 : Lean.Parser.ModuleParserState) (cmdState_1 : Lean.Elab.Command.State),
({ stx := stx, mpState := mpState, cmdState := cmdState } =
{ stx := stx_1, mpState := mpState_1, cmdSt... | true |
Lean.CodeAction.CommandCodeActionEntry.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActionEntry} →
t = t' → Lean.CodeAction.CommandCodeActionEntry.noConfusionType P t t' | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.done.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.done✝ goal = Lean.Meta.Grind.IntroResult.done✝¹ goal' → (goal = goal' → P) → P | false |
HurwitzZeta.hurwitzZetaEven_apply_zero | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle), HurwitzZeta.hurwitzZetaEven a 0 = if a = 0 then -1 / 2 else 0 | true |
Lean.Elab.Command.instInhabitedPreElabHeaderResult | Lean.Elab.MutualInductive | Inhabited Lean.Elab.Command.PreElabHeaderResult | true |
ComplexShape.embeddingDown'Add._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {A : Type u_1} [inst : AddCommSemigroup A] [inst_1 : IsRightCancelAdd A] (a b i₁ i₂ : A),
(ComplexShape.down' a).Rel i₁ i₂ ↔ (ComplexShape.down' a).Rel ((fun x => x + b) i₁) ((fun x => x + b) i₂) | false |
instTransIff | Init.Core | Trans Iff Iff Iff | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₂._proof_4 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B)
(r : ↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) (x : B),
r • x = (Algebra.Smooth.DescentAux.algebra₂._aux_1✝ R D) r *... | false |
CategoryTheory.Limits.hasPullback_op_iff_hasPushout | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.op g.op ↔ CategoryTheory.Limits.HasPushout f g | true |
Real.sinc_apply | Mathlib.Analysis.SpecialFunctions.Trigonometric.Sinc | ∀ {x : ℝ}, Real.sinc x = if x = 0 then 1 else Real.sin x / x | true |
Nucleus.instFrame._proof_4 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (a b : Nucleus X), Lattice.inf a b ≤ b | false |
iSup_symmDiff_iSup_le | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : CompleteBooleanAlgebra α] {f g : ι → α},
symmDiff (⨆ i, f i) (⨆ i, g i) ≤ ⨆ i, symmDiff (f i) (g i) | true |
_private.Mathlib.Algebra.GroupWithZero.Invertible.0.invertibleDiv._simp_1 | Mathlib.Algebra.GroupWithZero.Invertible | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c | false |
Filter.le_map₂_iff | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ},
h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h | true |
Set.image_val_sUnion | Mathlib.Data.Set.Subset | ∀ {α : Type u_2} {A : Set α} {T : Set (Set ↑A)}, Subtype.val '' ⋃₀ T = ⋃₀ {x | ∃ B ∈ T, Subtype.val '' B = x} | true |
Numbering.prefixedEquiv._proof_4 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] (s : Finset X), Fintype.card ↥s ≤ Fintype.card X | false |
Subgroup.transferTransversal | Mathlib.GroupTheory.Transfer | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → G → H.LeftTransversal | true |
AddAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {N : AddSubgroup G} [N.Normal] (a : X),
AddAction.IsBlock G (AddAction.orbit (↥N) a) | true |
Matrix.instPartialOrder | Mathlib.Analysis.Matrix.Order | {𝕜 : Type u_1} → {n : Type u_2} → [RCLike 𝕜] → PartialOrder (Matrix n n 𝕜) | true |
UniformOnFun.instPseudoEMetricSpace._proof_5 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖],
uniformity (UniformOnFun α β 𝔖) = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | false |
ArithmeticFunction.instModule | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid S] → [Module R S] → Module R (ArithmeticFunction S) | true |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Defs___unexpand_Algebra_linearMap_2 | Mathlib.Algebra.Algebra.Defs | Lean.PrettyPrinter.Unexpander | false |
MvPolynomial.aeval_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) {A : Type u_5} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] (f : σ → A) (φ : MvPolynomial σ R),
(MvPolynomial.aeval f) ((MvPolynomial.expand p) φ) = (MvPolynomial.aeval (f ^ p)) φ | true |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor Jᵒᵖ C} → (CategoryTheory.Limits.Cocone F)ᵒᵖ ≌ CategoryTheory.Limits.Cone F.rightOp | true |
_private.Mathlib.Data.Bool.Basic.0.Bool.injective_iff._proof_1_1 | Mathlib.Data.Bool.Basic | ∀ {α : Sort u_1} {f : Bool → α}, f false ≠ f true → ∀ (x y : Bool), f x = f y → x = y | false |
_private.Mathlib.LinearAlgebra.Pi.0.LinearEquiv.piOptionEquivProd._simp_1 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.regularity.match_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x z w : ZFSet.{u_1}) (motive : w ∈ x ∧ w ∈ z → Prop) (x_1 : w ∈ x ∧ w ∈ z),
(∀ (wx : w ∈ x) (wz : w ∈ z), motive ⋯) → motive x_1 | false |
Monotone.antitone_iterate_of_map_le | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → f x ≤ x → Antitone fun n => f^[n] x | true |
lift_rank_range_le | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Cardinal.lift.{v, v'} (Module.rank R ↥f.range) ≤ Cardinal.lift.{v', v} (Module.rank R M) | true |
Nat.lt | Init.Prelude | ℕ → ℕ → Prop | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic.0.IsIntegral.of_pow.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B} {n : ℕ}
(motive : IsIntegral R (x ^ n) → Prop) (hx : IsIntegral R (x ^ n)),
(∀ (p : Polynomial R) (hmonic : p.Monic) (heval : Polynomial.eval₂ (algebraMap R B) (x ^ n) p = 0), motive ⋯) →
motive hx | false |
CategoryTheory.MonObj.mk | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(C... | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithM | Mathlib.Tactic.DefEqAbuse | {m : Type → Type} →
[Monad m] →
{α : Type} →
{β : Type u_1} →
Array β →
(β → m α) →
autoParam α Lean.MessageData.visitWithM._auto_1✝ →
autoParam (α → α → α) Lean.MessageData.visitWithM._auto_3✝ → m α | true |
Lean.Server.Ilean.rec | Lean.Server.References | {motive : Lean.Server.Ilean → Sort u} →
((version : ℕ) →
(module : Lean.Name) →
(directImports : Array Lean.Lsp.ImportInfo) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) →
motive
{ version := version, module := module, directImports :... | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.exists_isBasis.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (X : Set α) (motive : (∃ J, M.IsBasis J X ∧ ∅ ⊆ J) → Prop)
(x : ∃ J, M.IsBasis J X ∧ ∅ ⊆ J), (∀ (w : Set α) (hI : M.IsBasis w X) (right : ∅ ⊆ w), motive ⋯) → motive x | false |
Set.LeftInvOn.image_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.