ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Surreal.Multiplication.ih₂₁
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
⊢ ∀ (a : Args), ArgsRel a (Args.P24 x₂ x₁ y) → P124 a
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₁, y, x₂} →
      P124 a
⊢ ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₂, y, x₁} →
      P124 a
tactic: simp_rw [ArgsRel, InvImage, Args.toMultiset, Multiset.pair_comm] at ih' ⊢
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₁, y, x₂} →
      P124 a
⊢ ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₂, y, x₁} →
      P124 a
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₁, y, x₂} →
      P124 a
⊢ {x₁, y, x₂} = {x₂, y, x₁}
tactic: suffices {x₁, y, x₂} = {x₂, y, x₁} by rwa [← this]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y, x}
        | Args.P24 x₁ x₂ y => {x₁, y, x₂})
        {x₁, y, x₂} →
      P124 a
⊢ {x₁, y, x₂} = {x₂, y, x₁}
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y} + {x}
        | Args.P24 x₁ x₂ y => {x₁} + ({y} + {x₂}))
        ({x₁} + ({y} + {x₂})) →
      P124 a
⊢ {x₁} + ({y} + {x₂}) = {x₂} + ({y} + {x₁})
tactic: dsimp only [Multiset.insert_eq_cons, ← Multiset.singleton_add] at ih' ⊢
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih' :
  ∀ (a : Args),
    TransGen (CutExpand IsOption)
        (match a with
        | Args.P1 x y => {y} + {x}
        | Args.P24 x₁ x₂ y => {x₁} + ({y} + {x₂}))
        ({x₁} + ({y} + {x₂})) →
      P124 a
⊢ {x₁} + ({y} + {x₂}) = {x₂} + ({y} + {x₁})
state_after: no goals
tactic: abel
Theorem: OrthonormalBasis.reindex_apply
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
v : ι → E
inst✝ : Fintype ι'
b : OrthonormalBasis ι 𝕜 E
e : ι ≃ ι'
i' : ι'
⊢ (b.reindex e) i' = b (e.symm i')
state_after: no goals
tactic: classical
    dsimp [reindex]
    rw [coe_ofRepr]
    dsimp
    rw [← b.repr_symm_single, LinearIsometryEquiv.piLpCongrLeft_symm,
      EuclideanSpace.piLpCongrLeft_single]
