ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: continuousAt_const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b
state_after: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => a ^ x) b
tactic: have cpow_eq : (fun x : ℂ => a ^ x) = fun x => exp (log a * x) := by
    ext1 b
    rw [cpow_def_of_ne_zero ha]
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => a ^ x) b
state_after: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => cexp (Complex.log a * x)) b
tactic: rw [cpow_eq]
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => cexp (Complex.log a * x)) b
state_after: no goals
tactic: exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
Theorem: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_counitIso
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
K : Multifork I
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    ((𝟭 (Multifork I)).obj K).π.app j =
      (Iso.refl ((𝟭 (Multifork I)).obj K).pt).hom ≫ ((I.toPiForkFunctor ⋙ I.ofPiForkFunctor).obj K).π.app j
state_after: no goals
tactic: rintro (_ | _) <;> simp [← Fork.app_one_eq_ι_comp_left]
Theorem: MeasureTheory.measurePreserving_mul_prod_inv
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ MeasurePreserving (fun z => (z.2 * z.1, z.1⁻¹)) (μ.prod ν) (μ.prod ν)
state_after: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ (fun z => (z.2 * z.1, z.1⁻¹)) = (fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)
tactic: convert (measurePreserving_prod_inv_mul_swap ν μ).comp (measurePreserving_prod_mul_swap μ ν)
    using 1
state_before: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ (fun z => (z.2 * z.1, z.1⁻¹)) = (fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)
state_after: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
x y : G
⊢ ((x, y).2 * (x, y).1, (x, y).1⁻¹) = ((fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)) (x, y)
tactic: ext1 ⟨x, y⟩
state_before: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
x y : G
⊢ ((x, y).2 * (x, y).1, (x, y).1⁻¹) = ((fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)) (x, y)
state_after: no goals
tactic: simp_rw [Function.comp_apply, mul_inv_rev, inv_mul_cancel_right]
Theorem: gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive
File: Mathlib/NumberTheory/DirichletCharacter/GaussSum.lean

Proof steps:
state_before: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
hχ : χ.IsPrimitive
he : ¬e.IsPrimitive
⊢ gaussSum χ e = 0
state_after: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
⊢ ¬χ.IsPrimitive
tactic: contrapose! hχ
state_before: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
⊢ ¬χ.IsPrimitive
state_after: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
⊢ ¬χ.IsPrimitive
tactic: rcases e.exists_divisor_of_not_isPrimitive he with ⟨d, hd₁, hd₂, hed⟩
state_before: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
⊢ ¬χ.IsPrimitive
state_after: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
this : χ.conductor ≤ d
⊢ ¬χ.IsPrimitive
tactic: have : χ.conductor ≤ d := Nat.sInf_le <| factorsThrough_of_gaussSum_ne_zero e hd₁ hed hχ
state_before: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
this : χ.conductor ≤ d
⊢ ¬χ.IsPrimitive
state_after: no goals
tactic: exact (this.trans_lt hd₂).ne
Theorem: FreeAddGroup.Red.church_rosser
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflGen Step b b
state_after: no goals
tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflTransGen Step b b
state_after: no goals
tactic: rfl
Theorem: Orientation.rotation_neg_orientation_eq_neg
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
θ : Real.Angle
⊢ ∀ (x : V), ((-o).rotation θ) x = (o.rotation (-θ)) x
state_after: no goals
tactic: simp [rotation_apply]
Theorem: Subgroup.quotientiInfSubgroupOfEmbedding_apply
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s t : Subgroup α
ι : Type u_2
f : ι → Subgroup α
H : Subgroup α
⊢ ∀ (a₁ a₂ : ↥H),
    (fun q i => quotientSubgroupOfMapOfLE H ⋯ q) (Quotient.mk'' a₁) =
        (fun q i => quotientSubgroupOfMapOfLE H ⋯ q) (Quotient.mk'' a₂) →
      Quotient.mk'' a₁ = Quotient.mk'' a₂
state_after: no goals
tactic: simp_rw [funext_iff, quotientSubgroupOfMapOfLE_apply_mk, eq', mem_subgroupOf, mem_iInf,
        imp_self, forall_const]
