ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.monic_multiset_prod_of_monic
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
ht : ∀ i ∈ t, (f i).Monic
⊢ (Multiset.map f t).prod.Monic
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
tactic: revert ht
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
state_after: case refine_1
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ (∀ i ∈ 0, (f i).Monic) → (Multiset.map f 0).prod.Monic

case refine_2
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ ∀ (a : ι) (s : Multiset ι),
    ((∀ i ∈ s, (f i).Monic) → (Multiset.map f s).prod.Monic) →
      (∀ i ∈ a ::ₘ s, (f i).Monic) → (Multiset.map f (a ::ₘ s)).prod.Monic
tactic: refine t.induction_on ?_ ?_
state_before: case refine_2
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ ∀ (a : ι) (s : Multiset ι),
    ((∀ i ∈ s, (f i).Monic) → (Multiset.map f s).prod.Monic) →
      (∀ i ∈ a ::ₘ s, (f i).Monic) → (Multiset.map f (a ::ₘ s)).prod.Monic
state_after: case refine_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
ht : ∀ i ∈ a ::ₘ t, (f i).Monic
⊢ (Multiset.map f (a ::ₘ t)).prod.Monic
tactic: intro a t ih ht
state_before: case refine_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
ht : ∀ i ∈ a ::ₘ t, (f i).Monic
⊢ (Multiset.map f (a ::ₘ t)).prod.Monic
state_after: case refine_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
ht : ∀ i ∈ a ::ₘ t, (f i).Monic
⊢ (f a * (Multiset.map f t).prod).Monic
tactic: rw [Multiset.map_cons, Multiset.prod_cons]
state_before: case refine_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic
ht : ∀ i ∈ a ::ₘ t, (f i).Monic
⊢ (f a * (Multiset.map f t).prod).Monic
state_after: no goals
tactic: exact (ht _ (Multiset.mem_cons_self _ _)).mul (ih fun _ hi => ht _ (Multiset.mem_cons_of_mem hi))
Theorem: Finset.prod_X_add_C_coeff
File: Mathlib/RingTheory/Polynomial/Vieta.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
s : Finset σ
r : σ → R
k : ℕ
h : k ≤ s.card
⊢ (∏ i ∈ s, (X + C (r i))).coeff k = ∑ t ∈ Finset.powersetCard (s.card - k) s, ∏ i ∈ t, r i
state_after: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
s : Finset σ
r : σ → R
k : ℕ
h : k ≤ s.card
⊢ ∑ t ∈ Finset.powersetCard (card s.val - k) s, t.prod r = ∑ t ∈ Finset.powersetCard (s.card - k) s, ∏ i ∈ t, r i
tactic: rw [Finset.prod, prod_X_add_C_coeff' _ r h, Finset.esymm_map_val]
state_before: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
s : Finset σ
r : σ → R
k : ℕ
h : k ≤ s.card
⊢ ∑ t ∈ Finset.powersetCard (card s.val - k) s, t.prod r = ∑ t ∈ Finset.powersetCard (s.card - k) s, ∏ i ∈ t, r i
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.map_withDensity_abs_det_fderiv_eq_addHaar
File: Mathlib/MeasureTheory/Function/Jacobian.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hs : MeasurableSet s
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
hf : InjOn f s
h'f : Measurable f
⊢ Measure.map f ((μ.restrict s).withDensity fun x => ENNReal.ofReal |(f' x).det|) = μ.restrict (f '' s)
state_after: E : Type u_1
F : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hs : MeasurableSet s
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
hf : InjOn f s
h'f : Measurable f
t : Set E
ht : MeasurableSet t
⊢ (Measure.map f ((μ.restrict s).withDensity fun x => ENNReal.ofReal |(f' x).det|)) t = (μ.restrict (f '' s)) t
tactic: apply Measure.ext fun t ht => ?_
state_before: E : Type u_1
F : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hs : MeasurableSet s
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
hf : InjOn f s
h'f : Measurable f
t : Set E
ht : MeasurableSet t
⊢ (Measure.map f ((μ.restrict s).withDensity fun x => ENNReal.ofReal |(f' x).det|)) t = (μ.restrict (f '' s)) t
state_after: no goals
tactic: rw [map_apply h'f ht, withDensity_apply _ (h'f ht), Measure.restrict_apply ht,
    restrict_restrict (h'f ht),
    lintegral_abs_det_fderiv_eq_addHaar_image μ ((h'f ht).inter hs)
      (fun x hx => (hf' x hx.2).mono inter_subset_right) (hf.mono inter_subset_right),
    image_preimage_inter]
Theorem: MvPolynomial.pderiv_monomial_single
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

Proof steps:
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
n : ℕ
⊢ (pderiv i) ((monomial (single i n)) a) = (monomial (single i (n - 1))) (a * ↑n)
state_after: no goals
tactic: simp
Theorem: PowerBasis.constr_pow_gen
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) pb.gen = y
state_after: no goals
tactic: convert pb.constr_pow_aeval hy X <;> rw [aeval_X]
Theorem: ArithmeticFunction.sum_moebius_mul_log_eq
File: Mathlib/NumberTheory/VonMangoldt.lean

Proof steps:
state_before: n : ℕ
⊢ ∑ d ∈ n.divisors, ↑(μ d) * log d = -Λ n
state_after: n : ℕ
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ x ∈ n.divisorsAntidiagonal, ↑(μ x.1) * -Real.log ↑x.2
tactic: simp only [← log_mul_moebius_eq_vonMangoldt, mul_comm log, mul_apply, log_apply, intCoe_apply, ←
    Finset.sum_neg_distrib, neg_mul_eq_mul_neg]
state_before: n : ℕ
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ x ∈ n.divisorsAntidiagonal, ↑(μ x.1) * -Real.log ↑x.2
state_after: n : ℕ
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i)
tactic: rw [sum_divisorsAntidiagonal fun i j => (μ i : ℝ) * -Real.log j]
state_before: n : ℕ
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i)
state_after: n : ℕ
this : ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i) = ∑ i ∈ n.divisors, (↑(μ i) * Real.log ↑i - ↑(μ i) * Real.log ↑n)
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i)
tactic: have : (∑ i ∈ n.divisors, (μ i : ℝ) * -Real.log (n / i : ℕ)) =
      ∑ i ∈ n.divisors, ((μ i : ℝ) * Real.log i - μ i * Real.log n) := by
    apply sum_congr rfl
    simp only [and_imp, Int.cast_eq_zero, mul_eq_mul_left_iff, Ne, neg_inj, mem_divisors]
    intro m mn hn
    have : (m : ℝ) ≠ 0 := by
      rw [cast_ne_zero]
      rintro rfl
      exact hn (by simpa using mn)
    rw [Nat.cast_div mn this, Real.log_div (cast_ne_zero.2 hn) this, neg_sub, mul_sub]
state_before: n : ℕ
this : ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i) = ∑ i ∈ n.divisors, (↑(μ i) * Real.log ↑i - ↑(μ i) * Real.log ↑n)
⊢ ∑ x ∈ n.divisors, ↑(μ x) * Real.log ↑x = ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i)
state_after: n : ℕ
this : ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i) = ∑ i ∈ n.divisors, (↑(μ i) * Real.log ↑i - ↑(μ i) * Real.log ↑n)
⊢ ↑(1 n) * Real.log ↑n = 0
tactic: rw [this, sum_sub_distrib, ← sum_mul, ← Int.cast_sum, ← coe_mul_zeta_apply, eq_comm, sub_eq_self,
    moebius_mul_coe_zeta]
state_before: n : ℕ
this : ∑ i ∈ n.divisors, ↑(μ i) * -Real.log ↑(n / i) = ∑ i ∈ n.divisors, (↑(μ i) * Real.log ↑i - ↑(μ i) * Real.log ↑n)
⊢ ↑(1 n) * Real.log ↑n = 0
state_after: no goals
tactic: rcases eq_or_ne n 1 with (hn | hn) <;> simp [hn]
Theorem: Set.Finite.toFinset_setOf
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
h : {x | p x}.Finite
⊢ h.toFinset = Finset.filter p Finset.univ
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
h : {x | p x}.Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.filter p Finset.univ
tactic: ext
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
h : {x | p x}.Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.filter p Finset.univ
state_after: no goals
tactic: simp [Set.toFinset_setOf _]
Theorem: tendsto_uniformity_iff_dist_tendsto_zero
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
f : ι → α × α
p : Filter ι
⊢ Tendsto f p (𝓤 α) ↔ Tendsto (fun x => dist (f x).1 (f x).2) p (𝓝 0)
state_after: no goals
tactic: rw [Metric.uniformity_eq_comap_nhds_zero, tendsto_comap_iff, Function.comp_def]
Theorem: Action.leftUnitor_hom_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (λ_ X).hom.hom = (λ_ X.V).hom
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 (𝟙_ V) ⊗ 𝟙 X.V) ≫ (λ_ X.V).hom) ≫ 𝟙 X.V = (λ_ X.V).hom
tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 (𝟙_ V) ⊗ 𝟙 X.V) ≫ (λ_ X.V).hom) ≫ 𝟙 X.V = (λ_ X.V).hom
state_after: no goals
tactic: simp
Theorem: Multiset.lt_singleton
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
⊢ s < {a} ↔ s = 0
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
⊢ s = 0 → ¬s = {a}
tactic: simp only [lt_iff_le_and_ne, le_singleton, or_and_right, Ne, and_not_self, or_false,
    and_iff_left_iff_imp]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
⊢ s = 0 → ¬s = {a}
state_after: α : Type u_1
β : Type v
γ : Type u_2
t : Multiset α
a : α
⊢ ¬0 = {a}
tactic: rintro rfl
state_before: α : Type u_1
β : Type v
γ : Type u_2
t : Multiset α
a : α
⊢ ¬0 = {a}
state_after: no goals
tactic: exact (singleton_ne_zero _).symm
Theorem: Matrix.PosDef.of_toQuadraticForm'
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
M : Matrix n n ℝ
hM : M.IsSymm
hMq : M.toQuadraticMap'.PosDef
⊢ M.PosDef
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
M : Matrix n n ℝ
hM : M.IsSymm
hMq : M.toQuadraticMap'.PosDef
x : n → ℝ
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ M *ᵥ x
tactic: refine ⟨hM, fun x hx => ?_⟩
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
M : Matrix n n ℝ
hM : M.IsSymm
hMq : M.toQuadraticMap'.PosDef
x : n → ℝ
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ M *ᵥ x
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
M : Matrix n n ℝ
hM : M.IsSymm
x : n → ℝ
hx : x ≠ 0
hMq : ∀ (x : n → ℝ), x ≠ 0 → 0 < x ⬝ᵥ M *ᵥ x
⊢ 0 < star x ⬝ᵥ M *ᵥ x
tactic: simp only [toQuadraticMap', QuadraticMap.PosDef, LinearMap.BilinMap.toQuadraticMap_apply,
    toLinearMap₂'_apply'] at hMq
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
M : Matrix n n ℝ
hM : M.IsSymm
x : n → ℝ
hx : x ≠ 0
hMq : ∀ (x : n → ℝ), x ≠ 0 → 0 < x ⬝ᵥ M *ᵥ x
⊢ 0 < star x ⬝ᵥ M *ᵥ x
state_after: no goals
tactic: apply hMq x hx
Theorem: Filter.rcomap'_rcomap'
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ t ∈ rcomap' r (rcomap' s l) ↔ t ∈ rcomap' (r.comp s) l
state_after: α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ t_1, (∃ t ∈ l, s.preimage t ⊆ t_1) ∧ r.preimage t_1 ⊆ t) ↔ ∃ t_1 ∈ l, r.preimage (s.preimage t_1) ⊆ t
tactic: simp only [mem_rcomap', Rel.preimage_comp]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ t_1, (∃ t ∈ l, s.preimage t ⊆ t_1) ∧ r.preimage t_1 ⊆ t) ↔ ∃ t_1 ∈ l, r.preimage (s.preimage t_1) ⊆ t
state_after: case mp
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ t_1, (∃ t ∈ l, s.preimage t ⊆ t_1) ∧ r.preimage t_1 ⊆ t) → ∃ t_1 ∈ l, r.preimage (s.preimage t_1) ⊆ t

case mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ t_1 ∈ l, r.preimage (s.preimage t_1) ⊆ t) → ∃ t_1, (∃ t ∈ l, s.preimage t ⊆ t_1) ∧ r.preimage t_1 ⊆ t
tactic: constructor
state_before: case mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ t_1 ∈ l, r.preimage (s.preimage t_1) ⊆ t) → ∃ t_1, (∃ t ∈ l, s.preimage t ⊆ t_1) ∧ r.preimage t_1 ⊆ t
state_after: case mpr.intro.intro
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t✝ : Set α
t : Set γ
tsets : t ∈ l
ht : r.preimage (s.preimage t) ⊆ t✝
⊢ ∃ t, (∃ t_1 ∈ l, s.preimage t_1 ⊆ t) ∧ r.preimage t ⊆ t✝
tactic: rintro ⟨t, tsets, ht⟩
state_before: case mpr.intro.intro
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t✝ : Set α
t : Set γ
tsets : t ∈ l
ht : r.preimage (s.preimage t) ⊆ t✝
⊢ ∃ t, (∃ t_1 ∈ l, s.preimage t_1 ⊆ t) ∧ r.preimage t ⊆ t✝
state_after: no goals
tactic: exact ⟨s.preimage t, ⟨t, tsets, Set.Subset.rfl⟩, ht⟩
Theorem: IsGδ.sUnion
File: Mathlib/Topology/GDelta.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
hS : S.Finite
h : ∀ s ∈ S, IsGδ s
⊢ IsGδ (⋃₀ S)
state_after: no goals
tactic: induction S, hS using Set.Finite.dinduction_on with
  | H0 => simp
  | H1 _ _ ih =>
    simp only [forall_mem_insert, sUnion_insert] at *
    exact h.1.union (ih h.2)
