name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Aesop.Check.mk | Aesop.Check | Lean.Option Bool → Aesop.Check |
herglotzRieszKernel_def | Mathlib.Analysis.Complex.Poisson | ∀ (c w z : ℂ), herglotzRieszKernel c w z = (z - c + (w - c)) / (z - c - (w - c)) |
CategoryTheory.ChosenPullbacksAlong.pullbackCone_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z X : C} (f : Y ⟶ X) (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g],
(CategoryTheory.ChosenPullbacksAlong.pullbackCone f g).snd = CategoryTheory.ChosenPullbacksAlong.snd f g |
UInt32.toUSize_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toUSize < b.toUSize ↔ a < b |
AddSubgroup.even._proof_1 | Mathlib.Algebra.Group.Subgroup.Even | ∀ (G : Type u_1) [inst : AddCommGroup G] {x : G}, Even x → Even (-x) |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.NNReal.rpow_pos._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True |
IntermediateField.restrictScalars_toSubfield | Mathlib.FieldTheory.IntermediateField.Basic | ∀ (K : Type u_1) {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] [inst_5 : Algebra L' L] [inst_6 : IsScalarTower K L' L]
{E : IntermediateField L' L}, (IntermediateField.restrictScalars K E).toSubfield = E.toSubfield |
Fin.finsetImage_natAdd_Ioc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (Fin.natAdd m) (Finset.Ioc i j) = Finset.Ioc (Fin.natAdd m i) (Fin.natAdd m j) |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_closure_eq._simp_1_8 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : IsDomain A] {s t : Set A},
(AlgebraicIndependent.matroid R A).IsBasis s t =
(AlgebraicIndepOn R id s ∧ s ⊆ t ∧ ∀ a ∈ t, IsAlgebraic (↥(Algebra.adjoin R s)) a) |
Perfection.teichmullerAux.congr_simp | Mathlib.RingTheory.Teichmuller | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] {I : Ideal R} [inst_2 : CharP (R ⧸ I) p]
(x x_1 : Perfection (R ⧸ I) p), x = x_1 → ∀ (a a_1 : ℕ), a = a_1 → x.teichmullerAux a = x_1.teichmullerAux a_1 |
Lean.Meta.coerceCollectingNames? | Lean.Meta.Coe | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.LOption (Lean.Expr × List Lean.Name)) |
_private.Lean.Elab.MacroRules.0.Lean.Elab.Command.elabMacroRulesAux._sparseCasesOn_3 | Lean.Elab.MacroRules | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(hx : AlgebraicIndependent R x),
hx.mvPolynomialOptionEquivPolynomialAdjoin = hx.mvPolynomialOptionEquivPolynomialAdjoin |
BoundedContinuousFunction.instNSMul._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[ContinuousAdd R] (f : BoundedContinuousFunction α R) (n : ℕ), Continuous fun b => n • f b |
_private.Mathlib.GroupTheory.FiniteAbelian.Duality.0.CommGroup.mem_subgroupOrderIsoSubgroupMonoidHom_symm_iff._simp_1_3 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G ≃* N} {K : Subgroup G} {x : N},
(x ∈ Subgroup.map f.toMonoidHom K) = (f.symm x ∈ K) |
MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Sort u_2} [Countable ι] (μ : ι → MeasureTheory.OuterMeasure α)
(s : Set α), ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i).trim s |
UpperSet.commSemigroup.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.commSemigroup = Function.Injective.commSemigroup SetLike.coe ⋯ ⋯ |
Set.pow_mem_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α} {a : α} {n : ℕ}, a ∈ s → a ^ n ∈ s ^ n |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_7 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → ¬curr = w → False |
LieAlgebra.SemiDirectSum.mk._flat_ctor | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → {x : L →ₗ⁅R⁆ LieDerivation R K K} → K → L → K ⋊⁅x⁆ L |
String.Internal.next | Init.Data.String.Bootstrap | String → String.Pos.Raw → String.Pos.Raw |
CategoryTheory.TwoSquare.guitartExact_id' | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] (F : CategoryTheory.Functor C₁ C₂),
(CategoryTheory.TwoSquare.mk F (CategoryTheory.Functor.id C₁) (CategoryTheory.Functor.id C₂) F
(CategoryTheory.CategoryStruct.id F)).GuitartExact |
CategoryTheory.regularTopology.equalizerCondition_iff_of_equivalence | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(P : CategoryTheory.Functor Cᵒᵖ D) (e : C ≌ E),
CategoryTheory.regularTopology.EqualizerCondition P ↔
CategoryTheory.regularTopology.EqualizerCondition (e.op.inverse.comp P) |
IsNoetherian.finsetBasisIndex | Mathlib.FieldTheory.Finiteness | (K : Type u) →
(V : Type v) →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → [IsNoetherian K V] → Finset V |
AddSemiconjBy.neg_symm_left_iff._simp_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a x y : G}, AddSemiconjBy (-a) y x = AddSemiconjBy a x y |
CategoryTheory.Coyoneda.colimitCoconeIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Cᵒᵖ)
(s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X))
(m : (CategoryTheory.Coyoneda.colimitCocone X).pt ⟶ s.pt),
(∀ (j : C), CategoryTheory.CategoryStruct.comp ((CategoryTheory.Coyoneda.colimitCocone X).ι.app j) m = s.ι.app j) →
m = fun x => s.ι.app (Opposite.unop X) (CategoryTheory.CategoryStruct.id (Opposite.unop X)) |
Std.DTreeMap.Raw.maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' |
CategoryTheory.CartesianMonoidalCategory.mk | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[toSemiCartesianMonoidalCategory : CategoryTheory.SemiCartesianMonoidalCategory C] →
((X Y : C) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)
(CategoryTheory.SemiCartesianMonoidalCategory.snd X Y))) →
CategoryTheory.CartesianMonoidalCategory C |
Module.Basis.ofIsCoprimeDifferentIdeal._proof_10 | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_3) {K : Type u_4} {L : Type u_2} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] (R₂ : Type u_1) [inst_4 : CommRing R₂] [inst_5 : Algebra A R₂] [Module.Finite A R₂]
{F₂ : IntermediateField K L} [inst_7 : Algebra R₂ ↥F₂] [IsDomain A] [IsDedekindDomain R₂] [IsFractionRing R₂ ↥F₂],
Module.Free A R₂ → IsLocalization (Algebra.algebraMapSubmonoid R₂ (nonZeroDivisors A)) ↥F₂ |
AlgHom.liftOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f.toRingHom).IsTwoSided |
Std.HashMap.Equiv.filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}
(f : α → β → Option γ), m₁.Equiv m₂ → (Std.HashMap.filterMap f m₁).Equiv (Std.HashMap.filterMap f m₂) |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_19 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] + 1 ≤ xs.length → (List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length |
CategoryTheory.CartesianMonoidalCategory.lift_leftUnitor_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {X Y : C}
(f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f g)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom =
g |
Array.find?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.find? p xs).isSome = true ↔ ∃ x ∈ xs, p x = true |
Std.LawfulEqCmp.opposite | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] [Std.LawfulEqCmp cmp], Std.LawfulEqCmp fun a b => cmp b a |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.ofAIGAux.go.match_1.splitter | Std.Sat.AIG.RelabelNat | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
((a : α) → decl = Std.Sat.AIG.Decl.atom a → motive (Std.Sat.AIG.Decl.atom a)) →
(decl = Std.Sat.AIG.Decl.false → motive Std.Sat.AIG.Decl.false) →
((lhs rhs : Std.Sat.AIG.Fanin) →
decl = Std.Sat.AIG.Decl.gate lhs rhs → motive (Std.Sat.AIG.Decl.gate lhs rhs)) →
motive decl |
AddMonoidAlgebra.mapRangeAlgEquiv._proof_7 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_4) {A : Type u_3} {B : Type u_2} (M : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddMonoid M] (e : A ≃ₐ[R] B) (r : R),
(↑↑(AddMonoidAlgebra.mapRangeAlgHom M ↑e).toRingHom).toFun ((algebraMap R (AddMonoidAlgebra A M)) r) =
(algebraMap R (AddMonoidAlgebra B M)) r |
FreeAbelianGroup.ring._proof_4 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (n : ℕ), (n + 1).unaryCast = n.unaryCast + 1 |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize._proof_3 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), ¬n + 1 > 0 → False |
mem_openSegment_iff_div | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E},
x ∈ openSegment 𝕜 y z ↔ ∃ a b, 0 < a ∧ 0 < b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x |
Batteries.RBNode.depth.eq_def | Batteries.Data.RBMap.Depth | ∀ {α : Type u_1} (x : Batteries.RBNode α),
x.depth =
match x with
| Batteries.RBNode.nil => 0
| Batteries.RBNode.node c a v b => max a.depth b.depth + 1 |
CategoryTheory.SemiCartesianMonoidalCategory.comp_toUnit_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory C]
{X Y : C} (f : X ⟶ Y) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit Y) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) h |
IsPurelyInseparable.iterateFrobenius._proof_4 | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (p : ℕ) [ExpChar K p] {n : ℕ},
IsPurelyInseparable.exponent K L ≤ n →
∀ (a b : L),
IsPurelyInseparable.iterateFrobeniusAux✝ K L p n (a + b) =
IsPurelyInseparable.iterateFrobeniusAux✝¹ K L p n a + IsPurelyInseparable.iterateFrobeniusAux✝² K L p n b |
_private.Mathlib.Order.Nucleus.0.Nucleus.giAux._proof_2 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x : X) (y : ↑(Set.range ⇑n)),
n.toClosureOperator x ≤ ↑y ↔ x ≤ ↑y |
Lean.Expr.FoldConstsImpl.State.rec | Lean.Util.FoldConsts | {motive : Lean.Expr.FoldConstsImpl.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(visitedConsts : Lean.NameHashSet) → motive { visited := visited, visitedConsts := visitedConsts }) →
(t : Lean.Expr.FoldConstsImpl.State) → motive t |
Odd.neg | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Ring α] {a : α}, Odd a → Odd (-a) |
KaehlerDifferential.fromIdeal_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(KaehlerDifferential.fromIdeal R S) |
ByteArray.append_left_inj._simp_1 | Init.Data.ByteArray.Lemmas | ∀ {xs₁ xs₂ : ByteArray} (ys : ByteArray), (xs₁ ++ ys = xs₂ ++ ys) = (xs₁ = xs₂) |
_private.Mathlib.Algebra.Module.LinearMap.End.0.Module.End.iterate_bijective.match_1_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
List.next_eq_getElem._proof_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} {a : α}, a ∈ l → 0 < l.length |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow._proof_1_2 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {m : ℕ}, 2 ≤ m → 2 ≤ 2 * m |
AlgebraicGeometry.SheafedSpace.ext._proof_1 | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.SheafedSpace C} (α β : X ⟶ Y),
α.hom.base = β.hom.base → (TopologicalSpace.Opens.map α.hom.base).op = (TopologicalSpace.Opens.map β.hom.base).op |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv | Mathlib.Geometry.Manifold.LocalDiffeomorph | {𝕜 : 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] →
{H : Type u_4} →
[inst_5 : TopologicalSpace H] →
{G : Type u_5} →
[inst_6 : TopologicalSpace G] →
{I : ModelWithCorners 𝕜 E H} →
{J : ModelWithCorners 𝕜 F G} →
{M : Type u_6} →
[inst_7 : TopologicalSpace M] →
[inst_8 : ChartedSpace H M] →
{N : Type u_7} →
[inst_9 : TopologicalSpace N] →
[inst_10 : ChartedSpace G N] →
{n : WithTop ℕ∞} →
{f : M → N} →
{x : M} →
IsLocalDiffeomorphAt I J n f x →
n ≠ 0 → TangentSpace I x ≃L[𝕜] TangentSpace J (f x) |
exists_linearIndepOn_id_extension | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V},
LinearIndepOn K id s → s ⊆ t → ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndepOn K id b |
OrderRingIso.instInhabited | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_2) → [inst : Mul α] → [inst_1 : Add α] → [inst_2 : LE α] → Inhabited (α ≃+*o α) |
Matrix.isSymm_fromBlocks_iff | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, (Matrix.fromBlocks A B C D).IsSymm ↔ A.IsSymm ∧ B.transpose = C ∧ C.transpose = B ∧ D.IsSymm |
Std.Sat.AIG.RefVec.fold.go._unary | Std.Sat.AIG.RefVecOperator.Fold | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
(len : ℕ) →
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) →
[Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f] →
(aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len → Std.Sat.AIG.Entrypoint α |
IsProperMap.clusterPt_of_mapClusterPt | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsProperMap f → ∀ ⦃ℱ : Filter X⦄ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ |
StarOrderedRing.toExistsAddOfLE | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R],
ExistsAddOfLE R |
Std.HashSet.Raw.not_mem_emptyWithCapacity._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α} {c : ℕ}, (a ∈ Std.HashSet.Raw.emptyWithCapacity c) = False |
CategoryTheory.Functor.chosenProd.snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Y |
CategoryTheory.Limits.coneOfDiagramInitial | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{X : J} → CategoryTheory.Limits.IsInitial X → (F : CategoryTheory.Functor J C) → CategoryTheory.Limits.Cone F |
CategoryTheory.Presheaf.coherentExtensiveEquivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] →
[inst_2 : CategoryTheory.Preregular C] →
[inst_3 : CategoryTheory.FinitaryExtensive C] →
[∀ (X : C), CategoryTheory.Projective X] →
CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A ≌
CategoryTheory.Sheaf (CategoryTheory.extensiveTopology C) A |
DomMulAct.instInvOneClassOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : InvOneClass Mᵐᵒᵖ], DomMulAct.instInvOneClassOfMulOpposite = inst |
CategoryTheory.InjectiveResolution.descIdHomotopy._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
(I : CategoryTheory.InjectiveResolution X),
CategoryTheory.CategoryStruct.comp I.ι
(CategoryTheory.InjectiveResolution.desc (CategoryTheory.CategoryStruct.id X) I I) =
CategoryTheory.CategoryStruct.comp ((CochainComplex.single₀ C).map (CategoryTheory.CategoryStruct.id X)) I.ι |
_private.Mathlib.Order.Interval.Set.WithBotTop.0.WithBot.preimage_coe_Ioc_bot._simp_1_1 | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b |
OpenAddSubgroup.comap | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
{N : Type u_2} →
[inst_2 : AddGroup N] →
[inst_3 : TopologicalSpace N] → (f : G →+ N) → Continuous ⇑f → OpenAddSubgroup N → OpenAddSubgroup G |
Finsupp.comapDistribMulAction._proof_1 | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_2} {G : Type u_3} [inst : Monoid G] [inst_1 : MulAction G α] [inst_2 : AddCommMonoid M]
(g : G), g • 0 = 0 |
_private.Mathlib.Order.Category.FinBddDistLat.0.FinBddDistLat.Hom.mk.sizeOf_spec | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (hom' : BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat), sizeOf { hom' := hom' } = 1 + sizeOf hom' |
Matrix.permMatrix_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
Equiv.Perm.permMatrix R σ ∈ Matrix.colStochastic R n |
StarAlgHom.ext_iff | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] {f g : A →⋆ₐ[R] B},
f = g ↔ ∀ (x : A), f x = g x |
QuadraticMap.instNeg._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (Q : QuadraticMap R M N),
∃ B, ∀ (x y : M), (-⇑Q) (x + y) = (-⇑Q) x + (-⇑Q) y + (B x) y |
CategoryTheory.Grothendieck.isoMk_hom_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
(CategoryTheory.Grothendieck.isoMk e₁ e₂).hom.fiber = e₂.hom |
MeasureTheory.Measure.Regular.exists_isCompact_not_null | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular],
(∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0 |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.eq_pell_lem.match_1_3 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (motive : ℕ → ℤ√↑(Pell.d✝ a1) → Prop) (x : ℕ) (x_1 : ℤ√↑(Pell.d✝¹ a1)),
(∀ (x : ℤ√↑(Pell.d✝² a1)), motive 0 x) → (∀ (n : ℕ) (b : ℤ√↑(Pell.d✝³ a1)), motive n.succ b) → motive x x_1 |
CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal Y)
(c : CategoryTheory.Limits.BinaryFan X Y), Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescope.match_7 | Lean.Meta.HaveTelescope | (motive : Array Bool × Array Bool → Sort u_1) →
(__discr : Array Bool × Array Bool) → ((fixed used : Array Bool) → motive (fixed, used)) → motive __discr |
isUpperSet_setOf._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsUpperSet {a | p a} = Monotone p |
_private.Init.Data.UInt.Lemmas.0.UInt32.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) |
LinearMap.range_dualMap_eq_dualAnnihilator_ker | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V₁ : Type u_2} {V₂ : Type u_3} [inst : Field K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V₁ →ₗ[K] V₂), f.dualMap.range = f.ker.dualAnnihilator |
CategoryTheory.Under.postEquiv_functor | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : T ≌ D), (CategoryTheory.Under.postEquiv X F).functor = CategoryTheory.Under.post F.functor |
_private.Mathlib.Algebra.FreeAlgebra.0.FreeAlgebra.liftAux._proof_1 | Mathlib.Algebra.FreeAlgebra | ∀ (R : Type u_1) {X : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(f : X → A) (a b : FreeAlgebra.Pre R X),
FreeAlgebra.Rel R X a b → FreeAlgebra.liftFun R X f a = FreeAlgebra.liftFun R X f b |
HasStrictDerivAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ},
HasStrictDerivAt f f' x → f x ∈ Complex.slitPlane → HasStrictDerivAt (fun t => Complex.log (f t)) (f' / f x) x |
BooleanSubalgebra.val_bot | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α}, ↑⊥ = ⊥ |
PFun.preimage_eq | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s : Set β), f.preimage s = f.core s ∩ f.Dom |
Codisjoint.sup_right' | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (c ⊔ b) |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.prod_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} (motive : (x : ℕ) → (Fin x → α) → Prop) (x : ℕ) (x_1 : Fin x → α),
(∀ (x : Fin 0 → α), motive 0 x) →
(∀ (a : Fin 1 → α), motive 1 a) → (∀ (n : ℕ) (a : Fin (n + 2) → α), motive n.succ.succ a) → motive x x_1 |
HomotopicalAlgebra.CofibrantObject.ι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] → CategoryTheory.Functor (HomotopicalAlgebra.CofibrantObject C) C |
Lean.Parser.Term.doUnless._regBuiltin.Lean.Parser.Term.doUnless_1 | Lean.Parser.Do | IO Unit |
Bipointed.swap._proof_1 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Bipointed),
{ toFun := (CategoryTheory.CategoryStruct.id X).toFun, map_fst := ⋯, map_snd := ⋯ } =
CategoryTheory.CategoryStruct.id { X := X.X, toProd := X.toProd.swap } |
TopologicalSpace.PositiveCompacts.locallyCompactSpace_of_addGroup | Mathlib.Topology.Algebra.Group.Compact | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G]
(K : TopologicalSpace.PositiveCompacts G), LocallyCompactSpace G |
_private.Lean.Meta.Transform.0.Lean.Meta.transformWithCache.visit.visitPost._unsafe_rec | Lean.Meta.Transform | {m : Type → Type} →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Lean.TransformStep) →
(Lean.Expr → m Lean.TransformStep) →
Bool →
Bool →
Bool →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m →
Lean.Expr → Lean.MonadCacheT Lean.ExprStructEq Lean.Expr m Lean.Expr |
_private.Lean.Elab.Tactic.Do.ProofMode.Refine.0.Lean.Elab.Tactic.Do.ProofMode.patAsTerm.match_1 | Lean.Elab.Tactic.Do.ProofMode.Refine | (motive : Lean.Parser.Tactic.MRefinePat → Sort u_1) →
(pat : Lean.Parser.Tactic.MRefinePat) →
((t : Lean.TSyntax `term) → motive (Lean.Parser.Tactic.MRefinePat.pure t)) →
((name : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MRefinePat.one name)) →
((x : Lean.Parser.Tactic.MRefinePat) → motive x) → motive pat |
_private.Mathlib.FieldTheory.Finite.Basic.0._aux_Mathlib_FieldTheory_Finite_Basic___macroRules__private_Mathlib_FieldTheory_Finite_Basic_0_termQ_1 | Mathlib.FieldTheory.Finite.Basic | Lean.Macro |
MeasureTheory.Filtration.mk.inj | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {inst : Preorder ι} {m : MeasurableSpace Ω} {seq : ι → MeasurableSpace Ω}
{mono' : Monotone seq} {le' : ∀ (i : ι), seq i ≤ m} {seq_1 : ι → MeasurableSpace Ω} {mono'_1 : Monotone seq_1}
{le'_1 : ∀ (i : ι), seq_1 i ≤ m},
{ seq := seq, mono' := mono', le' := le' } = { seq := seq_1, mono' := mono'_1, le' := le'_1 } → seq = seq_1 |
AddSubgroup.isComplement'_bot_top | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G], ⊥.IsComplement' ⊤ |
NonUnitalAlgHom.rec | Mathlib.Algebra.Algebra.NonUnitalHom | {R : Type u} →
{S : Type u₁} →
[inst : Monoid R] →
[inst_1 : Monoid S] →
{φ : R →* S} →
{A : Type v} →
{B : Type w} →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : DistribMulAction R A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction S B] →
{motive : (A →ₛₙₐ[φ] B) → Sort u_1} →
((toDistribMulActionHom : A →ₑ+[φ] B) →
(map_mul' :
∀ (x y : A),
toDistribMulActionHom.toFun (x * y) =
toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y) →
motive { toDistribMulActionHom := toDistribMulActionHom, map_mul' := map_mul' }) →
(t : A →ₛₙₐ[φ] B) → motive t |
Set.mul_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z₁ z₂ : M}, z₁ ∈ Set.center M → z₂ ∈ Set.center M → z₁ * z₂ ∈ Set.center M |
Nat.xor_mod_two_eq_one._simp_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, ((a ^^^ b) % 2 = 1) = ¬(a % 2 = 1 ↔ b % 2 = 1) |
Function.IsPeriodicPt.piMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i} {n : ℕ},
(∀ (i : ι), Function.IsPeriodicPt (f i) n (x i)) → Function.IsPeriodicPt (Pi.map f) n x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.