Theorem: two_nsmul_lie_lmul_lmul_add_add_eq_zero
File: Mathlib/Algebra/Jordan/Basic.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆) = 0
state_after: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)
tactic: symm
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)
state_after: no goals
tactic: calc
    0 = ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆ := by
      rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
    _ = _ := by rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
Theorem: bihimp_bihimp_self
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ b ⇔ a = b
state_after: no goals
tactic: rw [bihimp_comm, bihimp_bihimp_cancel_left]
Theorem: List.dlookup_dedupKeys
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
⊢ dlookup a l.dedupKeys = dlookup a l
state_after: case nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ dlookup a [].dedupKeys = dlookup a []

case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l_hd : Sigma β
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
⊢ dlookup a (l_hd :: tail✝).dedupKeys = dlookup a (l_hd :: tail✝)
tactic: induction' l with l_hd _ l_ih
state_before: case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l_hd : Sigma β
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
⊢ dlookup a (l_hd :: tail✝).dedupKeys = dlookup a (l_hd :: tail✝)
state_after: case cons.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
a' : α
b : β a'
⊢ dlookup a (⟨a', b⟩ :: tail✝).dedupKeys = dlookup a (⟨a', b⟩ :: tail✝)
tactic: cases' l_hd with a' b
state_before: case cons.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
a' : α
b : β a'
⊢ dlookup a (⟨a', b⟩ :: tail✝).dedupKeys = dlookup a (⟨a', b⟩ :: tail✝)
state_after: case pos
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
a' : α
b : β a'
h : a = a'
⊢ dlookup a (⟨a', b⟩ :: tail✝).dedupKeys = dlookup a (⟨a', b⟩ :: tail✝)