Theorem: Subgroup.map_comap_eq
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
N : Type u_5
inst✝ : Group N
f : G →* N
H : Subgroup N
⊢ ↑(map f (comap f H)) = ↑(f.range ⊓ H)
state_after: no goals
tactic: rw [coe_map, coe_comap, Set.image_preimage_eq_inter_range, coe_inf, coe_range, Set.inter_comm]
Theorem: padicNorm.of_int
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : z = 0
⊢ padicNorm p ↑z ≤ 1
state_after: no goals
tactic: simp [hz, zero_le_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ padicNorm p ↑z ≤ 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ (if ↑z = 0 then 0 else ↑p ^ (-padicValRat p ↑z)) ≤ 1
tactic: unfold padicNorm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ (if ↑z = 0 then 0 else ↑p ^ (-padicValRat p ↑z)) ≤ 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ ↑p ^ (-padicValRat p ↑z) ≤ 1

p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ ¬↑z = 0
tactic: rw [if_neg _]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ ¬↑z = 0
state_after: no goals
tactic: exact mod_cast hz
Theorem: NNReal.nhds_zero
File: Mathlib/Topology/Instances/NNReal.lean

Proof steps:
state_before: α : Type u_1
⊢ ⨅ l, ⨅ (_ : ⊥ < l), 𝓟 (Set.Iio l) = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)
state_after: α : Type u_1
⊢ ⨅ l, ⨅ (_ : l ≠ ⊥), 𝓟 (Set.Iio l) = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)
tactic: simp only [bot_lt_iff_ne_bot]
state_before: α : Type u_1
⊢ ⨅ l, ⨅ (_ : l ≠ ⊥), 𝓟 (Set.Iio l) = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)
state_after: no goals
tactic: rfl
Theorem: Equiv.Perm.Disjoint.mul_right
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f g h : Perm α
H1 : f.Disjoint g
H2 : f.Disjoint h
⊢ f.Disjoint (g * h)
state_after: α : Type u_1
f g h : Perm α
H1 : f.Disjoint g
H2 : f.Disjoint h
⊢ (g * h).Disjoint f
tactic: rw [disjoint_comm]
state_before: α : Type u_1
f g h : Perm α
H1 : f.Disjoint g
H2 : f.Disjoint h
⊢ (g * h).Disjoint f
state_after: no goals
tactic: exact H1.symm.mul_left H2.symm
Theorem: AffineIndependent.card_le_finrank_succ
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
state_after: case inl
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : IsEmpty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1

