ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasurableSpace.generateFrom_memPartition_le_range
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : ℕ → Set α
n : ℕ
⊢ generateFrom (memPartition t n) ≤ generateFrom (range t)
state_after: α : Type u_1
β : Type u_2
t : ℕ → Set α
n : ℕ
⊢ generateFrom (memPartition t n) ≤ generateFrom (⋃ n, memPartition t n)
tactic: conv_rhs => rw [← generateFrom_iUnion_memPartition t]
state_before: α : Type u_1
β : Type u_2
t : ℕ → Set α
n : ℕ
⊢ generateFrom (memPartition t n) ≤ generateFrom (⋃ n, memPartition t n)
state_after: no goals
tactic: exact generateFrom_mono (subset_iUnion _ _)
Theorem: neg_vadd_vadd
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : Group G
inst✝ : MulAction G α
g✝ : G
a✝ b : α
g : G
a : α
⊢ g⁻¹ • g • a = a
state_after: no goals
tactic: rw [smul_smul, mul_left_inv, one_smul]
Theorem: PadicInt.norm_int_le_pow_iff_dvd
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
⊢ ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
state_after: no goals
tactic: simpa [norm_intCast_eq_padic_norm]
Theorem: Finsupp.single_tsub
File: Mathlib/Data/Finsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝¹ : Sub α
inst✝ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
⊢ single i (a - b) = single i a - single i b
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝¹ : Sub α
inst✝ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
j : ι
⊢ (single i (a - b)) j = (single i a - single i b) j
tactic: ext j
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝¹ : Sub α
inst✝ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
j : ι
⊢ (single i (a - b)) j = (single i a - single i b) j
state_after: case h.inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝¹ : Sub α
inst✝ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
⊢ (single i (a - b)) i = (single i a - single i b) i

case h.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝¹ : Sub α
inst✝ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
j : ι
h : i ≠ j
⊢ (single i (a - b)) j = (single i a - single i b) j
tactic: obtain rfl | h := eq_or_ne i j
Theorem: PiLp.basis_toMatrix_basisFun_mul
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜✝ : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
𝕜 : Type u_5
inst✝ : SeminormedCommRing 𝕜
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
⊢ b.toMatrix ⇑(basisFun p 𝕜 ι) * A = of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (Aᵀ j))) i
state_after: p : ℝ≥0∞
𝕜✝ : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
𝕜 : Type u_5
inst✝ : SeminormedCommRing 𝕜
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this :
  (b.map (WithLp.linearEquiv p 𝕜 ((i : ι) → (fun x => 𝕜) i))).toMatrix ⇑(Pi.basisFun 𝕜 ι) * A =
    of fun i j => ((b.map (WithLp.linearEquiv p 𝕜 ((i : ι) → (fun x => 𝕜) i))).repr (Aᵀ j)) i
⊢ b.toMatrix ⇑(basisFun p 𝕜 ι) * A = of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (Aᵀ j))) i
tactic: have := basis_toMatrix_basisFun_mul (b.map (WithLp.linearEquiv _ 𝕜 _)) A
state_before: p : ℝ≥0∞
𝕜✝ : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
𝕜 : Type u_5
inst✝ : SeminormedCommRing 𝕜
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this :
  (b.map (WithLp.linearEquiv p 𝕜 ((i : ι) → (fun x => 𝕜) i))).toMatrix ⇑(Pi.basisFun 𝕜 ι) * A =
    of fun i j => ((b.map (WithLp.linearEquiv p 𝕜 ((i : ι) → (fun x => 𝕜) i))).repr (Aᵀ j)) i
⊢ b.toMatrix ⇑(basisFun p 𝕜 ι) * A = of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (Aᵀ j))) i
state_after: p : ℝ≥0∞
𝕜✝ : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
𝕜 : Type u_5
inst✝ : SeminormedCommRing 𝕜
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this : (b.toMatrix fun x => (basisFun p 𝕜 ι) x) * A = of fun i j => (b.repr ((WithLp.equiv p (ι → 𝕜)).symm (Aᵀ j))) i
⊢ b.toMatrix ⇑(basisFun p 𝕜 ι) * A = of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (Aᵀ j))) i
tactic: simp_rw [← PiLp.basisFun_map p, Basis.map_repr, LinearEquiv.trans_apply,
    WithLp.linearEquiv_symm_apply, Basis.toMatrix_map, Function.comp, Basis.map_apply,
    LinearEquiv.symm_apply_apply] at this