case neg
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
tail✝ : List (Sigma β)
l_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝
a' : α
b : β a'
h : ¬a = a'
⊢ dlookup a (⟨a', b⟩ :: tail✝).dedupKeys = dlookup a (⟨a', b⟩ :: tail✝)
tactic: by_cases h : a = a'
Theorem: UniqueAdd.of_subsingleton
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : Subsingleton G
⊢ UniqueMul A B a0 b0
state_after: no goals
tactic: simp [UniqueMul, eq_iff_true_of_subsingleton]
Theorem: Polynomial.degree_add_divByMonic
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
⊢ q.degree + (p /ₘ q).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
⊢ q.degree + (p /ₘ q).degree = p.degree
tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
⊢ q.degree + (p /ₘ q).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
⊢ q.degree + (p /ₘ q).degree = p.degree
tactic: have hdiv0 : p /ₘ q ≠ 0 := by rwa [Ne, divByMonic_eq_zero_iff hq, not_lt]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
⊢ q.degree + (p /ₘ q).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
hlc : q.leadingCoeff * (p /ₘ q).leadingCoeff ≠ 0
⊢ q.degree + (p /ₘ q).degree = p.degree
tactic: have hlc : leadingCoeff q * leadingCoeff (p /ₘ q) ≠ 0 := by
    rwa [Monic.def.1 hq, one_mul, Ne, leadingCoeff_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
hlc : q.leadingCoeff * (p /ₘ q).leadingCoeff ≠ 0
⊢ q.degree + (p /ₘ q).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
hlc : q.leadingCoeff * (p /ₘ q).leadingCoeff ≠ 0
hmod : (p %ₘ q).degree < (q * (p /ₘ q)).degree
⊢ q.degree + (p /ₘ q).degree = p.degree
tactic: have hmod : degree (p %ₘ q) < degree (q * (p /ₘ q)) :=
    calc
      degree (p %ₘ q) < degree q := degree_modByMonic_lt _ hq
      _ ≤ _ := by
        rw [degree_mul' hlc, degree_eq_natDegree hq.ne_zero, degree_eq_natDegree hdiv0, ←
            Nat.cast_add, Nat.cast_le]
        exact Nat.le_add_right _ _
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
h : q.degree ≤ p.degree
a✝ : Nontrivial R
hdiv0 : p /ₘ q ≠ 0
hlc : q.leadingCoeff * (p /ₘ q).leadingCoeff ≠ 0
hmod : (p %ₘ q).degree < (q * (p /ₘ q)).degree
⊢ q.degree + (p /ₘ q).degree = p.degree
state_after: no goals
tactic: calc
    degree q + degree (p /ₘ q) = degree (q * (p /ₘ q)) := Eq.symm (degree_mul' hlc)
    _ = degree (p %ₘ q + q * (p /ₘ q)) := (degree_add_eq_right_of_degree_lt hmod).symm
    _ = _ := congr_arg _ (modByMonic_add_div _ hq)
Theorem: CoxeterSystem.isLeftInversion_simple_iff_isLeftDescent
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsLeftInversion w (cs.simple i) ↔ cs.IsLeftDescent w i
state_after: no goals
tactic: simp [IsLeftInversion, IsLeftDescent, cs.isReflection_simple i]
Theorem: Submodule.dense_iff_topologicalClosure_eq_top
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ Dense ↑s ↔ s.topologicalClosure = ⊤
state_after: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ closure ↑s = Set.univ ↔ ↑s.topologicalClosure = ↑⊤
tactic: rw [← SetLike.coe_set_eq, dense_iff_closure_eq]
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ closure ↑s = Set.univ ↔ ↑s.topologicalClosure = ↑⊤
state_after: no goals
tactic: simp
Theorem: Orthonormal.isHilbertSum
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ (span 𝕜 (Set.range v)).topologicalClosure
⊢ ⊤ ≤ (⨆ i, LinearMap.range (LinearIsometry.toSpanSingleton 𝕜 E ⋯).toLinearMap).topologicalClosure
state_after: case h.e'_4.h.e'_9
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ (span 𝕜 (Set.range v)).topologicalClosure
⊢ ⨆ i, LinearMap.range (LinearIsometry.toSpanSingleton 𝕜 E ⋯).toLinearMap = span 𝕜 (Set.range v)
tactic: convert hsp
state_before: case h.e'_4.h.e'_9
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ (span 𝕜 (Set.range v)).topologicalClosure
⊢ ⨆ i, LinearMap.range (LinearIsometry.toSpanSingleton 𝕜 E ⋯).toLinearMap = span 𝕜 (Set.range v)
state_after: no goals
tactic: simp [← LinearMap.span_singleton_eq_range, ← Submodule.span_iUnion]
Theorem: List.forM_append
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
l₁ l₂ : List α
f : α → m PUnit
⊢ (l₁ ++ l₂).forM f = do
    l₁.forM f
    l₂.forM f
state_after: no goals
tactic: induction l₁ <;> simp [*]
Theorem: Finset.prod_eq_single_of_mem
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 β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ b ∈ s, b ≠ a → f b = 1
⊢ ∏ x ∈ s, f x = f a
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ b ∈ s, b ≠ a → f b = 1
this : DecidableEq α
⊢ ∏ x ∈ s, f x = f a
tactic: haveI := Classical.decEq α
Theorem: SheafOfModules.GeneratingSections.ofEpi_I
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Generators.lean

Proof steps:
state_before: C : Type u'
inst✝⁴ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝³ : HasWeakSheafify J AddCommGrp
inst✝² : J.WEqualsLocallyBijective AddCommGrp
inst✝¹ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N P : SheafOfModules R
σ : M.GeneratingSections
p : M ⟶ N
inst✝ : Epi p
⊢ Epi (N.freeHomEquiv.symm fun i => sectionsMap p (σ.s i))
state_after: C : Type u'
inst✝⁴ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝³ : HasWeakSheafify J AddCommGrp
inst✝² : J.WEqualsLocallyBijective AddCommGrp
inst✝¹ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N P : SheafOfModules R
σ : M.GeneratingSections
p : M ⟶ N
inst✝ : Epi p
⊢ Epi (M.freeHomEquiv.symm σ.s ≫ p)
tactic: rw [← freeHomEquiv_symm_comp]
state_before: C : Type u'
inst✝⁴ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝³ : HasWeakSheafify J AddCommGrp
inst✝² : J.WEqualsLocallyBijective AddCommGrp
inst✝¹ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N P : SheafOfModules R
σ : M.GeneratingSections
p : M ⟶ N
inst✝ : Epi p
⊢ Epi (M.freeHomEquiv.symm σ.s ≫ p)
state_after: no goals
tactic: apply epi_comp
Theorem: Complex.arg_coe_angle_toReal_eq_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
⊢ (↑z.arg).toReal = z.arg
state_after: a x z✝ z : ℂ
⊢ z.arg ∈ Ioc (-π) π
tactic: rw [Real.Angle.toReal_coe_eq_self_iff_mem_Ioc]
state_before: a x z✝ z : ℂ
⊢ z.arg ∈ Ioc (-π) π
state_after: no goals
tactic: exact arg_mem_Ioc _
Theorem: exp_neg_mul_rpow_isLittleO_exp_neg
File: Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean

Proof steps:
state_before: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)
state_after: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => -x - -b * x ^ p) atTop atTop
tactic: rw [isLittleO_exp_comp_exp_comp]
state_before: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => -x - -b * x ^ p) atTop atTop
state_after: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => x * (b * x ^ (p - 1) + -1)) atTop atTop
tactic: suffices Tendsto (fun x => x * (b * x ^ (p - 1) + -1)) atTop atTop by
    refine Tendsto.congr' ?_ this
    refine eventuallyEq_of_mem (Ioi_mem_atTop (0 : ℝ)) (fun x hx => ?_)
    rw [mem_Ioi] at hx
    rw [rpow_sub_one hx.ne']
    field_simp [hx.ne']
    ring
state_before: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => x * (b * x ^ (p - 1) + -1)) atTop atTop
state_after: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => b * x ^ (p - 1) + -1) atTop atTop
tactic: apply Tendsto.atTop_mul_atTop tendsto_id
state_before: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => b * x ^ (p - 1) + -1) atTop atTop
state_after: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => b * x ^ (p - 1)) atTop atTop
tactic: refine tendsto_atTop_add_const_right atTop (-1 : ℝ) ?_
state_before: p b : ℝ
hb : 0 < b
hp : 1 < p
⊢ Tendsto (fun x => b * x ^ (p - 1)) atTop atTop
state_after: no goals
tactic: exact Tendsto.const_mul_atTop hb (tendsto_rpow_atTop (by linarith))
Theorem: MeasurableEmbedding.integral_map
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
ν : Measure α
β : Type u_7
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
g : β → G
⊢ ∫ (y : β), g y ∂Measure.map f μ = ∫ (x : α), g (f x) ∂μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
ν : Measure α
β : Type u_7
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
g : β → G
hgm : AEStronglyMeasurable g (Measure.map f μ)
⊢ ∫ (y : β), g y ∂Measure.map f μ = ∫ (x : α), g (f x) ∂μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
ν : Measure α
β : Type u_7
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
g : β → G
hgm : ¬AEStronglyMeasurable g (Measure.map f μ)
⊢ ∫ (y : β), g y ∂Measure.map f μ = ∫ (x : α), g (f x) ∂μ
tactic: by_cases hgm : AEStronglyMeasurable g (Measure.map f μ)
Theorem: FirstOrder.Language.LEquiv.trans_invLHom
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
L'' : Language
e'✝ : L' ≃ᴸ L''
e✝ e : L ≃ᴸ L'
e' : L' ≃ᴸ L''
⊢ (e.invLHom.comp e'.invLHom).comp (e'.toLHom.comp e.toLHom) = LHom.id L
state_after: no goals
tactic: rw [LHom.comp_assoc, ← LHom.comp_assoc e'.invLHom, e'.left_inv, LHom.id_comp, e.left_inv]
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
L'' : Language
e'✝ : L' ≃ᴸ L''
e✝ e : L ≃ᴸ L'
e' : L' ≃ᴸ L''
⊢ (e'.toLHom.comp e.toLHom).comp (e.invLHom.comp e'.invLHom) = LHom.id L''
state_after: no goals
tactic: rw [LHom.comp_assoc, ← LHom.comp_assoc e.toLHom, e.right_inv, LHom.id_comp, e'.right_inv]