case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
tactic: cases isEmpty_or_nonempty ι
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
state_after: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι - 1 ≤ finrank k ↥(vectorSpan k (Set.range p))
tactic: rw [← tsub_le_iff_right]
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι - 1 ≤ finrank k ↥(vectorSpan k (Set.range p))
state_after: no goals
tactic: exact (affineIndependent_iff_le_finrank_vectorSpan _ _
    (tsub_add_cancel_of_le <| Nat.one_le_iff_ne_zero.2 Fintype.card_ne_zero).symm).1 hp
Theorem: FreeMonoid.hom_eq
File: Mathlib/Algebra/FreeMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
M : Type u_4
inst✝¹ : Monoid M
N : Type u_5
inst✝ : Monoid N
f g : FreeMonoid α →* M
h : ∀ (x : α), f (of x) = g (of x)
l : FreeMonoid α
x : α
xs : FreeMonoid α
hxs : f xs = g xs
⊢ f (of x * xs) = g (of x * xs)
state_after: no goals
tactic: simp only [h, hxs, MonoidHom.map_mul]
Theorem: BoundedContinuousFunction.range_toLpHom
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ (toLpHom p μ).range = Lp.boundedContinuousFunction E p μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ Lp.boundedContinuousFunction E p μ = (toLpHom p μ).range
tactic: symm
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ Lp.boundedContinuousFunction E p μ = (toLpHom p μ).range
state_after: no goals
tactic: convert AddMonoidHom.addSubgroupOf_range_eq_of_le
      ((ContinuousMap.toAEEqFunAddHom μ).comp (toContinuousMapAddHom α E))
      (by rintro - ⟨f, rfl⟩; exact mem_Lp f : _ ≤ Lp E p μ)
