ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.PullbackCone.condition_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
⊢ t.π.app WalkingCospan.one = t.fst ≫ f
state_after: C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w :
  ((Functor.const WalkingCospan).obj t.pt).map inl ≫ t.π.app WalkingCospan.one =
    t.π.app WalkingCospan.left ≫ (cospan f g).map inl
⊢ t.π.app WalkingCospan.one = t.fst ≫ f
tactic: have w := t.π.naturality WalkingCospan.Hom.inl
state_before: C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w :
  ((Functor.const WalkingCospan).obj t.pt).map inl ≫ t.π.app WalkingCospan.one =
    t.π.app WalkingCospan.left ≫ (cospan f g).map inl
⊢ t.π.app WalkingCospan.one = t.fst ≫ f
state_after: C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w : 𝟙 t.pt ≫ t.π.app WalkingCospan.one = t.fst ≫ f
⊢ t.π.app WalkingCospan.one = t.fst ≫ f
tactic: dsimp at w
state_before: C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w : 𝟙 t.pt ≫ t.π.app WalkingCospan.one = t.fst ≫ f
⊢ t.π.app WalkingCospan.one = t.fst ≫ f
state_after: no goals
tactic: simpa using w
Theorem: Affine.Simplex.dist_circumcenter_sq_eq_sq_sub_circumradius
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 : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist p₁ s.circumcenter * dist p₁ s.circumcenter = r * r - s.circumradius * s.circumradius
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist s.circumcenter p₁ * dist s.circumcenter p₁ =
    dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) * dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) +
        dist p₁ ↑(s.orthogonalProjectionSpan p₁) * dist p₁ ↑(s.orthogonalProjectionSpan p₁) -
      s.circumradius * s.circumradius
tactic: rw [dist_comm, ← h₁ 0,
    s.dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p₁ h]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist s.circumcenter p₁ * dist s.circumcenter p₁ =
    dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) * dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) +
        dist p₁ ↑(s.orthogonalProjectionSpan p₁) * dist p₁ ↑(s.orthogonalProjectionSpan p₁) -
      s.circumradius * s.circumradius
