name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Homology.BifunctorAssociator.0.HomologicalComplex.instHasMapProdObjGradedObjectFunctorMapBifunctorMapBifunctorMapObjπX._proof_1 | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_11} {C₂ : Type u_13} {C₁₂ : Type u_9} {C₃ : Type u_7} {C₄ : Type u_5}
[inst : CategoryTheory.Category.{u_10, u_11} C₁] [inst_1 : CategoryTheory.Category.{u_12, u_13} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_7} C₃] [inst_3 : CategoryTheory.Category.{u_4, u_5} C₄]
[inst_4 : CategoryTheory.Catego... | null | false |
SimpleGraph.Subgraph.sup_adj | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {G₁ G₂ : G.Subgraph} {a b : V}, (G₁ ⊔ G₂).Adj a b ↔ G₁.Adj a b ∨ G₂.Adj a b | null | true |
_private.Mathlib.Analysis.LocallyConvex.WeakDual.0.LinearMap.mem_span_iff_continuous._simp_1_1 | Mathlib.Analysis.LocallyConvex.WeakDual | ∀ {ι : Type u_4} {𝕜 : Type u_5} {E : Type u_6} [Finite ι] [inst : Field 𝕜] [t𝕜 : TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜 E] [T0Space 𝕜] {f : ι → E →ₗ[𝕜] 𝕜} (φ : E →ₗ[𝕜] 𝕜),
Continuous ⇑φ = (φ ∈ Submodule.span 𝕜 (Set.range f)) | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks.0.CategoryTheory.Limits.widePushoutShapeOpMap.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type u_1) →
(motive : (x x_1 : CategoryTheory.Limits.WidePushoutShape J) → (x_1 ⟶ x) → Sort u_2) →
(x x_1 : CategoryTheory.Limits.WidePushoutShape J) →
(x_2 : x_1 ⟶ x) →
((X : CategoryTheory.Limits.WidePushoutShape J) →
motive X X (CategoryTheory.Limits.WidePushoutShape.Hom.id X)) →... | null | true |
CategoryTheory.ObjectProperty.LimitOfShape.ofIso | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} J] →
{X : C} → P.LimitOfShape J X → {Y : C} → (X ≅ Y) → P.LimitOfShape J Y | If `X` is a limit indexed by `J` of objects satisfying a property `P`, then
any object that is isomorphic to `X` also is. | true |
Std.TreeMap.Equiv.getEntryGED_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : α × β}, t₁.Equiv t₂ → t₁.getEntryGED k fallback = t₂.getEntryGED k fallback | null | true |
CategoryTheory.Comma.mapLeftComp | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ L₃ : CategoryTheory.Functor A T}... | The functor `Comma L₁ R ⥤ Comma L₃ R` induced by the composition of two natural transformations
`l : L₁ ⟶ L₂` and `l' : L₂ ⟶ L₃` is naturally isomorphic to the composition of the two functors
induced by these natural transformations. | true |
CategoryTheory.GrothendieckTopology.pullbackComp | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{X Y Z : C} →
(f : X ⟶ Y) →
(g : Y ⟶ Z) → J.pullback (CategoryTheory.CategoryStruct.comp f g) ≅ (J.pullback g).comp (J.pullback f) | Pulling back along a composition is naturally isomorphic to
the composition of the pullbacks. | true |
Multiset.Rel.trans | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop) [IsTrans α r] {s t u : Multiset α},
Multiset.Rel r s t → Multiset.Rel r t u → Multiset.Rel r s u | null | true |
Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α},
(f.cycleFactorsFinset = {f}) = f.IsCycle | null | false |
List.replicate_sublist_replicate._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {m n : ℕ} (a : α), (List.replicate m a).Sublist (List.replicate n a) = (m ≤ n) | null | false |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.map_fst_le_of_subset_toEnumFinset._simp_1_4 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
CategoryTheory.Limits.WalkingParallelFamily.Hom.ctorElimType | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive :
(a a_1 : CategoryTheory.Limits.WalkingParallelFamily J) →
CategoryTheory.Limits.WalkingParallelFamily.Hom J a a_1 → Sort u} →
ℕ → Sort (max 1 (imax (w + 1) u)) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
(n : ℕ) → aig.RefVec w → aig.RefVec n → ℕ → Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget aig w | null | true |
MeasureTheory.FiniteMeasure.eq_of_forall_apply_eq | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.FiniteMeasure Ω),
(∀ (s : Set Ω), MeasurableSet s → μ s = ν s) → μ = ν | null | true |
NumberField.InfinitePlace.orbitRelEquiv._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K] [inst_3 : IsGalois k K],
Function.Injective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) ∧
Function.Surjective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) | null | false |
Fin.castLE.eq_1 | Mathlib.Data.Fin.Tuple.Take | ∀ {n m : ℕ} (h : n ≤ m) (i : Fin n), Fin.castLE h i = ⟨↑i, ⋯⟩ | null | true |
Dilation.edist_eq' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (self : α →ᵈ β),
∃ r, r ≠ 0 ∧ ∀ (x y : α), edist (self.toFun x) (self.toFun y) = ↑r * edist x y | null | true |
tangentSpaceCast._proof_5 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (x y : M) (x_1 y_1 : TangentSpace I x),... | null | false |
instHashableFin | Init.Data.Hashable | {n : ℕ} → Hashable (Fin n) | null | true |
ArithmeticFunction.one_smul' | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : ArithmeticFunction M), 1 • b = b | null | true |
DFinsupp.addZeroClass._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddZeroClass (β i)], Function.Injective DFunLike.coe | null | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁_trans._simp_1_10 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Option.getD_eq_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {a b : α}, o.getD a = b ↔ o = some b ∨ o = none ∧ a = b | null | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM_go_succ._proof_7 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {i : ℕ} {xs : Array α} {n : ℕ},
autoParam (i ≤ n) Vector.ofFnM_go_succ._auto_5✝ → ∀ {h : xs.size = i}, ¬i ≤ n + 1 → False | null | false |
Matrix.specialUnitaryGroup.coe_star | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.specialUnitaryGroup n α)), ↑(star A) = star ↑A | null | true |
Algebra.isAlgebraic_adjoin_iff | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDomain R]
{s : Set S}, (Algebra.adjoin R s).IsAlgebraic ↔ ∀ x ∈ s, IsAlgebraic R x | null | true |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.QuotientGroup.mk'_eq_mk'._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (b * a = c) = (a = b⁻¹ * c) | null | false |
PartitionOfUnity.mem_finsupport | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) {i : ι},
i ∈ ρ.finsupport x₀ ↔ i ∈ Function.support fun i => (ρ i) x₀ | null | true |
WittVector.IsocrystalHom._sizeOf_inst | Mathlib.RingTheory.WittVector.Isocrystal | (p : ℕ) →
{inst : Fact (Nat.Prime p)} →
(k : Type u_1) →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
(V : Type u_2) →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
(V₂ : Type ... | null | false |
Lean.Sym.decide_isFalse_congr | Init.Sym.Lemmas | ∀ (p p' : Prop), p = p' → ∀ {inst : Decidable p} {hnp : ¬p'}, decide p = false | null | true |
UInt64.ofFin_bitVecToFin | Init.Data.UInt.Lemmas | ∀ (n : BitVec 64), UInt64.ofFin n.toFin = { toBitVec := n } | null | true |
_private.Init.Grind.Ordered.Ring.0.Lean.Grind.OrderedRing.pos_intCast_of_pos._proof_1_1 | Init.Grind.Ordered.Ring | ∀ (a : ℕ), 0 < Int.negSucc a → False | null | false |
AlgebraicGeometry.IsAffineOpen.isLocalization_stalk | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) (x : ↥U),
IsLocalization.AtPrime (↑(X.presheaf.stalk ↑x)) (hU.primeIdealOf x).asIdeal | null | true |
List.lookmap_congr | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} {f g : α → Option α} {l : List α}, (∀ a ∈ l, f a = g a) → List.lookmap f l = List.lookmap g l | null | true |
_aux_Mathlib_Analysis_Normed_Affine_Isometry___unexpand_AffineIsometryEquiv_1 | Mathlib.Analysis.Normed.Affine.Isometry | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.coeff_prod_mem_ideal_pow_tsub._proof_1_3 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_2} (f : ι → Polynomial R) (I : Ideal R) (n : ι → ℕ) (a : ι)
(s : Finset ι),
((∀ i ∈ s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) → ∀ (k : ℕ), (s.prod f).coeff k ∈ I ^ (s.sum n - k)) →
(∀ i ∈ insert a s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) →
∀ (i j... | null | false |
List.mem_eraseDups._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, (a ∈ l.eraseDups) = (a ∈ l) | null | false |
Int.inductionOn'.pos.match_1.congr_eq_2 | Mathlib.Data.Int.Init | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ) (n : ℕ),
x = n.succ →
(match x with
| 0 => h_1 ()
| n.succ => h_2 n) ≍
h_2 n | null | true |
Lean.Grind.Linarith.Poly.denoteN.match_1 | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Poly → Sort u_1) →
(p : Lean.Grind.Linarith.Poly) →
(Unit → motive Lean.Grind.Linarith.Poly.nil) →
((k : ℤ) →
(v : Lean.Grind.Linarith.Var) →
(p : Lean.Grind.Linarith.Poly) → motive (Lean.Grind.Linarith.Poly.add k v p)) →
motive p | null | false |
Module.End.smulLeft._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
∀ α ∈ Set.center R, ∀ (β : R) (x : M), α • β • x = (RingHom.id R) β • α • x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), (1 < 2 → w + 1 < 2 ^ (w + 1)) → ∀ (n : ℕ), ¬w - (n + 1) < 2 ^ (w + 1) → False | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.processOffset.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) → ((k' : ℕ) → motive (some k')) → ((x : Option ℕ) → motive x) → motive __do_lift | null | false |
IsCoveringMap.liftPath_const | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) {e : E} {x : X} (hpe : x = p e),
cov.liftPath (ContinuousMap.const (↑unitInterval) x) e hpe = ContinuousMap.const (↑unitInterval) e | null | true |
CategoryTheory.leftAdjointOfStructuredArrowInitials._proof_1 | Mathlib.CategoryTheory.Adjunction.Comma | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor D C)
[inst_2 : ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] (x : C) (x_1 Y' : D)
(g : x_1 ⟶ Y') (h : (⊥_ CategoryTheory.Str... | null | false |
String.Slice.PosIterator.recOn | Init.Data.String.Iterate | {s : String.Slice} →
{motive : s.PosIterator → Sort u} →
(t : s.PosIterator) → ((currPos : s.Pos) → motive { currPos := currPos }) → motive t | null | false |
GradedRing.projZeroRingHom' | Mathlib.RingTheory.GradedAlgebra.Basic | {ι : Type u_1} →
{A : Type u_3} →
{σ : Type u_4} →
[inst : Semiring A] →
[inst_1 : DecidableEq ι] →
[inst_2 : AddCommMonoid ι] →
[inst_3 : PartialOrder ι] →
[CanonicallyOrderedAdd ι] →
[inst_5 : SetLike σ A] →
[inst_6 : AddSubmono... | The ring homomorphism from `A` to `𝒜 0` sending every `a : A` to `a₀`. | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.exists_cons_of_leadingCoeff_pos._proof_1_5 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} (η : R),
P.eraseLead.natDegree + 1 = P.natDegree →
∀ (d : ℕ),
P.natDegree = 0 + d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
((Polynomial.X - Polynomial.C η) * P).nextCoeff = 0 →
Polynomial.C η *... | null | false |
SeminormedGroup.ofMulDist._proof_2 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : Norm E] [inst_1 : Group E] [inst_2 : PseudoMetricSpace E],
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist x y ≤ dist (z * x) (z * y)) → ∀ (x y : E), dist x y = ‖x⁻¹ * y‖ | null | false |
Mathlib.Tactic.Superscript.scriptFnNoAntiquot | Mathlib.Util.Superscript | Mathlib.Tactic.Superscript.Mapping → String → Lean.Parser.ParserFn → optParam Bool true → Lean.Parser.ParserFn | The core function for super/subscript parsing. It consists of three stages:
1. Parse a run of superscripted characters, skipping whitespace and stopping when we hit a
non-superscript character.
2. Un-superscript the text and pass the body to the inner parser (usually `term`).
3. Take the resulting `Syntax` object a... | true |
PreTilt.valAux_one | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} [inst_3 : Fact (Nat.Prime p)] [inst_4 : Fact ¬IsUnit ↑p], PreTilt.valAux K v O p 1 = 1 | null | true |
Fintype.decidableForallFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {p : α → Prop} [inst : Fintype α], (∀ a ∈ Finset.univ, p a) ↔ ∀ (a : α), p a | null | false |
_private.Lean.PrettyPrinter.Parenthesizer.0.Lean.PrettyPrinter.categoryParenthesizerAttribute._regBuiltin.Lean.PrettyPrinter.categoryParenthesizerAttribute.docString_1 | Lean.PrettyPrinter.Parenthesizer | IO Unit | null | false |
Set.coe_singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddZeroClass α], ⇑Set.singletonAddMonoidHom = singleton | null | true |
CategoryTheory.IsRegularMono.fac_assoc | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y W : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.IsRegularMono f] (k : W ⟶ Y)
(h :
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.left f) =
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.right f))
{Z : C}... | null | true |
_private.Init.Data.List.Lemmas.0.List.flatMap_eq_nil_iff._simp_1_2 | Init.Data.List.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
AlgEquiv.lift_trdeg_eq | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {R : Type u_2} {A : Type v} {A' : Type v'} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing A']
[inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
Cardinal.lift.{v', v} (Algebra.trdeg R A) = Cardinal.lift.{v, v'} (Algebra.trdeg R A') | null | true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_inv._simp_1_2 | Mathlib.GroupTheory.Perm.Support | ∀ {a b : Prop}, (¬a ↔ ¬b) = (a ↔ b) | null | false |
instDecidableEqSum.decEq | Init.Core | {α : Type u_1} → {β : Type u_2} → [DecidableEq α] → [DecidableEq β] → (x x_1 : α ⊕ β) → Decidable (x = x_1) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.mk'._simp_4 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | null | false |
Vector.map_inj_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {xs : Vector α n} {f g : α → β},
Vector.map f xs = Vector.map g xs ↔ ∀ a ∈ xs, f a = g a | null | true |
commMonTypeEquivalenceCommMon._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ {X Y : CommMonCat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CommMonTypeEquivalenceCommMon.inverse.comp CommMonTypeEquivalenceCommMon.functor).map f)
(let __src := Equiv.refl (CommMonTypeEquivalenceCommMon.inverse.obj Y).X;
{ toEquiv := __src, map_mul' := ⋯ }).toCommMonCatIso.hom =
... | null | false |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go._unary.eq_def | Init.Data.Array.BasicAux | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (as : Array α)
(_x : (i : ℕ) ×' (_ : { bs // bs.size = i }) ×' i ≤ as.size),
Array.mapM'.go._unary✝ f as _x =
PSigma.casesOn _x fun i acc =>
PSigma.casesOn acc fun acc hle =>
if h : i = as.size then pure (h ▸ ... | null | false |
AddAction.vadd_zsmul_movedBy_eq_of_addCommute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h : G},
AddCommute g h → ∀ (j : ℤ), j • h +ᵥ (AddAction.fixedBy α g)ᶜ = (AddAction.fixedBy α g)ᶜ | If `g` and `h` commute, then `g` moves `(j • h) +ᵥ x` iff `g` moves `x`. | true |
IsLocalMax.add | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : AddCommMonoid β] [inst_2 : PartialOrder β]
[IsOrderedAddMonoid β] {f g : α → β} {a : α}, IsLocalMax f a → IsLocalMax g a → IsLocalMax (fun x => f x + g x) a | null | true |
_private.Mathlib.Algebra.Order.SuccPred.WithBot.0.WithBot.one_le_iff_pos._simp_1_1 | Mathlib.Algebra.Order.SuccPred.WithBot | ∀ {α : Type u_1} {x : α} [inst : PartialOrder α] [inst_1 : AddMonoidWithOne α] [ZeroLEOneClass α] [NeZero 1]
[SuccAddOrder α], (1 ≤ x) = (0 < x) | null | false |
List.filterMap_append | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {l l' : List α} {f : α → Option β},
List.filterMap f (l ++ l') = List.filterMap f l ++ List.filterMap f l' | null | true |
Std.HashMap.Raw.getKeyD_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k fallback : α} {v : β}, (m.insert k v).getKeyD k fallback = k | null | true |
basisOfPiSpaceOfLinearIndependent | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | {K : Type u} →
[inst : DivisionRing K] →
{ι : Type u_1} →
[Fintype ι] → [Decidable (Nonempty ι)] → {b : ι → ι → K} → LinearIndependent K b → Module.Basis ι K (ι → K) | In a vector space `ι → K`, a linear independent family indexed by `ι` is a basis. | true |
_private.Mathlib.Algebra.Module.Injective.0.Module.Baer.extension_property_addMonoidHom.match_1_1 | Mathlib.Algebra.Module.Injective | ∀ {Q : Type u_1} [inst : AddCommGroup Q] {M : Type u_3} {N : Type u_2} [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] (f : M →+ N) (g : M →+ Q) (motive : (∃ h, h ∘ₗ f.toIntLinearMap = g.toIntLinearMap) → Prop)
(x : ∃ h, h ∘ₗ f.toIntLinearMap = g.toIntLinearMap),
(∀ (g' : N →ₗ[ℤ] Q) (hg' : g' ∘ₗ f.toIntLinear... | null | false |
CategoryTheory.Limits.limit.post_π_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasColimit F] (G : CategoryTheory.Functor C D)
[inst_4 : CategoryTheory.... | null | false |
CommRingCat.prodFanIsLimit._proof_3 | Mathlib.Algebra.Category.Ring.Constructions | ∀ (A B : CommRingCat) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair A B)) (m : s.pt ⟶ (A.prodFan B).pt),
(∀ (j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp m ((A.prodFan B).π.app j) = s.π.app j) →
m =
CommRingCat.ofHom
((CommRin... | null | false |
Nat.Primes.coe_pnat_inj | Mathlib.Data.PNat.Prime | ∀ (p q : Nat.Primes), ↑p = ↑q ↔ p = q | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._simp_1_24 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
Lean.Meta.Grind.Arith.CommRing.State.ncSemirings | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Array Lean.Meta.Grind.Arith.CommRing.Semiring | Non commutative semirings.
| true |
Lists.Equiv.symm | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {l₁ l₂ : Lists α}, l₁.Equiv l₂ → l₂.Equiv l₁ | null | true |
fderivWithin_fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{x : E} {s : Set E},
UniqueDiffWithinAt 𝕜 s x →
DifferentiableWithinAt 𝕜 f s x →
Dif... | null | true |
ContinuousMulEquiv.coe_trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (e₁ : M ≃ₜ* N) (e₂ : N ≃ₜ* L),
⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reduceDiv._regBuiltin.Nat.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.746960771._hygCtx._hyg.30 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
PiTensorProduct.lift_reindex | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {ι₂ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] {E : Type u_9} [inst_3 : AddCommMonoid E]
[inst_4 : Module R E] (e : ι ≃ ι₂) (φ : MultilinearMap R (fun i => s (e.symm i)) E)
(x : PiTensorProduct... | null | true |
Lean.Compiler.LCNF.CodeDecl.casesOn | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u} →
(t : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF... | null | false |
Tactic.ComputeAsymptotics.WellFormedBasis.tendsto_atTop | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis : Tactic.ComputeAsymptotics.Basis},
Tactic.ComputeAsymptotics.WellFormedBasis basis →
∀ {f : ℝ → ℝ}, f ∈ basis → Filter.Tendsto f Filter.atTop Filter.atTop | All functions from a well-formed basis tend to `atTop`. | true |
CategoryTheory.Functor.representableByUliftFunctorEquiv._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} {X : C},
Function.RightInverse (fun R => { homEquiv := fun {Y} => R.homEquiv.trans Equiv.ulift.symm, homEquiv_comp := ⋯ })
fun R => { homEquiv := fun {Y} => R.homEquiv.trans Equiv.ulift, homEquiv_comp := ⋯ } | null | false |
Std.Internal.List.insertListIfNew._unsafe_rec | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → List ((a : α) × β a) → List ((a : α) × β a) → List ((a : α) × β a) | null | false |
_private.Mathlib.MeasureTheory.Measure.LevyProkhorovMetric.0.MeasureTheory.levyProkhorovEDist_le_of_forall._simp_1_2 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
Std.DTreeMap.Internal.Unit.RocSliceData.ctorIdx | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {inst : Ord α} → Std.DTreeMap.Internal.Unit.RocSliceData α → ℕ | null | false |
Bornology.isVonNBounded_add_self | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousSMul 𝕜 E] [ContinuousAdd E] {s : Set E},
Bornology.IsVonNBounded 𝕜 (s + s) ↔ Bornology.IsVonNBounded 𝕜 s | null | true |
LE.opposite_def | Init.Data.Order.Opposite | ∀ {α : Type u_1} {le : LE α}, le.opposite = { le := fun a b => b ≤ a } | null | true |
AddMonoidAlgebra.prod_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} {ι : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] (s : Finset ι)
(m : ι → M) (r : ι → R),
∏ i ∈ s, AddMonoidAlgebra.single (m i) (r i) = AddMonoidAlgebra.single (∑ i ∈ s, m i) (∏ i ∈ s, r i) | null | true |
Polynomial.IsUnitTrinomial.irreducible_of_coprime' | Mathlib.Analysis.Complex.Polynomial.UnitTrinomial | ∀ {p : Polynomial ℤ},
p.IsUnitTrinomial → (∀ (z : ℂ), ¬((Polynomial.aeval z) p = 0 ∧ (Polynomial.aeval z) p.mirror = 0)) → Irreducible p | A unit trinomial is irreducible if it has no complex roots in common with its mirror. | true |
CategoryTheory.Arrow.mapCechNerve._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (F : f ⟶ g)
(n : SimplexCategoryᵒᵖ) (j : Fin ((Opposite.unop n).len + 1)),
CategoryTheory.CategoryStruct.comp
(Ca... | null | false |
CategoryTheory.MorphismProperty.cons_mem_paths_iff._simp_1 | Mathlib.CategoryTheory.PathCategory.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y Z : C}
{p : Quiver.Path X Y} {f : Y ⟶ Z}, W.paths (p.cons f) = (W.paths p ∧ W f) | null | false |
Submodule.sndEquiv_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (x : ↥(Submodule.snd R M M₂)), (Submodule.sndEquiv R M M₂) x = (↑x).2 | null | true |
ProbabilityTheory.centralMoment_two_eq_variance | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
AEMeasurable X μ → ProbabilityTheory.centralMoment X 2 μ = ProbabilityTheory.variance X μ | null | true |
MeasureTheory.IntegrableOn.congr_set_ae | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s t : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasureTheory.IntegrableOn f t μ → s =ᵐ[μ] t → MeasureTheory.IntegrableOn f s μ | null | true |
_private.Mathlib.Algebra.Order.Floor.Ring.0.Int.image_fract._simp_1_2 | Mathlib.Algebra.Order.Floor.Ring | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
AddRightCancelMonoid.mk._flat_ctor | Mathlib.Algebra.Group.Monoid | {M : Type u_2} →
(zero : M) →
(add : M → M → M) →
(∀ (a b c : M), a + b + c = a + (b + c)) →
(∀ (a : M), 0 + a = a) →
(∀ (a : M), a + 0 = a) →
(nsmul : ℕ → M → M) →
autoParam (∀ (x : M), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n ... | null | false |
HomologicalComplex.instHasHomotopyFiberOfHasBinaryBiproducts | Mathlib.Algebra.Homology.HomotopyFiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {α : Type u_2}
{c : ComplexShape α} {F G : HomologicalComplex C c} (φ : F ⟶ G) [CategoryTheory.Limits.HasBinaryBiproducts C],
HomologicalComplex.HasHomotopyFiber φ | null | true |
ONote.repr_ofNat | Mathlib.SetTheory.Ordinal.Notation | ∀ (n : ℕ), (↑n).repr = ↑n | null | true |
CommSemiRingCat.Hom._mkInternal.inj | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} {hom' hom'_1 : ↑R →+* ↑S}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.