Theorem: Sym2.congr_left
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ s(b, a) = s(c, a) ↔ b = c
state_after: no goals
tactic: simp (config := {contextual := true})
Theorem: CategoryTheory.MonoidalPreadditive.tensor_add
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
W X Y Z : C
f : W ⟶ X
g h : Y ⟶ Z
⊢ f ⊗ (g + h) = f ⊗ g + f ⊗ h
state_after: no goals
tactic: simp [tensorHom_def]
Theorem: Finset.inter_sdiff_assoc
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u✝ v : Finset α
a b : α
s t u : Finset α
⊢ (s ∩ t) \ u = s ∩ (t \ u)
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u✝ v : Finset α
a b : α
s t u : Finset α
x : α
⊢ x ∈ (s ∩ t) \ u ↔ x ∈ s ∩ (t \ u)
tactic: ext x
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u✝ v : Finset α
a b : α
s t u : Finset α
x : α
⊢ x ∈ (s ∩ t) \ u ↔ x ∈ s ∩ (t \ u)
state_after: no goals
tactic: simp [and_assoc]
Theorem: Set.image_inter_mulSupport_eq
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
inst✝ : One M
f : α → M
s : Set β
g : β → α
⊢ g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g))
state_after: no goals
tactic: rw [mulSupport_comp_eq_preimage f g, image_inter_preimage]