state_after: no goals
tactic: simp only [h₁', dist_comm p₁, add_sub_cancel_left, Simplex.dist_circumcenter_eq_circumradius]
Theorem: charP_zero_or_prime_power
File: Mathlib/Algebra/CharP/LocalRing.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
⊢ q = 0 ∨ IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
⊢ ¬q = 0 → IsPrimePow q
tactic: apply or_iff_not_imp_left.2
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
⊢ ¬q = 0 → IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
⊢ IsPrimePow q
tactic: intro q_pos
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
⊢ IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
⊢ IsPrimePow q
tactic: let K := LocalRing.ResidueField R
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
⊢ IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
⊢ IsPrimePow q
tactic: haveI RM_char := ringChar.charP K
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
⊢ IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
⊢ IsPrimePow q
tactic: let r := ringChar K
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
⊢ IsPrimePow q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
n : ℕ := q.factorization r
⊢ IsPrimePow q
tactic: let n := q.factorization r
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
n : ℕ := q.factorization r
⊢ IsPrimePow q
state_after: case inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
n : ℕ := q.factorization r
r_prime : Nat.Prime r
⊢ IsPrimePow q

case inr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : LocalRing R
q : ℕ
char_R_q : CharP R q
q_pos : ¬q = 0
K : Type u_1 := LocalRing.ResidueField R
RM_char : CharP K (ringChar K)
r : ℕ := ringChar K
n : ℕ := q.factorization r
r_zero : r = 0
⊢ IsPrimePow q
tactic: cases' CharP.char_is_prime_or_zero K r with r_prime r_zero
Theorem: MvPolynomial.mem_vars_bind₁
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
j : τ
h : j ∈ ((bind₁ f) φ).vars
⊢ ∃ i ∈ φ.vars, j ∈ (f i).vars
state_after: no goals
tactic: classical
  simpa only [exists_prop, Finset.mem_biUnion, mem_support_iff, Ne] using vars_bind₁ f φ h
Theorem: Rel.inv_top
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
⊢ ⊤.inv = ⊤
state_after: no goals
tactic: simp [Top.top, inv, Function.flip_def]
Theorem: Mathlib.Vector.eq_cons_iff
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n.succ
v' : Vector α n
h : v.head = a ∧ v.tail = v'
⊢ v.head ::ᵥ v.tail = a ::ᵥ v'
state_after: no goals
tactic: rw [h.1, h.2]
Theorem: wbtw_pointReflection
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ Wbtw R y x ((pointReflection R x) y)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ (lineMap y ((pointReflection R x) y)) 2⁻¹ = x
tactic: refine ⟨2⁻¹, ⟨by norm_num, by norm_num⟩, ?_⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ (lineMap y ((pointReflection R x) y)) 2⁻¹ = x
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 2⁻¹ • 2 • (x -ᵥ y) +ᵥ y = x
tactic: rw [lineMap_apply, pointReflection_apply, vadd_vsub_assoc, ← two_smul R (x -ᵥ y)]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 2⁻¹ • 2 • (x -ᵥ y) +ᵥ y = x
state_after: no goals
tactic: simp
Theorem: Hyperreal.IsSt.unique
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
r s : ℝ
hr : x.IsSt r
hs : x.IsSt s
⊢ r = s
state_after: case intro
r s : ℝ
f : ℕ → ℝ
hr : (ofSeq f).IsSt r
hs : (ofSeq f).IsSt s
⊢ r = s
tactic: rcases ofSeq_surjective x with ⟨f, rfl⟩
state_before: case intro
r s : ℝ
f : ℕ → ℝ
hr : (ofSeq f).IsSt r
hs : (ofSeq f).IsSt s
⊢ r = s
state_after: case intro
r s : ℝ
f : ℕ → ℝ
hr : Tendsto f (↑(hyperfilter ℕ)) (𝓝 r)
hs : Tendsto f (↑(hyperfilter ℕ)) (𝓝 s)
⊢ r = s
tactic: rw [isSt_ofSeq_iff_tendsto] at hr hs
state_before: case intro
r s : ℝ
f : ℕ → ℝ
hr : Tendsto f (↑(hyperfilter ℕ)) (𝓝 r)
hs : Tendsto f (↑(hyperfilter ℕ)) (𝓝 s)
⊢ r = s
state_after: no goals
tactic: exact tendsto_nhds_unique hr hs
Theorem: geom_sum_Ico_mul
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Ring α
x : α
m n : ℕ
hmn : m ≤ n
⊢ (∑ i ∈ Ico m n, x ^ i) * (x - 1) = x ^ n - x ^ m
state_after: no goals
tactic: rw [sum_Ico_eq_sub _ hmn, sub_mul, geom_sum_mul, geom_sum_mul, sub_sub_sub_cancel_right]
Theorem: ProbabilityTheory.IsRatCondKernelCDFAux.tendsto_zero_of_antitone
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝ : IsFiniteKernel ν
a : α
seq : ℕ → ℚ
hseq : Antitone seq
hseq_tendsto : Tendsto seq atTop atBot
⊢ ∀ᵐ (c : β) ∂ν a, Tendsto (fun m => f (a, c) (seq m)) atTop (𝓝 0)
state_after: case refine_1
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝ : IsFiniteKernel ν
a : α
seq : ℕ → ℚ
hseq : Antitone seq
hseq_tendsto : Tendsto seq atTop atBot
⊢ ∀ (n : ℕ), Integrable (fun c => f (a, c) (seq n)) (ν a)

case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝ : IsFiniteKernel ν
a : α
seq : ℕ → ℚ
hseq : Antitone seq
hseq_tendsto : Tendsto seq atTop atBot
⊢ Tendsto (fun i => ∫ (a_1 : β), f (a, a_1) (seq i) ∂ν a) atTop (𝓝 (∫ (a : β), 0 ∂ν a))

case refine_3
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝ : IsFiniteKernel ν
a : α
seq : ℕ → ℚ
hseq : Antitone seq
hseq_tendsto : Tendsto seq atTop atBot
⊢ ∀ᵐ (a_1 : β) ∂ν a, Antitone fun i => f (a, a_1) (seq i)

case refine_4
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝ : IsFiniteKernel ν
a : α
seq : ℕ → ℚ
hseq : Antitone seq
hseq_tendsto : Tendsto seq atTop atBot
⊢ ∀ᵐ (a_1 : β) ∂ν a, ∀ (i : ℕ), 0 ≤ f (a, a_1) (seq i)
tactic: refine tendsto_of_integral_tendsto_of_antitone ?_ (integrable_const _) ?_ ?_ ?_
Theorem: Real.log_neg_of_lt_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
h0 : x < 0
h1 : -1 < x
⊢ log x < 0
state_after: x y : ℝ
h0 : x < 0
h1 : -1 < x
⊢ log (-x) < 0
tactic: rw [← neg_neg x, log_neg_eq_log]
state_before: x y : ℝ
h0 : x < 0
h1 : -1 < x
⊢ log (-x) < 0
state_after: x y : ℝ
h0 : x < 0
h1 : -1 < x
h0' : 0 < -x
⊢ log (-x) < 0
tactic: have h0' : 0 < -x := by linarith
state_before: x y : ℝ
h0 : x < 0
h1 : -1 < x
h0' : 0 < -x
⊢ log (-x) < 0
state_after: x y : ℝ
h0 : x < 0
h1 : -1 < x
h0' : 0 < -x
h1' : -x < 1
⊢ log (-x) < 0
tactic: have h1' : -x < 1 := by linarith
state_before: x y : ℝ
h0 : x < 0
h1 : -1 < x
h0' : 0 < -x
h1' : -x < 1
⊢ log (-x) < 0
state_after: no goals
tactic: exact log_neg h0' h1'
Theorem: HasProd.map
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✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
⊢ HasProd (⇑g ∘ f) (g a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ HasProd (⇑g ∘ f) (g a)
tactic: have : (g ∘ fun s : Finset β ↦ ∏ b ∈ s, f b) = fun s : Finset β ↦ ∏ b ∈ s, (g ∘ f) b :=
    funext <| map_prod g _
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✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ HasProd (⇑g ∘ f) (g a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ Tendsto (fun s => ∏ b ∈ s, (⇑g ∘ f) b) atTop (𝓝 (g a))
tactic: unfold HasProd
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✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ Tendsto (fun s => ∏ b ∈ s, (⇑g ∘ f) b) atTop (𝓝 (g a))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ Tendsto (⇑g ∘ fun s => ∏ b ∈ s, f b) atTop (𝓝 (g a))
tactic: rw [← this]
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✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
hf : HasProd f a
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Continuous ⇑g
this : (⇑g ∘ fun s => ∏ b ∈ s, f b) = fun s => ∏ b ∈ s, (⇑g ∘ f) b
⊢ Tendsto (⇑g ∘ fun s => ∏ b ∈ s, f b) atTop (𝓝 (g a))
state_after: no goals
tactic: exact (hg.tendsto a).comp hf
Theorem: Filter.kernMap_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
⊢ kernMap m (𝓟 s) = 𝓟 (kernImage m s)
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
g : Filter β
⊢ g ≤ kernMap m (𝓟 s) ↔ g ≤ 𝓟 (kernImage m s)
tactic: refine eq_of_forall_le_iff (fun g ↦ ?_)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
g : Filter β
⊢ g ≤ kernMap m (𝓟 s) ↔ g ≤ 𝓟 (kernImage m s)
state_after: no goals
tactic: rw [← comap_le_iff_le_kernMap, le_principal_iff, le_principal_iff, mem_comap'']
Theorem: leftCoset_rightCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Semigroup α
s : Set α
a b : α
⊢ op b • a • s = a • op b • s
state_after: no goals
tactic: simp [← image_smul, (image_comp _ _ _).symm, Function.comp, mul_assoc]
Theorem: List.get?_enum
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
n : ℕ
⊢ l.enum.get? n = Option.map (fun a => (n, a)) (l.get? n)
state_after: no goals
tactic: simp
Theorem: WithZero.map'_map'
File: Mathlib/Algebra/GroupWithZero/WithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MulOneClass γ
f : α →* β
g : β →* γ
x : WithZero α
⊢ (map' g) ((map' f) x) = (map' (g.comp f)) x
state_after: no goals
tactic: induction x <;> rfl
Theorem: Cycle.formPerm_subsingleton
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : s.Subsingleton
⊢ s.formPerm ⋯ = 1
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : Subsingleton (Quot.mk Setoid.r s)
⊢ formPerm (Quot.mk Setoid.r s) ⋯ = 1
tactic: induction' s using Quot.inductionOn with s
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : Subsingleton (Quot.mk Setoid.r s)
⊢ formPerm (Quot.mk Setoid.r s) ⋯ = 1
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : Subsingleton (Quot.mk Setoid.r s)
⊢ s.formPerm = 1
tactic: simp only [formPerm_coe, mk_eq_coe]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : Subsingleton (Quot.mk Setoid.r s)
⊢ s.formPerm = 1
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : s.length ≤ 1
⊢ s.formPerm = 1
tactic: simp only [length_subsingleton_iff, length_coe, mk_eq_coe] at h
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s✝ s' : Cycle α
s : List α
h : s.length ≤ 1
⊢ s.formPerm = 1
state_after: case h.nil
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
h : [].length ≤ 1
⊢ [].formPerm = 1

case h.cons
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
hd : α
tl : List α
h : (hd :: tl).length ≤ 1
⊢ (hd :: tl).formPerm = 1
tactic: cases' s with hd tl
Theorem: CategoryTheory.leftDistributor_ext₂_left
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⊗ Y ⊗ ⨁ f ⟶ Z
w : ∀ (j : J), X ◁ Y ◁ biproduct.ι f j ≫ g = X ◁ Y ◁ biproduct.ι f j ≫ h
⊢ g = h
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⊗ Y ⊗ ⨁ f ⟶ Z
w : ∀ (j : J), X ◁ Y ◁ biproduct.ι f j ≫ g = X ◁ Y ◁ biproduct.ι f j ≫ h
⊢ (α_ X Y (⨁ f)).hom ≫ g = (α_ X Y (⨁ f)).hom ≫ h
tactic: apply (cancel_epi (α_ _ _ _).hom).mp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⊗ Y ⊗ ⨁ f ⟶ Z
w : ∀ (j : J), X ◁ Y ◁ biproduct.ι f j ≫ g = X ◁ Y ◁ biproduct.ι f j ≫ h
⊢ (α_ X Y (⨁ f)).hom ≫ g = (α_ X Y (⨁ f)).hom ≫ h
state_after: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⊗ Y ⊗ ⨁ f ⟶ Z
w : ∀ (j : J), X ◁ Y ◁ biproduct.ι f j ≫ g = X ◁ Y ◁ biproduct.ι f j ≫ h
j✝ : J
⊢ (X ⊗ Y) ◁ biproduct.ι f j✝ ≫ (α_ X Y (⨁ f)).hom ≫ g = (X ⊗ Y) ◁ biproduct.ι f j✝ ≫ (α_ X Y (⨁ f)).hom ≫ h
tactic: ext
state_before: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⊗ Y ⊗ ⨁ f ⟶ Z
w : ∀ (j : J), X ◁ Y ◁ biproduct.ι f j ≫ g = X ◁ Y ◁ biproduct.ι f j ≫ h
j✝ : J
⊢ (X ⊗ Y) ◁ biproduct.ι f j✝ ≫ (α_ X Y (⨁ f)).hom ≫ g = (X ⊗ Y) ◁ biproduct.ι f j✝ ≫ (α_ X Y (⨁ f)).hom ≫ h
state_after: no goals
tactic: simp [w]
Theorem: Complex.hasStrictDerivAt_log
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

Proof steps:
state_before: x : ℂ
h : x ∈ slitPlane
h0 : x ≠ 0
⊢ HasStrictDerivAt (↑expPartialHomeomorph) x (↑expPartialHomeomorph.symm x)
state_after: no goals
tactic: simpa [exp_log h0] using hasStrictDerivAt_exp (log x)
Theorem: AddSubgroup.addSubgroupOf_eq_bot
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H K : Subgroup G
⊢ H.subgroupOf K = ⊥ ↔ Disjoint H K
state_after: no goals
tactic: rw [disjoint_iff, ← bot_subgroupOf, subgroupOf_inj, bot_inf_eq]
Theorem: CategoryTheory.Limits.Pi.map_comp_map'
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g : α → C
h : β → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
q : (a : α) → f a ⟶ g a
q' : (b : β) → g (p b) ⟶ h b
⊢ map q ≫ map' p q' = map' p fun b => q (p b) ≫ q' b
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g : α → C
h : β → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
q : (a : α) → f a ⟶ g a
q' : (b : β) → g (p b) ⟶ h b
b✝ : β
⊢ (map q ≫ map' p q') ≫ π h b✝ = (map' p fun b => q (p b) ≫ q' b) ≫ π h b✝
tactic: ext
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g : α → C
h : β → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
q : (a : α) → f a ⟶ g a
q' : (b : β) → g (p b) ⟶ h b
b✝ : β
⊢ (map q ≫ map' p q') ≫ π h b✝ = (map' p fun b => q (p b) ≫ q' b) ≫ π h b✝
state_after: no goals
tactic: simp
Theorem: sup_sdiff_right_self
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a ⊔ b) \ b = a \ b
state_after: no goals
tactic: rw [sup_sdiff, sdiff_self, sup_bot_eq]
Theorem: RingHom.map_rangeS
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
g : S →+* T
f : R →+* S
⊢ Subsemiring.map g f.rangeS = (g.comp f).rangeS
state_after: no goals
tactic: simpa only [rangeS_eq_map] using (⊤ : Subsemiring R).map_map g f
Theorem: Multiset.count_erase_of_ne
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a b : α
ab : a ≠ b
s : Multiset α
l : List α
⊢ count a (erase ⟦l⟧ b) = count a ⟦l⟧
state_after: no goals
tactic: convert List.count_erase_of_ne ab l <;> rw [← coe_count] <;> simp