Theorem: EuclideanDomain.mod_add_div'
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + m / k * k = m
state_after: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + k * (m / k) = m
tactic: rw [mul_comm]
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + k * (m / k) = m
state_after: no goals
tactic: exact mod_add_div _ _
Theorem: stereographic'_source
File: Mathlib/Geometry/Manifold/Instances/Sphere.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
n : ℕ
inst✝ : Fact (finrank ℝ E = n + 1)
v : ↑(sphere 0 1)
⊢ (stereographic' n v).source = {v}ᶜ
state_after: no goals
tactic: simp [stereographic']
Theorem: Nat.factorization_one
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n p : ℕ
⊢ factorization 1 = 0
state_after: case h
a b m n p a✝ : ℕ
⊢ (factorization 1) a✝ = 0 a✝
tactic: ext
state_before: case h
a b m n p a✝ : ℕ
⊢ (factorization 1) a✝ = 0 a✝
state_after: no goals
tactic: simp [factorization]
Theorem: Concept.snd_subset_snd_iff
File: Mathlib/Order/Concept.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
⊢ c.toProd.2 ⊆ d.toProd.2 ↔ d ≤ c
state_after: case refine_1
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.toProd.2 ⊆ d.toProd.2
⊢ d ≤ c

case refine_2
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ c.toProd.2 ⊆ d.toProd.2
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: MeasureTheory.Measure.sum_of_isEmpty
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
inst✝ : IsEmpty ι
μ : ι → Measure α
⊢ sum μ = 0
state_after: no goals
tactic: rw [← measure_univ_eq_zero, sum_apply _ MeasurableSet.univ, tsum_empty]
Theorem: AddSubgroup.inf_relindex_left
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ (H ⊓ K).relindex H = K.relindex H
state_after: no goals
tactic: rw [inf_comm, inf_relindex_right]
Theorem: NonUnitalStarSubalgebra.unitization_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
inst✝⁷ : Field R
inst✝⁶ : StarRing R
inst✝⁵ : Ring A
inst✝⁴ : StarRing A
inst✝³ : Algebra R A
inst✝² : StarModule R A
inst✝¹ : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
inst✝ : StarMemClass S A
s : S
h1 : 1 ∉ s
x✝ : ↥s
⊢ (unitization s) ↑x✝ = ↑x✝
state_after: no goals
tactic: simp
Theorem: intervalIntegral.smul_integral_comp_mul_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ c • ∫ (x : ℝ) in a..b, f (c * x - d) = ∫ (x : ℝ) in c * a - d..c * b - d, f x
state_after: no goals
tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_sub]
Theorem: FirstOrder.Language.Term.encoding_Γ
File: Mathlib/ModelTheory/Encoding.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
t : L.Term α
⊢ (fun l =>
        (do
            let a ← (listDecode l).head?
            pure (some a)).join)
      t.listEncode =
    some t
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
t : L.Term α
h : listDecode ([t].bind listEncode) = [t]
⊢ (fun l =>
        (do
            let a ← (listDecode l).head?
            pure (some a)).join)
      t.listEncode =
    some t
tactic: have h := listDecode_encode_list [t]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
t : L.Term α
h : listDecode ([t].bind listEncode) = [t]
⊢ (fun l =>
        (do
            let a ← (listDecode l).head?
            pure (some a)).join)
      t.listEncode =
    some t
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
t : L.Term α
h : listDecode t.listEncode = [t]
⊢ (fun l =>
        (do
            let a ← (listDecode l).head?
            pure (some a)).join)
      t.listEncode =
    some t
tactic: rw [bind_singleton] at h
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
t : L.Term α
h : listDecode t.listEncode = [t]
⊢ (fun l =>
        (do
            let a ← (listDecode l).head?
            pure (some a)).join)
      t.listEncode =
    some t
state_after: no goals
tactic: simp only [Option.join, h, head?_cons, Option.pure_def, Option.bind_eq_bind, Option.some_bind,
      id_eq]
Theorem: Nat.floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : 0 ≤ a
⊢ ⌊a + 1⌋₊ = ⌊a⌋₊ + 1
state_after: no goals
tactic: rw [← cast_one, floor_add_nat ha 1]
Theorem: MonoidAlgebra.mapDomainAlgHom_comp
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k✝ : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹² : CommSemiring k✝
inst✝¹¹ : Monoid G
inst✝¹⁰ : Monoid H
A✝ : Type u₃
inst✝⁹ : Semiring A✝
inst✝⁸ : Algebra k✝ A✝
B : Type u_3
inst✝⁷ : Semiring B
inst✝⁶ : Algebra k✝ B
k : Type u_4
A : Type u_5
G₁ : Type u_6
G₂ : Type u_7
G₃ : Type u_8
inst✝⁵ : CommSemiring k
inst✝⁴ : Semiring A
inst✝³ : Algebra k A
inst✝² : Monoid G₁
inst✝¹ : Monoid G₂
inst✝ : Monoid G₃
f : G₁ →* G₂
g : G₂ →* G₃
⊢ mapDomainAlgHom k A (g.comp f) = (mapDomainAlgHom k A g).comp (mapDomainAlgHom k A f)
state_after: case H
k✝ : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹² : CommSemiring k✝
inst✝¹¹ : Monoid G
inst✝¹⁰ : Monoid H
A✝ : Type u₃
inst✝⁹ : Semiring A✝
inst✝⁸ : Algebra k✝ A✝
B : Type u_3
inst✝⁷ : Semiring B
inst✝⁶ : Algebra k✝ B
k : Type u_4
A : Type u_5
G₁ : Type u_6
G₂ : Type u_7
G₃ : Type u_8
inst✝⁵ : CommSemiring k
inst✝⁴ : Semiring A
inst✝³ : Algebra k A
inst✝² : Monoid G₁
inst✝¹ : Monoid G₂
inst✝ : Monoid G₃
f : G₁ →* G₂
g : G₂ →* G₃
x✝ : MonoidAlgebra A G₁
⊢ (mapDomainAlgHom k A (g.comp f)) x✝ = ((mapDomainAlgHom k A g).comp (mapDomainAlgHom k A f)) x✝
tactic: ext
state_before: case H
k✝ : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹² : CommSemiring k✝
inst✝¹¹ : Monoid G
inst✝¹⁰ : Monoid H
A✝ : Type u₃
inst✝⁹ : Semiring A✝
inst✝⁸ : Algebra k✝ A✝
B : Type u_3
inst✝⁷ : Semiring B
inst✝⁶ : Algebra k✝ B
k : Type u_4
A : Type u_5
G₁ : Type u_6
G₂ : Type u_7
G₃ : Type u_8
inst✝⁵ : CommSemiring k
inst✝⁴ : Semiring A
inst✝³ : Algebra k A
inst✝² : Monoid G₁
inst✝¹ : Monoid G₂
inst✝ : Monoid G₃
f : G₁ →* G₂
g : G₂ →* G₃
x✝ : MonoidAlgebra A G₁
⊢ (mapDomainAlgHom k A (g.comp f)) x✝ = ((mapDomainAlgHom k A g).comp (mapDomainAlgHom k A f)) x✝
state_after: no goals
tactic: simp [mapDomain_comp]
Theorem: Real.summable_one_div_nat_rpow
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: p : ℝ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p
state_after: no goals
tactic: simp
Theorem: PolyEquivTensor.right_inv
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ (toFunAlgHom R A) (invFun R A x) = x
state_after: case refine_1
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ ∀ (p q : A[X]),
    (toFunAlgHom R A) (invFun R A p) = p →
      (toFunAlgHom R A) (invFun R A q) = q → (toFunAlgHom R A) (invFun R A (p + q)) = p + q

case refine_2
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ ∀ (n : ℕ) (a : A), (toFunAlgHom R A) (invFun R A ((monomial n) a)) = (monomial n) a
tactic: refine Polynomial.induction_on' x ?_ ?_
Theorem: Matrix.inv_mulVec_eq_vec
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A✝ B A : Matrix n n α
inst✝ : Invertible A
u v : n → α
hM : u = A *ᵥ v
⊢ A⁻¹ *ᵥ u = v
state_after: no goals
tactic: rw [hM, Matrix.mulVec_mulVec, Matrix.inv_mul_of_invertible, Matrix.one_mulVec]
Theorem: List.iterate_eq_iterateTR
File: Mathlib/Data/List/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
⊢ @iterate = @iterateTR
state_after: case h.h.h.h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
α : Type u_7
f : α → α
a : α
n : ℕ
⊢ iterate f a n = iterateTR f a n
tactic: funext α f a n
state_before: case h.h.h.h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
α : Type u_7
f : α → α
a : α
n : ℕ
⊢ iterate f a n = iterateTR f a n
state_after: no goals
tactic: exact Eq.symm <| iterateTR_loop_eq f a n []
Theorem: CompactSpace.uniformContinuous_of_continuous
File: Mathlib/Topology/UniformSpace/Compact.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
f : α → β
h : Continuous f
⊢ map (Prod.map f f) (𝓤 α) = map (Prod.map f f) (𝓝ˢ (diagonal α))
state_after: no goals
tactic: rw [nhdsSet_diagonal_eq_uniformity]
Theorem: Stream'.Seq1.map_id
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : Seq α
⊢ map id (a, s) = (a, s)
state_after: no goals
tactic: simp [map]
Theorem: MeasurableEquiv.measurableSet_preimage
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set β
h : MeasurableSet (⇑e ⁻¹' s)
⊢ MeasurableSet s
state_after: no goals
tactic: simpa only [symm_preimage_preimage] using e.symm.measurable h
Theorem: Polynomial.coeff_zero_eq_aeval_zero'
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : CommSemiring A'
inst✝³ : Semiring B
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R B
p✝ q : R[X]
x : A
p : R[X]
⊢ (algebraMap R A) (p.coeff 0) = (aeval 0) p
state_after: no goals
tactic: simp [aeval_def]
Theorem: LieSubmodule.range_incl
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
⊢ N.incl.range = N
state_after: no goals
tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff]
Theorem: HurwitzZeta.completedCosZeta_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedCosZeta (-a) s = completedCosZeta a s
state_after: no goals
tactic: simp only [completedCosZeta, hurwitzEvenFEPair_neg]
Theorem: Int.sub_one_lt_iff
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
⊢ m - 1 < n ↔ m ≤ n
state_after: no goals
tactic: omega
Theorem: WeierstrassCurve.ΨSq_one
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.ΨSq 1 = 1
state_after: no goals
tactic: erw [ΨSq_ofNat, preΨ'_one, one_pow, mul_one]
Theorem: Asymptotics.IsEquivalent.tendsto_nhds
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
⊢ Tendsto v l (𝓝 c)
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : c = 0
⊢ Tendsto v l (𝓝 c)

case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : ¬c = 0
⊢ Tendsto v l (𝓝 c)
tactic: by_cases h : c = 0
Theorem: Nat.bitIndices_two_pow
File: Mathlib/Data/Nat/BitIndices.lean

Proof steps:
state_before: a n k : ℕ
⊢ (2 ^ k).bitIndices = [k]
state_after: a n k : ℕ
⊢ map (fun x => x + k) (bitIndices 1) = [k]
tactic: rw [← mul_one (a := 2^k), bitIndices_two_pow_mul]
state_before: a n k : ℕ
⊢ map (fun x => x + k) (bitIndices 1) = [k]
state_after: no goals
tactic: simp
Theorem: Orientation.volumeForm_comp_linearIsometryEquiv
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
_i : Fact (finrank ℝ E = n)
o : Orientation ℝ E (Fin n)
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
x : Fin n → E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x
state_after: case zero
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
_i : Fact (finrank ℝ E = 0)
o : Orientation ℝ E (Fin 0)
x : Fin 0 → E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x

case succ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x
tactic: cases' n with n
state_before: case succ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x
state_after: case succ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
this : FiniteDimensional ℝ E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x
tactic: haveI : FiniteDimensional ℝ E := .of_fact_finrank_eq_succ n
state_before: case succ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
this : FiniteDimensional ℝ E
⊢ o.volumeForm (⇑φ ∘ x) = o.volumeForm x
state_after: case h.e'_2.h.e'_5.h.e'_6
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
this : FiniteDimensional ℝ E
⊢ o = (map (Fin (n + 1)) φ.toLinearEquiv) o

case h.e'_3.h.e'_6
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ : E ≃ₗᵢ[ℝ] E
hφ : 0 < LinearMap.det ↑φ.toLinearEquiv
n : ℕ
_i : Fact (finrank ℝ E = n + 1)
o : Orientation ℝ E (Fin (n + 1))
x : Fin (n + 1) → E
this : FiniteDimensional ℝ E
⊢ x = ⇑φ.symm ∘ ⇑φ ∘ x
tactic: convert o.volumeForm_map φ (φ ∘ x)
Theorem: unary_relation_sInf_iff
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
s : Set (α → Prop)
a : α
⊢ sInf s a ↔ ∀ r ∈ s, r a
state_after: α✝ : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
s : Set (α → Prop)
a : α
⊢ ⨅ f, ↑f a ↔ ∀ r ∈ s, r a
tactic: rw [sInf_apply]
state_before: α✝ : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
s : Set (α → Prop)
a : α
⊢ ⨅ f, ↑f a ↔ ∀ r ∈ s, r a
state_after: no goals
tactic: simp [← eq_iff_iff]
Theorem: tendsto_exp_mul_div_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: s b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => rexp (b * x) / x ^ s) atTop atTop
state_after: s b : ℝ
hb : 0 < b
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) =ᶠ[atTop] fun x => rexp (b * x) / x ^ s
tactic: refine ((tendsto_rpow_atTop hb).comp (tendsto_exp_div_rpow_atTop (s / b))).congr' ?_
state_before: s b : ℝ
hb : 0 < b
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) =ᶠ[atTop] fun x => rexp (b * x) / x ^ s
state_after: case h
s b : ℝ
hb : 0 < b
x : ℝ
hx₀ : 0 ≤ x
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) x = rexp (b * x) / x ^ s
tactic: filter_upwards [eventually_ge_atTop (0 : ℝ)] with x hx₀
state_before: case h
s b : ℝ
hb : 0 < b
x : ℝ
hx₀ : 0 ≤ x
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) x = rexp (b * x) / x ^ s
state_after: no goals
tactic: simp [Real.div_rpow, (exp_pos x).le, rpow_nonneg, ← Real.rpow_mul, ← exp_mul,
    mul_comm x, hb.ne', *]
Theorem: CochainComplex.HomComplex.Cochain.map_add
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ (z + z').map Φ = z.map Φ + z'.map Φ
state_after: no goals
tactic: aesop_cat