state_before: p : ℝ≥0∞
𝕜✝ : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
𝕜 : Type u_5
inst✝ : SeminormedCommRing 𝕜
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this : (b.toMatrix fun x => (basisFun p 𝕜 ι) x) * A = of fun i j => (b.repr ((WithLp.equiv p (ι → 𝕜)).symm (Aᵀ j))) i
⊢ b.toMatrix ⇑(basisFun p 𝕜 ι) * A = of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (Aᵀ j))) i
state_after: no goals
tactic: exact this
Theorem: LSeriesHasSum.convolution
File: Mathlib/NumberTheory/LSeries/Convolution.lean

Proof steps:
state_before: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
⊢ LSeriesHasSum (f ⍟ g) s (a * b)
state_after: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
⊢ HasSum (fun n => ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2) (a * b)
tactic: simp only [LSeriesHasSum, term_convolution']
state_before: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
⊢ HasSum (fun n => ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2) (a * b)
state_after: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
hsum : Summable fun x => term f s x.1 * term g s x.2
⊢ HasSum (fun n => ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2) (a * b)
tactic: have hsum := summable_mul_of_summable_norm hf.summable.norm hg.summable.norm
state_before: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
hsum : Summable fun x => term f s x.1 * term g s x.2
⊢ HasSum (fun n => ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2) (a * b)
state_after: no goals
tactic: exact (HasSum.mul hf hg hsum).tsum_fiberwise (fun p ↦ p.1 * p.2)
Theorem: List.ofFn_eq_pmap
File: Mathlib/Data/List/FinRange.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = pmap (fun i hi => f ⟨i, hi⟩) (range n) ⋯
state_after: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = map (fun x => f ⟨↑x, ⋯⟩) (range n).attach
tactic: rw [pmap_eq_map_attach]
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = map (fun x => f ⟨↑x, ⋯⟩) (range n).attach
state_after: no goals
tactic: exact ext_getElem (by simp) fun i hi1 hi2 => by simp [getElem_ofFn f i hi1]
Theorem: LocalRing.isLocalRingHom_residue
File: Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ IsLocalRingHom (residue R)
state_after: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ ∀ (a : R), IsUnit ((residue R) a) → IsUnit a
tactic: constructor
state_before: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ ∀ (a : R), IsUnit ((residue R) a) → IsUnit a
state_after: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
⊢ IsUnit a
tactic: intro a ha
state_before: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
⊢ IsUnit a
state_after: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
h : ¬IsUnit a
⊢ False
tactic: by_contra h
state_before: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
h : ¬IsUnit a
⊢ False
state_after: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit 0
h : ¬IsUnit a
⊢ False
tactic: erw [Ideal.Quotient.eq_zero_iff_mem.mpr ((LocalRing.mem_maximalIdeal _).mpr h)] at ha
state_before: case map_nonunit
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit 0
h : ¬IsUnit a
⊢ False
state_after: no goals
tactic: exact ha.ne_zero rfl
Theorem: TopologicalSpace.productOfMemOpens_inducing
File: Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
⊢ Inducing ⇑(productOfMemOpens X)
state_after: case h.e'_3
X : Type u_1
inst✝ : TopologicalSpace X
⊢ inst✝ = ⨅ i, induced (fun x => x ∈ i) inferInstance
tactic: convert inducing_iInf_to_pi fun (u : Opens X) (x : X) => x ∈ u
state_before: case h.e'_3
X : Type u_1
inst✝ : TopologicalSpace X
⊢ inst✝ = ⨅ i, induced (fun x => x ∈ i) inferInstance
state_after: no goals
tactic: apply eq_induced_by_maps_to_sierpinski
Theorem: Subtype.preconnectedSpace
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
h : IsPreconnected s
⊢ IsPreconnected univ
state_after: no goals
tactic: rwa [← inducing_subtype_val.isPreconnected_image, image_univ, Subtype.range_val]
Theorem: SimpleGraph.Subgraph.deleteEdges_spanningCoe_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
⊢ G'.spanningCoe.deleteEdges s = (G'.deleteEdges s).spanningCoe
state_after: case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ (G'.spanningCoe.deleteEdges s).Adj x✝¹ x✝ ↔ (G'.deleteEdges s).spanningCoe.Adj x✝¹ x✝
tactic: ext
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ (G'.spanningCoe.deleteEdges s).Adj x✝¹ x✝ ↔ (G'.deleteEdges s).spanningCoe.Adj x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: DirectSum.coe_decompose_mul_of_right_mem_of_le
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁸ : Semiring A
inst✝⁷ : DecidableEq ι
inst✝⁶ : CanonicallyOrderedAddCommMonoid ι
inst✝⁵ : SetLike σ A
inst✝⁴ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝³ : GradedRing 𝒜
a b : A
n i : ι
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b_mem : b ∈ 𝒜 i
h : i ≤ n
⊢ ↑(((decompose 𝒜) (a * b)) n) = ↑(((decompose 𝒜) a) (n - i)) * b
state_after: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁸ : Semiring A
inst✝⁷ : DecidableEq ι
inst✝⁶ : CanonicallyOrderedAddCommMonoid ι
inst✝⁵ : SetLike σ A
inst✝⁴ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝³ : GradedRing 𝒜
a : A
n i : ι
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : i ≤ n
b : ↥(𝒜 i)
⊢ ↑(((decompose 𝒜) (a * ↑b)) n) = ↑(((decompose 𝒜) a) (n - i)) * ↑b
tactic: lift b to 𝒜 i using b_mem
state_before: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁸ : Semiring A
inst✝⁷ : DecidableEq ι
inst✝⁶ : CanonicallyOrderedAddCommMonoid ι
inst✝⁵ : SetLike σ A
inst✝⁴ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝³ : GradedRing 𝒜
a : A
n i : ι
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : i ≤ n
b : ↥(𝒜 i)
⊢ ↑(((decompose 𝒜) (a * ↑b)) n) = ↑(((decompose 𝒜) a) (n - i)) * ↑b
state_after: no goals
tactic: rwa [decompose_mul, decompose_coe, coe_mul_of_apply_of_le]
Theorem: Polynomial.eval₂_sub
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Ring R
p q r : R[X]
S : Type u_1
inst✝ : Ring S
f : R →+* S
x : S
⊢ eval₂ f x (p - q) = eval₂ f x p - eval₂ f x q
state_after: no goals
tactic: rw [sub_eq_add_neg, eval₂_add, eval₂_neg, sub_eq_add_neg]
Theorem: AnalyticAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean

Proof steps:
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x
state_after: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x
tactic: have e : (fun z ↦ f z ^ g z) =ᶠ[𝓝 x] fun z ↦ exp (log (f z) * g z) := by
    filter_upwards [(fa.continuousAt.eventually_ne (slitPlane_ne_zero m))]
    intro z fz
    simp only [fz, cpow_def, if_false]
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x
state_after: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => cexp (log (f z) * g z)) x
tactic: rw [analyticAt_congr e]
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => cexp (log (f z) * g z)) x
state_after: no goals
tactic: exact ((fa.clog m).mul ga).cexp
Theorem: Trivialization.apply_eq_prod_continuousLinearEquivAt
File: Mathlib/Topology/VectorBundle/Basic.lean

Proof steps:
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
z : E b
⊢ ↑e { proj := b, snd := z } = (b, (continuousLinearEquivAt R e b hb) z)
state_after: case a
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
z : E b
⊢ (↑e { proj := b, snd := z }).1 = (b, (continuousLinearEquivAt R e b hb) z).1

case a
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
z : E b
⊢ (↑e { proj := b, snd := z }).2 = (b, (continuousLinearEquivAt R e b hb) z).2
tactic: ext
Theorem: MeasurableEquiv.measurable_comp_iff
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 δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
⊢ Measurable f
state_after: α : 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 δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
this : Measurable (f ∘ ⇑(e.symm.trans e).toEquiv)
⊢ Measurable f
tactic: have : Measurable (f ∘ (e.symm.trans e).toEquiv) := hfe.comp e.symm.measurable
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 δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
this : Measurable (f ∘ ⇑(e.symm.trans e).toEquiv)
⊢ Measurable f
state_after: no goals
tactic: rwa [coe_toEquiv, symm_trans_self] at this
Theorem: MeasureTheory.smul_convolution
File: Mathlib/Analysis/Convolution.lean

