name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubmonoid.recOn | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
{motive : AddSubmonoid M → Sort u} →
(t : AddSubmonoid M) →
((toAddSubsemigroup : AddSubsemigroup M) →
(zero_mem' : 0 ∈ toAddSubsemigroup.carrier) →
motive { toAddSubsemigroup := toAddSubsemigroup, zero_mem' := zero_mem' }) →
... | null | false |
Std.Http.Protocol.H1.Writer.rec | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Writer dir → Sort u} →
((userData : Array Std.Http.Chunk) →
(outputData : Std.Http.Internal.ChunkedBuffer) →
(state : Std.Http.Protocol.H1.Writer.State) →
(knownSize : Option Std.Http.Body.Length) →
... | null | false |
CentroidHom.copy._proof_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α) (f' : α → α),
f' = ⇑f → ∀ (a b : α), f' (a * b) = a * f' b | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionAssocIso_op | 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] (c c' : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.... | null | true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.tensor | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} {f f' : W.Hom X} {g g' : Y.Hom Z},
CategoryTheory.FreeMonoidalCategory.HomEquiv f f' →
CategoryTheory.FreeMonoidalCategory.HomEquiv g g' →
CategoryTheory.FreeMonoidalCategory.HomEquiv (f.tensor g) (f'.tensor g') | null | true |
RingEquiv.ofLeftInverse._proof_4 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {f : R →+* S} (x y : R),
(↑↑f.rangeRestrict).toFun (x + y) = (↑↑f.rangeRestrict).toFun x + (↑↑f.rangeRestrict).toFun y | null | false |
Affine._aux_Mathlib_LinearAlgebra_AffineSpace_Defs___macroRules_Affine_termAffineSpace_1 | Mathlib.LinearAlgebra.AffineSpace.Defs | Lean.Macro | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.withLams | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | List Lean.FVarId →
Lean.Meta.RefinedDiscrTree.Key → StateT Lean.Meta.RefinedDiscrTree.LazyEntry Lean.MetaM Lean.Meta.RefinedDiscrTree.Key | Sometimes, we need to not index lambda binders, in particular when the body is the application of
a metavariable.
In the case where we do index the lambda binders,
`withLams` efficiently adds the lambdas and `key` to the result.
| true |
Lean.Meta.DiscrTree.Key.format | Lean.Meta.DiscrTree.Basic | Lean.Meta.DiscrTree.Key → Std.Format | null | true |
Ordinal.cof_iSup_le_lift | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {ι : Type u} {f : ι → Ordinal.{max u v}},
(∀ (i : ι), f i < iSup f) → (iSup f).cof ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) | null | true |
_private.Init.Data.Nat.Basic.0.Nat.succ_pred_eq_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
Std.IterM.Partial.find? | Init.Data.Iterators.Consumers.Monadic.Loop | {α β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[inst : Std.Iterator α m β] → [Std.IteratorLoop α m m] → Std.IterM.Partial m β → (β → Bool) → m (Option β) | Returns the first output of the iterator for which the predicate `p` returns `true`, or `none` if
no such output is found.
`O(|it|)`. Short-circuits upon encountering the first match. The elements in `it` are examined in
order of iteration.
This function is deprecated. Instead of `it.allowNontermination.find?`, use `... | true |
CategoryTheory.CommSq.shortComplex'_X₁ | Mathlib.Algebra.Homology.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X₁ X₂ X₃ X₄ : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X₂ X₃] {fst : X₁ ⟶ X₂} {snd : X₁ ⟶ X₃} {f : X₂ ⟶ X₄} {g : X₃ ⟶ X₄}
(sq : CategoryTheory.CommSq fst snd f g), sq.shortComplex'.X₁ = X₁ | null | true |
FundamentalGroupoidFunctor.homotopicMapsNatIso._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)}
(H : f.Homotopy g) ⦃X_1 Y_1 : FundamentalGroupoid X⦄ (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.map f).map f_1) ⟦H.evalAt Y_1.as⟧ =
CategoryTheory.CategoryStruct.comp ⟦H.eva... | null | false |
Filter.instInvolutiveNeg._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : InvolutiveNeg α] (f : Filter α), Filter.map (Neg.neg ∘ Neg.neg) f = f | null | false |
MulEquiv.toFun_eq_coe | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M ≃* N), f.toFun = ⇑f | null | true |
Lean.Meta.Sym.ProofInstInfo.argsInfo | Lean.Meta.Sym.SymM | Lean.Meta.Sym.ProofInstInfo → Array Lean.Meta.Sym.ProofInstArgInfo | Information about each argument position. | true |
USize.ofFin_or | Init.Data.UInt.Bitwise | ∀ (a b : Fin USize.size), USize.ofFin (a ||| b) = USize.ofFin a ||| USize.ofFin b | null | true |
_private.Mathlib.Algebra.Group.Subsemigroup.Basic.0.MulHom.ofDense._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Lean.Order.bot | Init.Internal.Order.Basic | {α : Sort u} → [Lean.Order.CCPO α] → α | The bottom element is the least upper bound of the empty chain.
This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
| true |
Lean.Elab.Command.instMonadEvalTermElabMCommandElabM | Lean.Elab.Command | MonadEval Lean.Elab.TermElabM Lean.Elab.Command.CommandElabM | null | true |
Algebra.intNormAux._proof_3 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Algebra A B] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K] [inst_6 : Algebra K L]
[inst_7 : Algebra A L] [IsScalarTower A K L] [inst_9 : Algebra B L] [IsScalarTower A B L] [IsIntegralClos... | null | false |
CategoryTheory.Iso.hom_inv_id_triangle_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{A B : CategoryTheory.Pretriangulated.Triangle C} (e : A ≅ B),
CategoryTheory.CategoryStruct.comp e.hom.hom₂ e.inv.hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ | null | true |
CategoryTheory.MorphismProperty.Comma.mapLeftIso._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | false |
IsSimpleOrder.completeBooleanAlgebra | Mathlib.Order.Atoms | {α : Type u_2} → [inst : Lattice α] → [inst_1 : BoundedOrder α] → [IsSimpleOrder α] → CompleteBooleanAlgebra α | A simple `BoundedOrder` is also a `CompleteBooleanAlgebra`. | true |
Algebra.Extension.toBaseChange._proof_2 | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Extension R S} (T : Type u_4) [inst_3 : CommRing T] [inst_4 : Algebra R T] (x : P.Ring),
(algebraMap P.baseChange.Ring (TensorProduct R T S)) (Algebra.TensorProduct.includeRight.toRingHom x) =
(algebraM... | null | false |
_private.Init.Data.List.Perm.0.List.perm_iff_count._simp_1_3 | Init.Data.List.Perm | ∀ {a b : ℕ}, (a.succ = b.succ) = (a = b) | null | false |
ValuativeRel.ofValuation._proof_5 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {S : Type u_2} {Γ : Type u_1} [inst : Ring S] [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation S Γ)
{x y : S}, v (x * y) ≤ v (y * x) | null | false |
CategoryTheory.HasWeakSheafify | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
CategoryTheory.GrothendieckTopology C → (A : Type u₂) → [CategoryTheory.Category.{v₂, u₂} A] → Prop | A proposition saying that the inclusion functor from sheaves to presheaves admits a left adjoint.
| true |
LinearEquiv.congrLeft_symm_apply | Mathlib.Algebra.Module.Equiv.Basic | ∀ (M : Type u_5) {M₂ : Type u_7} {M₃ : Type u_8} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] {R : Type u_9} (S : Type u_10) [inst_3 : Semiring R] [inst_4 : Semiring S]
[inst_5 : Module R M₂] [inst_6 : Module R M₃] [inst_7 : Module R M] [inst_8 : Module S M]
[inst_9 : SMulCommC... | null | true |
_private.Init.Data.Array.Lemmas.0.Array.toList_reverse._simp_1_7 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n ≤ n) = True | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_43 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Equiv.embeddingFinSucc_snd | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {ι : Type u_1} (e : Fin (n + 1) ↪ ι), ↑((Equiv.embeddingFinSucc n ι) e).snd = e 0 | null | true |
CommRingCat.HomTopology.precompHomeomorph._proof_4 | Mathlib.Algebra.Category.Ring.Topology | ∀ {R A B : CommRingCat} [inst : TopologicalSpace ↑R] (f : A ≅ B),
Continuous fun x => CategoryTheory.CategoryStruct.comp f.inv x | null | false |
CategoryTheory.Functor.instPreservesEffectiveEpiFamiliesOfIsEquivalence | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [F.IsEquivalence],
F.PreservesEffectiveEpiFamilies | null | true |
PadicInt.toZModHom | Mathlib.NumberTheory.Padics.RingHoms | {p : ℕ} →
[hp_prime : Fact (Nat.Prime p)] →
(v : ℕ) →
(f : ℤ_[p] → ℕ) →
(∀ (x : ℤ_[p]), x - ↑(f x) ∈ Ideal.span {↑v}) →
(∀ (x : ℤ_[p]) (a b : ℕ), x - ↑a ∈ Ideal.span {↑v} → x - ↑b ∈ Ideal.span {↑v} → ↑a = ↑b) → ℤ_[p] →+* ZMod v | `toZModHom` is an auxiliary constructor for creating ring homs from `ℤ_[p]` to `ZMod v`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.mem_support_rotate_iff._proof_1_5 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} [inst : DecidableEq V] (c : G.Walk v v) (u : V) (h : u ∈ c.support),
w ∈ (c.rotate u h).support ↔ w ∈ c.support | null | false |
MultipliableLocallyUniformly.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) [inst_1 : UniformSpace α]
[inst_2 : TopologicalSpace β], MultipliableLocallyUniformly f = ∃ g, HasProdLocallyUniformly f g | null | true |
_private.Mathlib.RingTheory.RingHom.Locally.0.RingHom.locally_stableUnderComposition._simp_1_8 | Mathlib.RingTheory.RingHom.Locally | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | null | false |
CategoryTheory.Limits.Cone.extendHom | 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} →
(s : CategoryTheory.Limits.Cone F) → {X : C} → (f : X ⟶ s.pt) → s.extend f ⟶ s | There is a morphism from an extended cone to the original cone. | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.shiftLeft_add_of_toNat_lt._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt16}, b.toNat + c.toNat < 16 → ¬b.toNat < 16 → False | null | false |
CategoryTheory.Functor.isPointwiseRightKanExtensionOfHasPointwiseLeftDerivedFunctor | Mathlib.CategoryTheory.Functor.Derived.PointwiseLeftDerived | {C : Type u₁} →
{D : Type u₂} →
{H : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} H] →
(F' : CategoryTheory.Functor D H) →
{F : CategoryTheory.Functor C H} →
... | A left derived functor is a pointwise left derived functor when
there exists a pointwise left derived functor. | true |
DirectLimit.instGroup._proof_8 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.slice_lt_slice_iff._simp_1_3 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
_private.Mathlib.Order.CompleteLattice.SetLike.0.CompleteSublattice.mem_sSup._simp_1_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {T : ↥L} {x : X}, (x ∈ T) = (x ∈ L.subtype T) | null | false |
SetRel.dom | Mathlib.Data.Rel | {α : Type u_1} → {β : Type u_2} → SetRel α β → Set α | Domain of a relation. | true |
Equiv.Perm.cycleFactorsAux._proof_13 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (f g : Equiv.Perm α),
(∀ {x : α}, g x ≠ x → f.cycleOf x = g.cycleOf x) →
∀ (x : α),
¬g x = x → ∀ {x_1 : α}, ((f.cycleOf x)⁻¹ * g) x_1 ≠ x_1 → f.cycleOf x_1 = ((f.cycleOf x)⁻¹ * g).cycleOf x_1 | null | false |
_private.Mathlib.Logic.Relation.0.Relation.reflTransGen_transGen._simp_1_1 | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop}, Relation.ReflTransGen r = Relation.ReflGen (Relation.TransGen r) | null | false |
List.ofFn_inj' | Mathlib.Data.List.OfFn | ∀ {α : Type u} {m n : ℕ} {f : Fin m → α} {g : Fin n → α}, List.ofFn f = List.ofFn g ↔ ⟨m, f⟩ = ⟨n, g⟩ | `Fin.sigma_eq_iff_eq_comp_cast` may be useful to work with the RHS of this expression. | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.precheckMatch.match_9 | Lean.Elab.Match | (motive : Option (Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term))) →
((tuples : Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → motive (some tuples)) →
(Unit → motive none) → motive x | null | false |
Batteries.Tactic.generalizeProofsElab | Batteries.Tactic.GeneralizeProofs | Lean.ParserDescr | `generalize_proofs ids* [at locs]?` generalizes proofs in the current goal,
turning them into new local hypotheses.
- `generalize_proofs` generalizes proofs in the target.
- `generalize_proofs at h₁ h₂` generalized proofs in hypotheses `h₁` and `h₂`.
- `generalize_proofs at *` generalizes proofs in the entire local co... | true |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.stabilizer_orbit_eq._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : α} {g : G},
(g • a = a) = (g ∈ MulAction.stabilizer G a) | null | false |
Pi.ofNat_def | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} {π : α → Type u_3} (n : ℕ) [inst : (i : α) → OfNat (π i) n], OfNat.ofNat n = fun x => OfNat.ofNat n | null | true |
lp.instInvolutiveStar._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)]
[inst_1 : (i : α) → StarAddMonoid (E i)] [inst_2 : ∀ (i : α), NormedStarGroup (E i)] (x : ↥(lp E p)),
star (star x) = x | null | false |
Std.DHashMap.Internal.Raw₀.reinsertAux_eq | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α] (data : { d // 0 < d.size }) (a : α) (b : β a),
↑(Std.DHashMap.Internal.Raw₀.reinsertAux hash data a b) =
Std.DHashMap.Internal.updateBucket ↑data ⋯ a fun l => Std.DHashMap.Internal.AssocList.cons a b l | null | true |
AddSubgroup.upperCentralSeriesAux._proof_2 | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : AddGroup G] (n : ℕ), (AddSubgroup.upperCentralSeriesAux G n).fst.Characteristic | null | false |
Lean.Meta.Grind.SplitCandidateWithAnchor.mk | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitInfo → ℕ → Bool → Lean.Expr → UInt64 → Lean.Meta.Grind.SplitCandidateWithAnchor | null | true |
Matrix.linfty_opNorm_replicateCol | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateCol ι v‖ = ‖v‖ | null | true |
Lean.Grind.CommRing.instReprPoly.repr._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Std.Format | null | false |
_private.Init.Data.String.Legacy.0.String.splitAux._unary._proof_1 | Init.Data.String.Legacy | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx | null | false |
_private.Batteries.Data.List.Lemmas.0.List.foldlIdx_const._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_2} {α_1 : Type u_1} {f : α_1 → α → α_1} {i : α_1} {s : ℕ},
List.foldlIdx (Function.const ℕ f) i [] s = List.foldl f i [] | null | false |
Function.HasUncurry.recOn | Mathlib.Logic.Function.Basic | {α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
{motive : Function.HasUncurry α β γ → Sort u} →
(t : Function.HasUncurry α β γ) → ((uncurry : α → β → γ) → motive { uncurry := uncurry }) → motive t | null | false |
AbsoluteValue.toNormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_1} [inst : Ring R] (v : AbsoluteValue R ℝ) (x y : R),
ENNReal.ofReal (v (-x + y)) = ENNReal.ofReal (v (-x + y)) | null | false |
CategoryTheory.Limits.CatCospanTransformMorphism.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | Sort u →
{A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{A' : Type u₄} →
{B' : Type u₅} →
{C' : Type u₆} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Cat... | null | false |
Equiv.Finset.prod._proof_7 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_2} {β : Type u_1} (s : Finset α) (t : Finset β) (x : ↥s × ↥t), (↑⟨(↑x.1, ↑x.2), ⋯⟩).2 ∈ t | null | false |
ENNReal.canLift | Mathlib.Data.ENNReal.Basic | CanLift ENNReal NNReal ENNReal.ofNNReal fun x => x ≠ ⊤ | null | true |
CategoryTheory.Equivalence.faithful_inverse | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {E : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} E]
(e : C ≌ E), e.inverse.Faithful | null | true |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.mk | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (base : X.base ⟶ Y.base) → ((F.map base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber) → X.Hom Y | null | true |
instRingUniversalEnvelopingAlgebra._aux_43 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → ℤ → UniversalEnvelopingAlgebra R L | null | false |
Lean.IR.VarId.mk._flat_ctor | Lean.Compiler.IR.Basic | Lean.IR.Index → Lean.IR.VarId | null | false |
Set.Ico_eq_Ioc_same_iff | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico b a = Set.Ioc b a ↔ ¬b < a | null | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReduced.nodup_rightInvSeq._simp_1_7 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | null | false |
CategoryTheory.Precoverage.Saturate.hcongr_5 | Mathlib.CategoryTheory.Sites.Coverage | ∀ (C C' : Type u_1),
C = C' →
∀ (inst : CategoryTheory.Category.{u_2, u_1} C) (inst' : CategoryTheory.Category.{u_2, u_1} C'),
inst ≍ inst' →
∀ (J : CategoryTheory.Precoverage C) (J' : CategoryTheory.Precoverage C'),
J ≍ J' →
∀ (X : C) (X' : C'),
X ≍ X' →
... | null | true |
_private.Mathlib.Order.UpperLower.Closure.0.upperClosure_min.match_1_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} (_a : α) (motive : _a ∈ ↑(upperClosure s) → Prop)
(x : _a ∈ ↑(upperClosure s)), (∀ (_b : α) (hb : _b ∈ s) (hba : _b ≤ _a), motive ⋯) → motive x | null | false |
_private.Mathlib.Analysis.Calculus.Implicit.0.HasStrictFDerivAt.implicitToOpenPartialHomeomorph._proof_1 | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {F : Type u_1} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace 𝕜 F] [FiniteDimensional 𝕜 F], CompleteSpace F | null | false |
AlgebraicGeometry.Scheme.Modules.pushforwardCongr._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} {f g : X ⟶ Y}, f = g → g.base = f.base | null | false |
AddMonoidAlgebra.ring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] (a b : AddMonoidAlgebra R M), a - b = a + -b | null | false |
Matroid.uniqueBaseOn_inter_isBasis | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, X ⊆ E → (Matroid.uniqueBaseOn I E).IsBasis (X ∩ I) X | null | true |
Graph.map._proof_1 | Mathlib.Combinatorics.Graph.Maps | ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} (f : α → α') (G : Graph α β) ⦃e : β⦄ ⦃x y v w : α'⦄,
Relation.Map (G.IsLink e) f f x y → Relation.Map (G.IsLink e) f f v w → x = v ∨ x = w | null | false |
ShareCommon.Object.ptrEq | Init.ShareCommon | ShareCommon.Object → ShareCommon.Object → Bool | null | true |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp._unsafe_rec | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | null | false |
NumberField.mixedEmbedding.fundamentalCone.equivFinRank._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K],
Fintype.card (Fin (NumberField.Units.rank K)) = Fintype.card { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } | null | false |
Std.Time.Internal.Bounded.LE.ofNatWrapping._proof_7 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (val : ℤ),
lo ≤ lo + (val - lo) % (hi - lo + 1) →
(val - lo) % (hi - lo + 1) < hi - lo + 1 →
lo ≤ ((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ∧
((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ≤ hi | null | false |
AddSubmonoid.comap_map_eq_of_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), AddSubmonoid.comap f (AddSubmonoid.map f S) = S | null | true |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.cast.match_3 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(r : Q(«$R»)) →
(motive :
Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.Common.ExSum Mathlib.Tactic.Ring.RatCoeff sR)
q(«$r») →
Sort u_1) →
(__discr :
Mathlib... | null | false |
Subgroup.map_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {N : Type u_5} [inst_1 : Group N] {P : Type u_6} [inst_2 : Group P]
(g : N →* P) (f : G →* N), Subgroup.map g (Subgroup.map f K) = Subgroup.map (g.comp f) K | null | true |
HasContDiffBump.rec | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{motive : HasContDiffBump E → Sort u} →
((out : Nonempty (ContDiffBumpBase E)) → motive ⋯) → (t : HasContDiffBump E) → motive t | null | false |
AddSubmonoid.IsSpanning.of_le | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : AddGroup G] {M N : AddSubmonoid G}, M.IsSpanning → M ≤ N → N.IsSpanning | null | true |
CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associato... | null | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_of_lt_base | Init.Data.Nat.ToString | ∀ {b n fuel : ℕ} {cs : List Char}, n < b → n < fuel → b.toDigitsCore fuel n cs = n.digitChar :: cs | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Bilinear.0.pow_mulRightLinearMap.match_1_1 | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ (motive : ℕ → Prop) (k : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive k | null | false |
AddCommute.on_refl | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} {S : Type u_3} [inst : Add S] {f : G → S}, Std.Refl fun a b => AddCommute (f a) (f b) | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVExprCache.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → Sort u_1) →
(x : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr)) →
((hit : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → motive (some hit)) →
(Unit → motive none) → motive x | null | false |
ContinuousMapZero.instAddCommMonoid._proof_2 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : AddCommMonoid R] [inst_4 : ContinuousAdd R] (a : ContinuousMapZero X R), 0 + a = a | null | false |
CategoryTheory.ProjectiveResolution.liftCompHomotopy._proof_2 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y)
(R : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp
(Cate... | null | false |
Std.DTreeMap.Internal.Impl.isEmpty_filter!_key_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] {f : α → Bool},
t.WF →
((Std.DTreeMap.Internal.Impl.filter! (fun a x => f a) t).isEmpty = true ↔
∀ (k : α) (h : Std.DTreeMap.Internal.Impl.contains k t = true), f (t.getKey k h) = false) | null | true |
_private.Mathlib.Algebra.Module.StablyFree.FreeOfInvertible.0.Module.free_of_isStablyFree_of_invertible._proof_1_1 | Mathlib.Algebra.Module.StablyFree.FreeOfInvertible | ∀ (R : Type u_1) [inst : CommRing R], Nontrivial R → Nonempty (PrimeSpectrum R) | null | false |
CategoryTheory.MonoidalCategory.tensor._proof_4 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y Z : C × C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f g).1
(CategoryTheory.CategoryStruct.comp f g).2 =
CategoryTheory.Catego... | null | false |
TemperedDistribution.fourierMultiplierCLM.congr_simp | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} (F : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] (g g_1 : E → ℂ),
g = g_1 → TemperedDistribution.fourierMultiplierCLM F g =... | null | true |
derivWithin_congr | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
Set.EqOn f₁ f s → f₁ x = f x → derivWithin f₁ s x = derivWithin f s x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.