ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DirectSum.lieAlgebraOf_apply
File: Mathlib/Algebra/Lie/DirectSum.lean

Proof steps:
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
j : ι
x y : L j
⊢ { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆ =
    ⁅{ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun x,
      { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
state_after: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
j : ι
x y : L j
i : ι
⊢ ({ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆) i =
    ⁅{ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun x,
        { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
      i
tactic: refine DFinsupp.ext fun i => ?_
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
j : ι
x y : L j
i : ι
⊢ ({ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆) i =
    ⁅{ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun x,
        { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
      i
state_after: case pos
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
j : ι
x y : L j
i : ι
h : j = i
⊢ ({ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆) i =
    ⁅{ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun x,
        { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
      i

case neg
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
j : ι
x y : L j
i : ι
h : ¬j = i
⊢ ({ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆) i =
    ⁅{ toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun x,
        { toFun := ⇑(of L j), map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
      i
tactic: by_cases h : j = i
Theorem: CategoryTheory.Limits.Types.colimitEquivQuot_apply
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F) (colimit.ι F j x) = Quot.mk (Quot.Rel F) ⟨j, x⟩
state_after: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F).symm ((colimitEquivQuot F) (colimit.ι F j x)) =
    (colimitEquivQuot F).symm (Quot.mk (Quot.Rel F) ⟨j, x⟩)
tactic: apply (colimitEquivQuot F).symm.injective
state_before: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F).symm ((colimitEquivQuot F) (colimit.ι F j x)) =
    (colimitEquivQuot F).symm (Quot.mk (Quot.Rel F) ⟨j, x⟩)
state_after: no goals
tactic: simp
Theorem: ENNReal.hasSum_coe
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : α → ℝ≥0
r : ℝ≥0
⊢ HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r
state_after: no goals
tactic: simp only [HasSum, ← coe_finset_sum, tendsto_coe]
Theorem: Real.arccos_of_le_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : x ≤ -1
⊢ arccos x = π
state_after: no goals
tactic: rw [arccos, arcsin_of_le_neg_one hx, sub_neg_eq_add, add_halves]
Theorem: Polynomial.mem_support_iff
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ n ∈ p.support ↔ p.coeff n ≠ 0
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ n ∈ { toFinsupp := toFinsupp✝ }.support ↔ { toFinsupp := toFinsupp✝ }.coeff n ≠ 0
tactic: rcases p with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ n ∈ { toFinsupp := toFinsupp✝ }.support ↔ { toFinsupp := toFinsupp✝ }.coeff n ≠ 0
state_after: no goals
tactic: simp
Theorem: hasSum_empty
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
inst✝ : IsEmpty β
⊢ HasProd f 1
state_after: no goals
tactic: convert @hasProd_one α β _ _
Theorem: AddSubgroup.eq_bot_iff_card
File: Mathlib/Algebra/Group/Subgroup/Finite.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
A : Type u_2
inst✝ : AddGroup A
H K : Subgroup G
⊢ H = ⊥ → Nat.card ↥H = 1
state_after: G : Type u_1
inst✝¹ : Group G
A : Type u_2
inst✝ : AddGroup A
K : Subgroup G
⊢ Nat.card ↥⊥ = 1
tactic: rintro rfl
state_before: G : Type u_1
inst✝¹ : Group G
A : Type u_2
inst✝ : AddGroup A
K : Subgroup G
⊢ Nat.card ↥⊥ = 1
state_after: no goals
tactic: exact card_bot
Theorem: sup_eq_sdiff_sup_sdiff_sup_inf
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x \ y ⊔ y \ x ⊔ x ⊓ y = (x \ y ⊔ y \ x ⊔ x) ⊓ (x \ y ⊔ y \ x ⊔ y)
state_after: no goals
tactic: rw [sup_inf_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x \ y ⊔ y \ x ⊔ x) ⊓ (x \ y ⊔ y \ x ⊔ y) = (x \ y ⊔ x ⊔ y \ x) ⊓ (x \ y ⊔ (y \ x ⊔ y))
state_after: no goals
tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x \ y ⊔ x ⊔ y \ x) ⊓ (x \ y ⊔ (y \ x ⊔ y)) = (x ⊔ y \ x) ⊓ (x \ y ⊔ y)
state_after: no goals
tactic: rw [sup_sdiff_right, sup_sdiff_right]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x ⊔ y \ x) ⊓ (x \ y ⊔ y) = x ⊔ y
state_after: no goals
tactic: rw [sup_sdiff_self_right, sup_sdiff_self_left, inf_idem]
Theorem: WeierstrassCurve.Affine.CoordinateRing.coe_basis
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ ⇑(CoordinateRing.basis W) = ![1, (mk W) Y]
state_after: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
n : Fin 2
⊢ (CoordinateRing.basis W) n = ![1, (mk W) Y] n
tactic: ext n
state_before: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
n : Fin 2
⊢ (CoordinateRing.basis W) n = ![1, (mk W) Y] n
state_after: case h.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨0, ⋯⟩ = ![1, (mk W) Y] ⟨0, ⋯⟩

case h.tail.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨1, ⋯⟩ = ![1, (mk W) Y] ⟨1, ⋯⟩
tactic: fin_cases n
state_before: case h.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨0, ⋯⟩ = ![1, (mk W) Y] ⟨0, ⋯⟩

case h.tail.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨1, ⋯⟩ = ![1, (mk W) Y] ⟨1, ⋯⟩
state_after: no goals
tactic: exacts [basis_zero W, basis_one W]
Theorem: Finset.update_piecewise
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
v : π i
⊢ update (s.piecewise f g) i v = s.piecewise (update f i v) (update g i v)
state_after: case h
ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
v : π i
j : ι
⊢ update (s.piecewise f g) i v j = s.piecewise (update f i v) (update g i v) j
tactic: ext j
state_before: case h
ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
v : π i
j : ι
⊢ update (s.piecewise f g) i v j = s.piecewise (update f i v) (update g i v) j
state_after: no goals
tactic: rcases em (j = i) with (rfl | hj) <;> by_cases hs : j ∈ s <;> simp [*]
Theorem: Finset.prod_range_succ
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x ∈ range (n + 1), f x = (∏ x ∈ range n, f x) * f n
state_after: no goals
tactic: simp only [mul_comm, prod_range_succ_comm]
Theorem: ProbabilityTheory.Kernel.fst_map_prod
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f✝ : β → γ
g✝ : γ → α
κ : Kernel α β
f : β → γ
g : β → δ
hf : Measurable f
hg : Measurable g
⊢ (κ.map (fun x => (f x, g x)) ⋯).fst = κ.map f hf
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f✝ : β → γ
g✝ : γ → α
κ : Kernel α β
f : β → γ
g : β → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set γ
hs : MeasurableSet s
⊢ ((κ.map (fun x => (f x, g x)) ⋯).fst x) s = ((κ.map f hf) x) s
tactic: ext x s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f✝ : β → γ
g✝ : γ → α
κ : Kernel α β
f : β → γ
g : β → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set γ
hs : MeasurableSet s
⊢ ((κ.map (fun x => (f x, g x)) ⋯).fst x) s = ((κ.map f hf) x) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f✝ : β → γ
g✝ : γ → α
κ : Kernel α β
f : β → γ
g : β → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set γ
hs : MeasurableSet s
⊢ (κ x) ((fun x => (f x, g x)) ⁻¹' {p | p.1 ∈ s}) = (κ x) (f ⁻¹' s)

case h.h.hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f✝ : β → γ
g✝ : γ → α
κ : Kernel α β
f : β → γ
g : β → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set γ
hs : MeasurableSet s
⊢ MeasurableSet {p | p.1 ∈ s}
tactic: rw [fst_apply' _ _ hs, map_apply', map_apply' _ _ _ hs]
Theorem: ProbabilityTheory.condIndepFun_iff
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : Type u_3
γ : Type u_4
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
hf : Measurable f
hg : Measurable g
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ CondIndepFun m' hm' f g μ ↔
    ∀ (t1 t2 : Set Ω),
      MeasurableSet t1 →
        MeasurableSet t2 →
          μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']
state_after: no goals
tactic: rw [condIndepFun_iff_condIndep, condIndep_iff _ _ _ _ hf.comap_le hg.comap_le]
Theorem: Pullback.continuous_proj
File: Mathlib/Topology/FiberBundle/Constructions.lean

Proof steps:
state_before: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace F E)
f : B' → B
⊢ Continuous TotalSpace.proj
state_after: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace F E)
f : B' → B
⊢ induced TotalSpace.proj inst✝¹ ⊓ induced (Pullback.lift f) inst✝ ≤ induced TotalSpace.proj inst✝¹
tactic: rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
state_before: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace F E)
f : B' → B
⊢ induced TotalSpace.proj inst✝¹ ⊓ induced (Pullback.lift f) inst✝ ≤ induced TotalSpace.proj inst✝¹
state_after: no goals
tactic: exact inf_le_left
Theorem: Affine.Simplex.sum_pointWeightsWithCircumcenter
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
⊢ ∑ j : PointsWithCircumcenterIndex n, pointWeightsWithCircumcenter i j = 1
state_after: case h.e'_2.a
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
j : PointsWithCircumcenterIndex n
a✝ : j ∈ univ
⊢ pointWeightsWithCircumcenter i j = if j = pointIndex i then Function.const (PointsWithCircumcenterIndex n) 1 j else 0

case h.e'_3
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
⊢ 1 = if pointIndex i ∈ univ then Function.const (PointsWithCircumcenterIndex n) 1 (pointIndex i) else 0
tactic: convert sum_ite_eq' univ (pointIndex i) (Function.const _ (1 : ℝ)) with j
Theorem: Cardinal.bddAbove_iff_small
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
s : Set Cardinal.{u}
⊢ Small.{u, u + 1} ↑s → BddAbove s
state_after: case mk.intro.intro
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
⊢ BddAbove s
tactic: rintro ⟨ι, ⟨e⟩⟩
state_before: case mk.intro.intro
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
⊢ BddAbove s
state_after: case mk.intro.intro
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
⊢ (range fun x => ↑(e.symm x)) = s
tactic: suffices (range fun x : ι => (e.symm x).1) = s by
      rw [← this]
      apply bddAbove_range.{u, u}
state_before: case mk.intro.intro
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
⊢ (range fun x => ↑(e.symm x)) = s
state_after: case mk.intro.intro.h
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
x : Cardinal.{u}
⊢ (x ∈ range fun x => ↑(e.symm x)) ↔ x ∈ s
tactic: ext x
state_before: case mk.intro.intro.h
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
x : Cardinal.{u}
⊢ (x ∈ range fun x => ↑(e.symm x)) ↔ x ∈ s
state_after: case mk.intro.intro.h.refine_1
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
x : Cardinal.{u}
⊢ (x ∈ range fun x => ↑(e.symm x)) → x ∈ s

case mk.intro.intro.h.refine_2
α β : Type u
s : Set Cardinal.{u}
ι : Type u
e : ↑s ≃ ι
x : Cardinal.{u}
hx : x ∈ s
⊢ (fun x => ↑(e.symm x)) (e ⟨x, hx⟩) = x
tactic: refine ⟨?_, fun hx => ⟨e ⟨x, hx⟩, ?_⟩⟩
Theorem: VitaliFamily.eventually_filterAt_measurableSet
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in v.filterAt x, MeasurableSet a
state_after: no goals
tactic: filter_upwards [v.eventually_filterAt_mem_setsAt x] with _ ha using v.measurableSet _ _ ha
Theorem: countable_bInter_mem
File: Mathlib/Order/Filter/CountableInter.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_4
S : Set ι
hS : S.Countable
s : (i : ι) → i ∈ S → Set α
⊢ ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
state_after: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_4
S : Set ι
hS : S.Countable
s : (i : ι) → i ∈ S → Set α
⊢ ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
tactic: rw [biInter_eq_iInter]
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_4
S : Set ι
hS : S.Countable
s : (i : ι) → i ∈ S → Set α
⊢ ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
state_after: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_4
S : Set ι
hS : S.Countable
s : (i : ι) → i ∈ S → Set α
this : Encodable ↑S
⊢ ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
tactic: haveI := hS.toEncodable
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_4
S : Set ι
hS : S.Countable
s : (i : ι) → i ∈ S → Set α
this : Encodable ↑S
⊢ ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
state_after: no goals
tactic: exact countable_iInter_mem.trans Subtype.forall
Theorem: ContDiffBump.integral_pos
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < ∫ (x : E), ↑f x ∂μ
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (support ↑f)
tactic: refine (integral_pos_iff_support_of_nonneg f.nonneg' f.integrable).mpr ?_
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (support ↑f)
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (ball c f.rOut)
tactic: rw [f.support_eq]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (ball c f.rOut)
state_after: no goals
tactic: exact measure_ball_pos μ c f.rOut_pos
Theorem: CategoryTheory.Limits.Multifork.isLimit_types_iff
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: I : MulticospanIndex (Type u)
c : Multifork I
⊢ Nonempty (IsLimit c) ↔ Function.Bijective c.toSections
state_after: no goals
tactic: rw [Types.isLimit_iff_bijective_sectionOfCone, ← toSections_fac, EquivLike.comp_bijective]
Theorem: ProbabilityTheory.gammaPDFReal_pos
File: Mathlib/Probability/Distributions/Gamma.lean

Proof steps:
state_before: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < gammaPDFReal a r x
state_after: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < r ^ a / Gamma a * x ^ (a - 1) * rexp (-(r * x))
tactic: simp only [gammaPDFReal, if_pos hx.le]
state_before: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < r ^ a / Gamma a * x ^ (a - 1) * rexp (-(r * x))
state_after: no goals
tactic: positivity
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.to_iso
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
⊢ IsIso f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
⊢ IsIso f
tactic: have : ∀ (U : (Opens Y)ᵒᵖ), IsIso (f.c.app U) := by
    intro U
    have : U = op (opensFunctor f |>.obj ((Opens.map f.base).obj (unop U))) := by
      induction U using Opposite.rec' with | h U => ?_
      cases U
      dsimp only [Functor.op, Opens.map]
      congr
      exact (Set.image_preimage_eq _ ((TopCat.epi_iff_surjective _).mp h')).symm
    convert H.c_iso (Opens.map f.base |>.obj <| unop U)
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
⊢ IsIso f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
⊢ IsIso f
tactic: have : IsIso f.c := NatIso.isIso_of_isIso_app _
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
⊢ IsIso f
state_after: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
⊢ IsIso f.base
tactic: apply (config := { allowSynthFailures := true }) isIso_of_components
state_before: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
⊢ IsIso f.base
state_after: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
t : ↑↑X ≃ₜ ↑↑Y :=
  (Homeomorph.ofEmbedding ⇑f.base ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso f.base
tactic: let t : X ≃ₜ Y := (Homeomorph.ofEmbedding _ H.base_open.toEmbedding).trans
    { toFun := Subtype.val
      invFun := fun x =>
        ⟨x, by rw [Set.range_iff_surjective.mpr ((TopCat.epi_iff_surjective _).mp h')]; trivial⟩
      left_inv := fun ⟨_, _⟩ => rfl
      right_inv := fun _ => rfl }
state_before: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this✝ : ∀ (U : (Opens ↑↑Y)ᵒᵖ), IsIso (f.c.app U)
this : IsIso f.c
t : ↑↑X ≃ₜ ↑↑Y :=
  (Homeomorph.ofEmbedding ⇑f.base ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso f.base
state_after: no goals
tactic: exact (TopCat.isoOfHomeo t).isIso_hom
Theorem: mul_mul_invOf_self_cancel'
File: Mathlib/Algebra/Group/Invertible/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b : α
x✝ : Invertible b
⊢ a * b * ⅟b = a
state_after: no goals
tactic: simp [mul_assoc]