Proof steps:
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
⊢ y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g)
state_after: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
x✝ : G
⊢ (y • f ⋆[L, μ] g) x✝ = (y • (f ⋆[L, μ] g)) x✝
tactic: ext
state_before: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
x✝ : G
⊢ (y • f ⋆[L, μ] g) x✝ = (y • (f ⋆[L, μ] g)) x✝
state_after: no goals
tactic: simp only [Pi.smul_apply, convolution_def, ← integral_smul, L.map_smul₂]
Theorem: CategoryTheory.EffectiveEpiFamily.hom_ext
File: Mathlib/CategoryTheory/EffectiveEpi/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
B W : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
inst✝ : EffectiveEpiFamily X π
m₁ m₂ : B ⟶ W
h : ∀ (a : α), π a ≫ m₁ = π a ≫ m₂
⊢ m₁ = m₂
state_after: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
B W : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
inst✝ : EffectiveEpiFamily X π
m₁ m₂ : B ⟶ W
h : ∀ (a : α), π a ≫ m₁ = π a ≫ m₂
this : m₂ = desc X π (fun a => π a ≫ m₂) ⋯
⊢ m₁ = m₂
tactic: have : m₂ = EffectiveEpiFamily.desc X π (fun a => π a ≫ m₂)
      (fun a₁ a₂ g₁ g₂ h => by simp only [← Category.assoc, h]) := by
    apply EffectiveEpiFamily.uniq; intro; rfl
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
B W : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
inst✝ : EffectiveEpiFamily X π
m₁ m₂ : B ⟶ W
h : ∀ (a : α), π a ≫ m₁ = π a ≫ m₂
this : m₂ = desc X π (fun a => π a ≫ m₂) ⋯
⊢ m₁ = m₂
state_after: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
B W : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
inst✝ : EffectiveEpiFamily X π
m₁ m₂ : B ⟶ W
h : ∀ (a : α), π a ≫ m₁ = π a ≫ m₂
this : m₂ = desc X π (fun a => π a ≫ m₂) ⋯
⊢ m₁ = desc X π (fun a => π a ≫ m₂) ⋯
tactic: rw [this]
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
B W : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
inst✝ : EffectiveEpiFamily X π
m₁ m₂ : B ⟶ W
h : ∀ (a : α), π a ≫ m₁ = π a ≫ m₂
this : m₂ = desc X π (fun a => π a ≫ m₂) ⋯
⊢ m₁ = desc X π (fun a => π a ≫ m₂) ⋯
state_after: no goals
tactic: exact EffectiveEpiFamily.uniq _ _ _ _ _ h
Theorem: Real.sign_one
File: Mathlib/Data/Real/Sign.lean

Proof steps:
state_before: ⊢ 0 < 1
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.eqToIso_map_trans
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
p : X = Y
q : Y = Z
⊢ F.mapIso (eqToIso p) ≪≫ F.mapIso (eqToIso q) = F.mapIso (eqToIso ⋯)
state_after: no goals
tactic: aesop_cat
Theorem: FirstOrder.Language.Theory.exists_model_card_eq
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
h : ∃ M, Infinite ↑M
κ : Cardinal.{w}
h1 : ℵ₀ ≤ κ
h2 : lift.{w, max u v} L.card ≤ lift.{max u v, w} κ
⊢ ∃ N, #↑N = κ
state_after: no goals
tactic: cases h with
  | intro M MI =>
    haveI := MI
    obtain ⟨N, hN, rfl⟩ := exists_elementarilyEquivalent_card_eq L M κ h1 h2
    haveI : Nonempty N := hN.nonempty
    exact ⟨hN.theory_model.bundled, rfl⟩
Theorem: Set.toFinset_inj
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
h : s.toFinset = t.toFinset
⊢ s = t
state_after: no goals
tactic: rw [← s.coe_toFinset, h, t.coe_toFinset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
h : s = t
⊢ s.toFinset = t.toFinset
state_after: no goals
tactic: simp [h]
Theorem: commute_star_comm
File: Mathlib/Algebra/Star/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Mul R
inst✝ : StarMul R
x y : R
⊢ Commute (star x) y ↔ Commute x (star y)
state_after: no goals
tactic: rw [← commute_star_star, star_star]