name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q)),
(match Turing.TM0to1.Λ'.normal q with
| Turing.TM0to1.Λ'.normal q => h_1 q
| Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q => h_2 d q
| Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q => h_3 a q) =
h_1 q |
Bundle.Trivialization.piecewise._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_1} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e e' : Bundle.Trivialization F proj) (s : Set B),
e.baseSet ∩ frontier s = e'.baseSet ∩ frontier s →
e.source ∩ frontier (proj ⁻¹' s) = e'.source ∩ frontier (proj ⁻¹' s) |
Std.TreeSet.Raw.max?_le_max?_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k km kmi : α},
t.max? = some km → (t.insert k).max?.get ⋯ = kmi → (cmp km kmi).isLE = true |
ContinuousOn.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℂ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ a ∈ s, f a ∈ Complex.slitPlane) → ContinuousOn (fun x => f x ^ g x) s |
AddCircle.equivIco | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : AddCommGroup 𝕜] →
(p : 𝕜) →
[inst_1 : LinearOrder 𝕜] →
[IsOrderedAddMonoid 𝕜] → [hp : Fact (0 < p)] → (a : 𝕜) → [Archimedean 𝕜] → AddCircle p ≃ ↑(Set.Ico a (a + p)) |
_private.Std.Time.Date.ValidDate.0.PSigma.casesOn._arg_pusher | Std.Time.Date.ValidDate | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
MvPolynomial.expand_char | Mathlib.RingTheory.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (p : ℕ) [inst_1 : ExpChar R p] {f : MvPolynomial σ R},
(MvPolynomial.map (frobenius R p)) ((MvPolynomial.expand p) f) = f ^ p |
Mathlib.Util.«_aux_Mathlib_Util_CompileInductive___elabRules_Mathlib_Util_commandCompile_def%__1» | Mathlib.Util.CompileInductive | Lean.Elab.Command.CommandElab |
Int32.toInt_not | Init.Data.SInt.Bitwise | ∀ (a : Int32), (~~~a).toInt = (-a.toInt - 1).bmod (2 ^ 32) |
SubMulAction.subtype_eq_val | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M), ⇑p.subtype = Subtype.val |
Lean.Elab.Term.State.mk.injEq | Lean.Elab.Term.TermElabM | ∀ (levelNames : List Lean.Name) (syntheticMVars : Lean.MVarIdMap Lean.Elab.Term.SyntheticMVarDecl)
(pendingMVars : List Lean.MVarId) (mvarErrorInfos : List Lean.Elab.Term.MVarErrorInfo)
(levelMVarErrorInfos : List Lean.Elab.Term.LevelMVarErrorInfo) (mvarArgNames : Lean.MVarIdMap Lean.Name)
(letRecsToLift : List Lean.Elab.Term.LetRecToLift) (levelNames_1 : List Lean.Name)
(syntheticMVars_1 : Lean.MVarIdMap Lean.Elab.Term.SyntheticMVarDecl) (pendingMVars_1 : List Lean.MVarId)
(mvarErrorInfos_1 : List Lean.Elab.Term.MVarErrorInfo)
(levelMVarErrorInfos_1 : List Lean.Elab.Term.LevelMVarErrorInfo) (mvarArgNames_1 : Lean.MVarIdMap Lean.Name)
(letRecsToLift_1 : List Lean.Elab.Term.LetRecToLift),
({ levelNames := levelNames, syntheticMVars := syntheticMVars, pendingMVars := pendingMVars,
mvarErrorInfos := mvarErrorInfos, levelMVarErrorInfos := levelMVarErrorInfos, mvarArgNames := mvarArgNames,
letRecsToLift := letRecsToLift } =
{ levelNames := levelNames_1, syntheticMVars := syntheticMVars_1, pendingMVars := pendingMVars_1,
mvarErrorInfos := mvarErrorInfos_1, levelMVarErrorInfos := levelMVarErrorInfos_1,
mvarArgNames := mvarArgNames_1, letRecsToLift := letRecsToLift_1 }) =
(levelNames = levelNames_1 ∧
syntheticMVars = syntheticMVars_1 ∧
pendingMVars = pendingMVars_1 ∧
mvarErrorInfos = mvarErrorInfos_1 ∧
levelMVarErrorInfos = levelMVarErrorInfos_1 ∧
mvarArgNames = mvarArgNames_1 ∧ letRecsToLift = letRecsToLift_1) |
Encodable.decode₂_is_partial_inv | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α], Function.IsPartialInv Encodable.encode (Encodable.decode₂ α) |
Polynomial.Monic.degree_le_zero_iff_eq_one | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → (p.degree ≤ 0 ↔ p = 1) |
Ordinal.nfp_mul_eq_opow_omega0 | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {a b : Ordinal.{u_1}}, 0 < b → b ≤ a ^ Ordinal.omega0 → Ordinal.nfp (fun x => a * x) b = a ^ Ordinal.omega0 |
instFullWitness | Mathlib.CategoryTheory.UnivLE | ∀ [inst : UnivLE.{max u v, v}], UnivLE.witness.Full |
_private.Mathlib.Topology.ContinuousMap.CompactlySupported.0.CompactlySupportedContinuousMap.nnrealPart_smul_neg._simp_1_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b : R} [ExistsAddOfLE R] [MulPosMono R] [AddRightMono R]
[AddRightReflectLE R], a ≤ 0 → b ≤ 0 → (0 ≤ a * b) = True |
Std.Tactic.BVDecide.BVExpr.Cache.Key.w | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | Std.Tactic.BVDecide.BVExpr.Cache.Key → ℕ |
Lean.Parser.ParserExtension.Entry.category.sizeOf_spec | Lean.Parser.Extension | ∀ (catName declName : Lean.Name) (behavior : Lean.Parser.LeadingIdentBehavior),
sizeOf (Lean.Parser.ParserExtension.Entry.category catName declName behavior) =
1 + sizeOf catName + sizeOf declName + sizeOf behavior |
CategoryTheory.MorphismProperty.Over.pullbackComp._proof_2 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) [inst_2 : P.IsStableUnderBaseChangeAlong f]
[inst_3 : P.IsStableUnderBaseChangeAlong g] [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.HasPullbacksAlong g]
[inst_6 : Q.IsStableUnderBaseChange] (fg : X ⟶ Z) (hfg : fg = CategoryTheory.CategoryStruct.comp f g)
(X_1 : P.Over Q Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.congrHom ⋯ hfg ≪≫
(CategoryTheory.Limits.pullbackLeftPullbackSndIso X_1.hom g f).symm).hom
(((CategoryTheory.MorphismProperty.Over.pullback P Q g).comp
(CategoryTheory.MorphismProperty.Over.pullback P Q f)).obj
X_1).hom =
((CategoryTheory.MorphismProperty.Over.pullback P Q fg).obj X_1).hom |
Set.MapsTo.vadd_set | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} {F : Type u_4} [inst : VAdd M α] [inst_1 : VAdd M β]
[inst_2 : FunLike F α β] [AddActionHomClass F M α β] {f : F} {s : Set α} {t : Set β},
Set.MapsTo (⇑f) s t → ∀ (c : M), Set.MapsTo (⇑f) (c +ᵥ s) (c +ᵥ t) |
Codisjoint.map | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[inst_3 : OrderTop α] [inst_4 : OrderTop β] [TopHomClass F α β] [SupHomClass F α β] {a b : α} (f : F),
Codisjoint a b → Codisjoint (f a) (f b) |
NonUnitalStarSubalgebra.map | Mathlib.Algebra.Star.NonUnitalSubalgebra | {F : Type v'} →
{R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : Module R B] →
[inst_6 : Star B] →
[inst_7 : FunLike F A B] →
[NonUnitalAlgHomClass F R A B] →
[StarHomClass F A B] → F → NonUnitalStarSubalgebra R A → NonUnitalStarSubalgebra R B |
PrimeSpectrum.instNonemptyOfNontrivial | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] [Nontrivial R], Nonempty (PrimeSpectrum R) |
Real.Angle.sign_two_nsmul_eq_neg_sign_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (2 • θ).sign = -θ.sign ↔ θ = 0 ∨ Real.pi / 2 < |θ.toReal| |
List.Perm.eq_reverse_of_sortedLE_of_sortedGE | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : PartialOrder α] {l₁ l₂ : List α}, l₁.Perm l₂ → l₁.SortedLE → l₂.SortedGE → l₁ = l₂.reverse |
nonempty_linearEquiv_of_lift_rank_eq | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [Module.Free R M] [inst_5 : AddCommMonoid M'] [inst_6 : Module R M'] [Module.Free R M'],
Cardinal.lift.{v', v} (Module.rank R M) = Cardinal.lift.{v, v'} (Module.rank R M') → Nonempty (M ≃ₗ[R] M') |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_316 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
List.idxOfNth w_1 [g a, g (g a)] (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[1] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[1] <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
PointwiseConvergenceCLM.coeLMₛₗ | Mathlib.Topology.Algebra.Module.PointwiseConvergence | {𝕜₁ : Type u_4} →
{𝕜₂ : Type u_5} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_7) →
(F : Type u_8) →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : AddCommGroup F] →
[inst_5 : TopologicalSpace F] →
[inst_6 : IsTopologicalAddGroup F] →
[inst_7 : Module 𝕜₁ E] →
[inst_8 : Module 𝕜₂ F] →
[inst_9 : ContinuousConstSMul 𝕜₂ F] → (E →SLₚₜ[σ] F) →ₗ[𝕜₂] E →ₛₗ[σ] F |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_unit._autoParam | Mathlib.CategoryTheory.Adjunction.Basic | Lean.Syntax |
Real.cosPartialEquiv._proof_5 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ θ ∈ Set.Icc 0 Real.pi, θ ≤ Real.pi |
AddSubgroup.relIndex_eq_one._simp_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, (H.relIndex K = 1) = (K ≤ H) |
AlgebraicGeometry.Scheme.Hom | Mathlib.AlgebraicGeometry.Scheme | AlgebraicGeometry.Scheme → AlgebraicGeometry.Scheme → Type u_1 |
AdicCompletion.map_of | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_3} [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M),
(AdicCompletion.map I f) ((AdicCompletion.of I M) x) = (AdicCompletion.of I N) (f x) |
Std.DTreeMap.toList_rci | Std.Data.DTreeMap.Slice | ∀ {α : Type u} {β : α → Type v} (cmp : autoParam (α → α → Ordering) Std.DTreeMap.toList_rci._auto_1) [Std.TransCmp cmp]
{t : Std.DTreeMap α β cmp} {bound : α},
Std.Slice.toList (Std.Rci.Sliceable.mkSlice t bound...*) = List.filter (fun e => (cmp e.fst bound).isGE) t.toList |
ContMDiff.smul | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} {V : Type u_12}
[inst_6 : NormedAddCommGroup V] [inst_7 : NormedSpace 𝕜 V] {f : M → 𝕜} {g : M → V},
ContMDiff I (modelWithCornersSelf 𝕜 𝕜) n f →
ContMDiff I (modelWithCornersSelf 𝕜 V) n g → ContMDiff I (modelWithCornersSelf 𝕜 V) n fun p => f p • g p |
LinearMap.lift_rank_le_of_surjective | 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'),
Function.Surjective ⇑f → Cardinal.lift.{v, v'} (Module.rank R M') ≤ Cardinal.lift.{v', v} (Module.rank R M) |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
Function.Injective (Quotient.lift (NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K) ⋯) ∧
Function.Surjective (Quotient.lift (NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K) ⋯) |
fwdDiff_aux.fwdDiffₗ_apply | Mathlib.Algebra.Group.ForwardDiff | ∀ (M : Type u_1) (G : Type u_2) [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (f : M → G) (a : M),
(fwdDiff_aux.fwdDiffₗ M G h) f a = fwdDiff h f a |
_private.Mathlib.Topology.ContinuousOn.0.continuous_prod_of_discrete_left._simp_1_1 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
Continuous f = ContinuousOn f Set.univ |
CategoryTheory.Pseudofunctor.mapComp'_hom_comp_mapComp'_hom_whiskerRight | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : CategoryTheory.CategoryStruct.comp f₀₁ f₁₂ = f₀₂) (h₁₃ : CategoryTheory.CategoryStruct.comp f₁₂ f₂₃ = f₁₃)
(hf : CategoryTheory.CategoryStruct.comp f₀₂ f₂₃ = f),
CategoryTheory.CategoryStruct.comp (F.mapComp' f₀₂ f₂₃ f ⋯).hom
(CategoryTheory.Bicategory.whiskerRight (F.mapComp' f₀₁ f₁₂ f₀₂ h₀₂).hom (F.map f₂₃)) =
CategoryTheory.CategoryStruct.comp (F.mapComp' f₀₁ f₁₃ f ⋯).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f₀₁) (F.mapComp' f₁₂ f₂₃ f₁₃ h₁₃).hom)
(CategoryTheory.Bicategory.associator (F.map f₀₁) (F.map f₁₂) (F.map f₂₃)).inv) |
UnitalShelf.act_self_act_eq | Mathlib.Algebra.Quandle | ∀ {S : Type u_1} [inst : UnitalShelf S] (x y : S), Shelf.act x (Shelf.act x y) = Shelf.act x y |
_private.Mathlib.MeasureTheory.SpecificCodomains.WithLp.0.MeasureTheory.memLp_piLp_iff._simp_1_1 | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p : ENNReal} {ι : Type u_2} [inst : Fintype ι]
{E : ι → Type u_3} [inst_1 : (i : ι) → NormedAddCommGroup (E i)] {f : X → (i : ι) → E i},
(∀ (i : ι), MeasureTheory.MemLp (fun x => f x i) p μ) = MeasureTheory.MemLp f p μ |
SemiNormedGrp₁.of | Mathlib.Analysis.Normed.Group.SemiNormedGrp | (carrier : Type u) → [str : SeminormedAddCommGroup carrier] → SemiNormedGrp₁ |
MvPowerSeries.map._proof_7 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S)
(φ ψ : MvPowerSeries σ R),
(fun n => f ((MvPowerSeries.coeff n) (φ + ψ))) =
(fun n => f ((MvPowerSeries.coeff n) φ)) + fun n => f ((MvPowerSeries.coeff n) ψ) |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.param_eq._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Type u_4} (s : Set α) [inst : Fintype ↑s], Fintype.card ↑s = s.toFinset.card |
CompositionAsSet.card_boundaries_pos | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), 0 < c.boundaries.card |
Polynomial.roots_C_mul | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
a ≠ 0 → (Polynomial.C a * p).roots = p.roots |
SMulWithZero.compHom | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{M₀' : Type u_3} →
(A : Type u_7) →
[inst : Zero M₀] →
[inst_1 : Zero A] → [SMulWithZero M₀ A] → [inst_3 : Zero M₀'] → ZeroHom M₀' M₀ → SMulWithZero M₀' A |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.expOpenPartialHomeomorph._simp_3 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a |
Con.instCompleteLattice._proof_2 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (s : Set (Con M)), sInf s ∈ lowerBounds s ∧ sInf s ∈ upperBounds (lowerBounds s) |
NumberField.InfinitePlace.liesOver_conjugate_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{w : NumberField.InfinitePlace L} {v : NumberField.InfinitePlace K},
w ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v →
NumberField.ComplexEmbedding.LiesOver (NumberField.ComplexEmbedding.conjugate w.embedding) v.embedding |
CategoryTheory.StrictPseudofunctor.comp_obj | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C] {D : Type u₃}
[inst_2 : CategoryTheory.Bicategory D] (F : CategoryTheory.StrictPseudofunctor B C)
(G : CategoryTheory.StrictPseudofunctor C D) (X : B), (F.comp G).obj X = G.obj (F.obj X) |
IsTopologicalAddGroup.toHSpace._proof_5 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousAdd M],
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.const M 0).prodMk (ContinuousMap.id M)) =
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.const M 0).prodMk (ContinuousMap.id M)) |
Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite | Mathlib.RingTheory.Lasker | ∀ {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
(s₀ : Finset ↑N.associatedPrimes),
IsLowerSet ↑s₀ →
∀ (q : Submodule R M),
q.IsPrimary →
∀ (p : ↑N.associatedPrimes),
(q.colon Set.univ).radical = ↑p →
Submodule.comap (LocalizedModule.mkLinearMap (⨅ q ∈ s₀, (↑q).primeCompl) M)
(Submodule.localized₀ (⨅ q ∈ s₀, (↑q).primeCompl)
(LocalizedModule.mkLinearMap (⨅ q ∈ s₀, (↑q).primeCompl) M) q) =
if p ∈ s₀ then q else ⊤ |
Finmap.keys_singleton | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (a : α) (b : β a), (Finmap.singleton a b).keys = {a} |
Std.TreeMap.mk.injEq | Std.Data.TreeMap.Basic | ∀ {α : Type u} {β : Type v} {cmp : autoParam (α → α → Ordering) Std.TreeMap._auto_1}
(inner inner_1 : Std.DTreeMap α (fun x => β) cmp), ({ inner := inner } = { inner := inner_1 }) = (inner = inner_1) |
OpenPartialHomeomorph.extend_preimage_mem_nhdsWithin | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s t : Set M} {x : M},
x ∈ f.source →
t ∈ nhdsWithin x s →
↑(f.extend I).symm ⁻¹' t ∈ nhdsWithin (↑(f.extend I) x) (↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I) |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.WithBot.instArchimedean._simp_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {α : Type u} [inst : AddMonoid α] (a : α) (n : ℕ), n • ↑a = ↑(n • a) |
Algebra.TensorProduct.mapOfCompatibleSMul._proof_7 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_4) (S : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra S A]
[inst_7 : Algebra S B] [inst_8 : SMulCommClass R S A] [inst_9 : TensorProduct.CompatibleSMul R S A B]
(x y : TensorProduct S A B),
(TensorProduct.mapOfCompatibleSMul R S A B) (x * y) =
(TensorProduct.mapOfCompatibleSMul R S A B) x * (TensorProduct.mapOfCompatibleSMul R S A B) y |
CategoryTheory.MonoidalCategory.selRightfAction._proof_11 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {d d' : C}
(f : d ⟶ d'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor d).hom f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor d').hom |
LinearIsometry.map_sub | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) (x y : E), f (x - y) = f x - f y |
TwoSidedIdeal.rightModule | Mathlib.RingTheory.TwoSidedIdeal.Operations | {R : Type u_1} → [inst : Ring R] → (I : TwoSidedIdeal R) → Module Rᵐᵒᵖ ↥I |
Fintype.linearCombination._proof_3 | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_2} {M : Type u_1} (R : Type u_3) [inst : Fintype α] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (v : α → M) (f g : α → R), ∑ i, (f + g) i • v i = ∑ i, f i • v i + ∑ i, g i • v i |
Homeomorph.toOpenPartialHomeomorphOfImageEq._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y) (s : Set X)
(t : Set Y) (h : ⇑e '' s = t), ContinuousOn (⇑e) (e.toPartialEquivOfImageEq s t h).source |
Projectivization.independent_iff_iSupIndep | Mathlib.LinearAlgebra.Projectivization.Independence | ∀ {ι : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{f : ι → Projectivization K V}, Projectivization.Independent f ↔ iSupIndep fun i => (f i).submodule |
_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperation_ge_two_eq_self._proof_1_2 | Mathlib.Data.Nat.Hyperoperation | ∀ (m n : ℕ), hyperoperation (n + 2) m 1 = m → hyperoperation (n + 1 + 2) m 1 = m |
norm_eq_zero._simp_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedAddGroup E] {a : E}, (‖a‖ = 0) = (a = 0) |
MvPolynomial.rTensorAlgEquiv.eq_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} {N : Type v} [inst : CommSemiring R] {σ : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : CommSemiring N] [inst_4 : Algebra R N] [inst_5 : DecidableEq σ],
MvPolynomial.rTensorAlgEquiv = AlgEquiv.ofLinearEquiv MvPolynomial.rTensor ⋯ ⋯ |
ContinuousAlternatingMap.instTopologicalSpace | Mathlib.Topology.Algebra.Module.Alternating.Topology | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{ι : Type u_4} →
[inst : NormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : AddCommGroup F] →
[inst_5 : Module 𝕜 F] →
[inst_6 : TopologicalSpace F] → [IsTopologicalAddGroup F] → TopologicalSpace (E [⋀^ι]→L[𝕜] F) |
LeanSearchClient.unicode_turnstile | LeanSearchClient.LoogleSyntax | Lean.Parser.Parser |
DomMulAct.instMulDistribMulActionMonoidHom._proof_2 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {A : Type u_2} {M : Type u_1} {B : Type u_3} [inst : Monoid M] [inst_1 : Monoid A] [inst_2 : MulDistribMulAction M A]
[inst_3 : CommMonoid B] (x : Mᵈᵐᵃ) (x_1 : A →* B), (MonoidHom.coeFn A B) (x • x_1) = (MonoidHom.coeFn A B) (x • x_1) |
Disjoint.of_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
Function.Surjective f → ∀ {s t : Set β}, Disjoint (f ⁻¹' s) (f ⁻¹' t) → Disjoint s t |
CommRingCat.coyonedaUnique_inv_app_hom_apply | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ {n : Type v} [inst : Unique n] (X : CommRingCat) (a : ↑X) (a_1 : Opposite.unop (Opposite.op n)),
(CommRingCat.Hom.hom (CommRingCat.coyonedaUnique.inv.app X)) a a_1 = a |
Int.emod_eq_zero_of_dvd | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, a ∣ b → b % a = 0 |
Lean.Meta.SynthInstance.TableEntry.mk.injEq | Lean.Meta.SynthInstance | ∀ (waiters : Array Lean.Meta.SynthInstance.Waiter) (answers : Array Lean.Meta.SynthInstance.Answer)
(waiters_1 : Array Lean.Meta.SynthInstance.Waiter) (answers_1 : Array Lean.Meta.SynthInstance.Answer),
({ waiters := waiters, answers := answers } = { waiters := waiters_1, answers := answers_1 }) =
(waiters = waiters_1 ∧ answers = answers_1) |
FirstOrder.Language.BoundedFormula.realize_iAlls._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{φ : L.Formula (α ⊕ β)} {v : α → M} {v' : Fin 0 → M},
FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Formula.iAlls β φ) v v' =
∀ (i : β → M), φ.Realize fun a => Sum.elim v i a |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.digitsAux0.match_1.eq_1 | Mathlib.Data.Nat.Digits.Defs | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () |
SemimoduleCat.coe_of | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ (R : Type u) [inst : Semiring R] (X : Type v) [inst_1 : Semiring X] [inst_2 : Module R X], ↑(SemimoduleCat.of R X) = X |
Localization.lt._proof_2 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelMonoid α] {s : Submonoid α} {a₁ b₁ : α}
{a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(Localization.r s) (a₁, a₂) (b₁, b₂) →
(Localization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ * a₁ < ↑a₂ * c₁) = (↑d₂ * b₁ < ↑b₂ * d₁) |
vsub_left_injective | Mathlib.Algebra.AddTorsor.Basic | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p : P), Function.Injective fun x => x -ᵥ p |
CategoryTheory.Limits.Types.Image.ι | Mathlib.CategoryTheory.Limits.Types.Images | {α β : Type u} → (f : α ⟶ β) → CategoryTheory.Limits.Types.Image f ⟶ β |
WeierstrassCurve.natDegree_Ψ₂Sq_le | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R), W.Ψ₂Sq.natDegree ≤ 3 |
Prod.seminormedRing._proof_14 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (a : α × β),
SubNegMonoid.zsmul 0 a = 0 |
Complex.log_mul_ofReal | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ (r : ℝ), 0 < r → ∀ (x : ℂ), x ≠ 0 → Complex.log (x * ↑r) = ↑(Real.log r) + Complex.log x |
_private.Init.Data.BitVec.Bitblast.0.BitVec.fastUmulOverflow._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (x : BitVec (0 + 1)), ¬x.toNat ≤ 1 → False |
Lean.Elab.Do.observingPostpone | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM (Option α) |
CategoryTheory.Limits.HasImageMaps.has_image_map | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasImages C}
[self : CategoryTheory.Limits.HasImageMaps C] {f g : CategoryTheory.Arrow C} (st : f ⟶ g),
CategoryTheory.Limits.HasImageMap st |
IncidenceAlgebra.coe_add._simp_1 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddZeroClass 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑f + ⇑g = ⇑(f + g) |
CategoryTheory.CommGrp.forget_obj | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.CommGrp C),
(CategoryTheory.CommGrp.forget C).obj X = X.X |
AlgebraicGeometry.Scheme.Hom.resLE_appLE | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (O : (↑U).Opens) (W : (↑V).Opens)
(e' : W ≤ (TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.Hom.resLE f U V e).base).obj O),
AlgebraicGeometry.Scheme.Hom.appLE (AlgebraicGeometry.Scheme.Hom.resLE f U V e) O W e' =
AlgebraicGeometry.Scheme.Hom.appLE f ((AlgebraicGeometry.Scheme.Hom.opensFunctor U.ι).obj O)
((AlgebraicGeometry.Scheme.Hom.opensFunctor V.ι).obj W) ⋯ |
Lean.NamePart.num.noConfusion | Lean.Data.NameTrie | {P : Sort u} → {n n' : ℕ} → Lean.NamePart.num n = Lean.NamePart.num n' → (n = n' → P) → P |
CategoryTheory.Sieve.pushforward_monotone | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
Monotone (CategoryTheory.Sieve.pushforward f) |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal.mk.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
(toDiagram : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) (top : J)
(isTerminal isTerminal_1 : toDiagram.IsTerminal top),
isTerminal = isTerminal_1 →
∀ (uniq_terminal : ∀ (j : J) (hj : toDiagram.IsTerminal j), j = top),
{ toDiagram := toDiagram, top := top, isTerminal := isTerminal, uniq_terminal := uniq_terminal } =
{ toDiagram := toDiagram, top := top, isTerminal := isTerminal_1, uniq_terminal := uniq_terminal } |
Group.exponent_dvd_iff_forall_zpow_eq_one | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Group G] {n : ℤ}, ↑(Monoid.exponent G) ∣ n ↔ ∀ (g : G), g ^ n = 1 |
affineCombination_mem_affineSpan | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {k : Type u_2} {V : Type u_3} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V]
[inst_2 : Module k V] [inst_3 : AddTorsor V P] [Nontrivial k] {s : Finset ι} {w : ι → k},
∑ i ∈ s, w i = 1 → ∀ (p : ι → P), (Finset.affineCombination k s p) w ∈ affineSpan k (Set.range p) |
le_gauge_of_subset_closedBall | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E} {r : ℝ} {x : E},
Absorbent ℝ s → 0 ≤ r → s ⊆ Metric.closedBall 0 r → ‖x‖ / r ≤ gauge s x |
CochainComplex.mappingCocone.liftCochain.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{n m : ℤ} (α α_1 : CochainComplex.HomComplex.Cochain M K n),
α = α_1 →
∀ (β β_1 : CochainComplex.HomComplex.Cochain M L m),
β = β_1 →
∀ (h : m + 1 = n) (T : CochainComplex.HomComplex.Triplet n),
CochainComplex.mappingCocone.liftCochain φ α β h T = CochainComplex.mappingCocone.liftCochain φ α_1 β_1 h T |
_private.Mathlib.Combinatorics.Enumerative.Partition.GenFun.0.Nat.Partition.aux_dvd_of_coeff_ne_zero | Mathlib.Combinatorics.Enumerative.Partition.GenFun | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [T2Space R] {f : ℕ → ℕ → R} {d : ℕ}
{s : Finset ℕ},
0 ∉ s →
∀ {g : ℕ →₀ ℕ},
g ∈ s.finsuppAntidiag d →
(∀ i ∈ s, (PowerSeries.coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • PowerSeries.X ^ (i * (j + 1))) ≠ 0) →
∀ (x : ℕ), x ∣ g x |
FirstOrder.Field.FieldAxiom.mulAssoc | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom |
convexJoin_singleton_segment | Mathlib.Analysis.Convex.Join | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (a b c : E),
convexJoin 𝕜 {a} (segment 𝕜 b c) = (convexHull 𝕜) {a, b, c} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.