ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Metric.cthickening_singleton
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
⊢ cthickening δ {x} = closedBall x δ
state_after: case h
ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
y : α
⊢ y ∈ cthickening δ {x} ↔ y ∈ closedBall x δ
tactic: ext y
state_before: case h
ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
y : α
⊢ y ∈ cthickening δ {x} ↔ y ∈ closedBall x δ
state_after: no goals
tactic: simp [cthickening, edist_dist, ENNReal.ofReal_le_ofReal_iff hδ]
Theorem: Finset.powersetCard_map
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝¹ t✝¹ : Finset α
n✝ : ?m.33453
s✝ t✝ : Finset α
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
⊢ t ∈ powersetCard n (map f s) ↔ t ∈ map (mapEmbedding f).toEmbedding (powersetCard n s)
state_after: α : Type u_1
s✝¹ t✝¹ : Finset α
n✝ : ?m.33453
s✝ t✝ : Finset α
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
⊢ t ⊆ map f s ∧ t.card = n ↔ ∃ a, (a ⊆ s ∧ a.card = n) ∧ (mapEmbedding f).toEmbedding a = t
tactic: simp only [card_map, mem_powersetCard, le_eq_subset, gt_iff_lt, mem_map, mapEmbedding_apply]
state_before: α : Type u_1
s✝¹ t✝¹ : Finset α
n✝ : ?m.33453
s✝ t✝ : Finset α
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
⊢ t ⊆ map f s ∧ t.card = n ↔ ∃ a, (a ⊆ s ∧ a.card = n) ∧ (mapEmbedding f).toEmbedding a = t
state_after: case mp
α : Type u_1
s✝¹ t✝¹ : Finset α
n✝ : ?m.33453
s✝ t✝ : Finset α
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
⊢ t ⊆ map f s ∧ t.card = n → ∃ a, (a ⊆ s ∧ a.card = n) ∧ (mapEmbedding f).toEmbedding a = t

case mpr
α : Type u_1
s✝¹ t✝¹ : Finset α
n✝ : ?m.33453
s✝ t✝ : Finset α
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
⊢ (∃ a, (a ⊆ s ∧ a.card = n) ∧ (mapEmbedding f).toEmbedding a = t) → t ⊆ map f s ∧ t.card = n
tactic: constructor
Theorem: toZ_iterate_succ_le
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ toZ i0 (succ^[n] i0) ≤ ↑n
state_after: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ ↑(Nat.find ⋯) ≤ ↑n
tactic: rw [toZ_of_ge (le_succ_iterate _ _)]
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ ↑(Nat.find ⋯) ≤ ↑n
state_after: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ Nat.find ⋯ ≤ n
tactic: norm_cast
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ Nat.find ⋯ ≤ n
state_after: no goals
tactic: exact Nat.find_min' _ rfl
Theorem: MeasureTheory.eLpNorm'_measure_zero_of_exponent_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.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✝ : MeasurableSpace α
f : α → F
⊢ eLpNorm' f 0 0 = 1
state_after: no goals
tactic: simp [eLpNorm']
Theorem: CategoryTheory.ShortComplex.SnakeInput.δ_eq
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
⊢ x₃ ≫ S.δ = x₁ ≫ S.v₂₃.τ₁
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : pullback.lift x₂ x₃ h₂ ≫ pullback.snd S.L₁.g S.v₀₁.τ₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ x₃ ≫ S.δ = x₁ ≫ S.v₂₃.τ₁
tactic: have H := (pullback.lift x₂ x₃ h₂) ≫= S.snd_δ
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : pullback.lift x₂ x₃ h₂ ≫ pullback.snd S.L₁.g S.v₀₁.τ₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ x₃ ≫ S.δ = x₁ ≫ S.v₂₃.τ₁
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ x₃ ≫ S.δ = x₁ ≫ S.v₂₃.τ₁
tactic: rw [pullback.lift_snd_assoc] at H
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ x₃ ≫ S.δ = x₁ ≫ S.v₂₃.τ₁
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ (pullback.lift x₂ x₃ h₂ ≫ S.φ₁) ≫ S.v₂₃.τ₁ = x₁ ≫ S.v₂₃.τ₁
tactic: rw [H, ← assoc]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ (pullback.lift x₂ x₃ h₂ ≫ S.φ₁) ≫ S.v₂₃.τ₁ = x₁ ≫ S.v₂₃.τ₁
state_after: case e_a
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ pullback.lift x₂ x₃ h₂ ≫ S.φ₁ = x₁
tactic: congr 1
state_before: case e_a
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
x₃ : A ⟶ S.L₀.X₃
x₂ : A ⟶ S.L₁.X₂
x₁ : A ⟶ S.L₂.X₁
h₂ : x₂ ≫ S.L₁.g = x₃ ≫ S.v₀₁.τ₃
h₁ : x₁ ≫ S.L₂.f = x₂ ≫ S.v₁₂.τ₂
H : x₃ ≫ S.δ = pullback.lift x₂ x₃ h₂ ≫ S.φ₁ ≫ S.v₂₃.τ₁
⊢ pullback.lift x₂ x₃ h₂ ≫ S.φ₁ = x₁
state_after: no goals
tactic: simp only [← cancel_mono S.L₂.f, assoc, φ₁_L₂_f, lift_φ₂, h₁]
Theorem: MeasureTheory.AEStronglyMeasurable.integral_condDistrib_map
File: Mathlib/Probability/Kernel/CondDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂(condDistrib Y X μ) x) (Measure.map X μ)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x)
    (Measure.map (fun a => (X a, Y a)) μ).fst
tactic: rw [← Measure.fst_map_prod_mk₀ hY, condDistrib]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x)
    (Measure.map (fun a => (X a, Y a)) μ).fst
state_after: no goals
tactic: exact hf.integral_condKernel
Theorem: Set.Finite.absorbs_sUnion
File: Mathlib/Topology/Bornology/Absorbs.lean

Proof steps:
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Bornology M
inst✝ : SMul M α
s s₁ s₂ t t₁ t₂ : Set α
S T✝ T : Set (Set α)
hT : T.Finite
⊢ Absorbs M s (⋃₀ T) ↔ ∀ t ∈ T, Absorbs M s t
state_after: no goals
tactic: simp [Absorbs, hT]
Theorem: Behrend.le_N
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
⊢ (2 * dValue N - 1) ^ nValue N ≤ N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * dValue N - 1) ^ nValue N ≤ N
tactic: have : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N :=
    Nat.pow_le_pow_left (Nat.sub_le _ _) _
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * dValue N - 1) ^ nValue N ≤ N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * dValue N) ^ nValue N ≤ N
tactic: apply this.trans
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * dValue N) ^ nValue N ≤ N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * ↑(dValue N)) ^ nValue N ≤ ↑N
tactic: suffices ((2 * dValue N) ^ nValue N : ℝ) ≤ N from mod_cast this
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ (2 * ↑(dValue N)) ^ nValue N ≤ ↑N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ 2 * ↑(dValue N) ≤ ↑N ^ (↑(nValue N))⁻¹
tactic: suffices i : (2 * dValue N : ℝ) ≤ (N : ℝ) ^ (nValue N : ℝ)⁻¹ by
    rw [← rpow_natCast]
    apply (rpow_le_rpow (mul_nonneg zero_le_two (cast_nonneg _)) i (cast_nonneg _)).trans
    rw [← rpow_mul (cast_nonneg _), inv_mul_cancel, rpow_one]
    rw [cast_ne_zero]
    apply (nValue_pos hN).ne'
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ 2 * ↑(dValue N) ≤ ↑N ^ (↑(nValue N))⁻¹
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ ↑(dValue N) ≤ ↑N ^ (↑(nValue N))⁻¹ / 2

α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ 0 < 2
tactic: rw [← le_div_iff']
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
this : (2 * dValue N - 1) ^ nValue N ≤ (2 * dValue N) ^ nValue N
⊢ 0 < 2
state_after: no goals
tactic: apply zero_lt_two
Theorem: Cardinal.toPartENat_eq_natCast_iff
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
c : Cardinal.{u_3}
n : ℕ
⊢ toPartENat c = ↑n ↔ c = ↑n
state_after: no goals
tactic: rw [eq_comm, Cardinal.natCast_eq_toPartENat_iff, eq_comm]
Theorem: Finpartition.exists_enumeration
File: Mathlib/Order/Partition/Finpartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∃ f, ∀ (a b : { x // x ∈ s }), P.part ↑a = P.part ↑b ↔ (f a).fst = (f b).fst
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∀ (a b : { x // x ∈ s }),
    P.part ↑a = P.part ↑b ↔
      ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) a).fst =
        ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) b).fst
tactic: use P.equivSigmaParts.trans ((Equiv.refl _).sigmaCongr (fun t ↦ t.1.equivFin))
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∀ (a b : { x // x ∈ s }),
    P.part ↑a = P.part ↑b ↔
      ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) a).fst =
        ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) b).fst
state_after: no goals
tactic: simp [equivSigmaParts, Equiv.sigmaCongr, Equiv.sigmaCongrLeft]
Theorem: Set.univ_pi_eq_empty_iff
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ univ.pi t = ∅ ↔ ∃ i, t i = ∅
state_after: no goals
tactic: simp [← not_nonempty_iff_eq_empty, univ_pi_nonempty_iff]
Theorem: Real.range_sin_infinite
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ (range sin).Infinite
state_after: ⊢ (Icc (-1) 1).Infinite
tactic: rw [Real.range_sin]
state_before: ⊢ (Icc (-1) 1).Infinite
state_after: no goals
tactic: exact Icc_infinite (by norm_num)
Theorem: AddGroupFilterBasis.nhds_eq
File: Mathlib/Topology/Algebra/FilterBasis.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ 𝓝 x₀ = B.N x₀
state_after: case hpure
G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ ∀ (a : G), ∀ i ∈ toFilterBasis, a ∈ (fun y => a * y) '' id i

case hopen
G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ ∀ (a : G),
    ∀ i ∈ toFilterBasis,
      ∀ᶠ (x : G) in map (fun y => a * y) toFilterBasis.filter,
        (fun y => a * y) '' id i ∈ map (fun y => x * y) toFilterBasis.filter
tactic: apply TopologicalSpace.nhds_mkOfNhds_of_hasBasis (fun x ↦ (FilterBasis.hasBasis _).map _)
Theorem: SubMulAction.subset_coe_pow
File: Mathlib/GroupTheory/GroupAction/SubMulAction/Pointwise.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
⊢ ↑p ^ 0 ⊆ ↑(p ^ 0)
state_after: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
⊢ 1 ⊆ ↑1
tactic: rw [pow_zero, pow_zero]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
⊢ 1 ⊆ ↑1
state_after: no goals
tactic: exact subset_coe_one
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
n : ℕ
⊢ ↑p ^ (n + 1) ⊆ ↑(p ^ (n + 1))
state_after: no goals
tactic: rw [← Nat.succ_eq_add_one, coe_pow _ n.succ_ne_zero]
Theorem: Complex.tanh_mul_I
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ tanh (x * I) = tan x * I
state_after: no goals
tactic: rw [tanh_eq_sinh_div_cosh, cosh_mul_I, sinh_mul_I, mul_div_right_comm, tan]
Theorem: Subsemigroup.mem_sSup_of_directed_on
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
state_after: no goals
tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk,
    exists_prop]
Theorem: cfc_star_id
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
⊢ cfc (fun x => star x) a = star a
state_after: no goals
tactic: rw [cfc_star .., cfc_id' ..]
Theorem: Real.lt_sq_of_sqrt_lt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
h : √x < y
⊢ x < y ^ 2
state_after: x✝ y✝ x y : ℝ
h : √x < y
hy : 0 < y
⊢ x < y ^ 2
tactic: have hy := x.sqrt_nonneg.trans_lt h
state_before: x✝ y✝ x y : ℝ
h : √x < y
hy : 0 < y
⊢ x < y ^ 2
state_after: no goals
tactic: rwa [← sqrt_lt_sqrt_iff_of_pos (sq_pos_of_pos hy), sqrt_sq hy.le]
Theorem: Choose.choose_modEq_choose_mul_prod_range_choose
File: Mathlib/Data/Nat/Choose/Lucas.lean

Proof steps:
state_before: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℕ
⊢ ↑(n.choose k) ≡
    ↑((n / p ^ Nat.zero).choose (k / p ^ Nat.zero)) *
      ↑(∏ i ∈ range Nat.zero, (n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD
    ↑p]
state_after: no goals
tactic: simp
state_before: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a).choose (k / p ^ a)) * ↑(∏ i ∈ range a, (n / p ^ i % p).choose (k / p ^ i % p)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑(∏ i ∈ range a.succ, (n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD
    ↑p]
state_after: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a).choose (k / p ^ a)) * ↑(∏ i ∈ range a, (n / p ^ i % p).choose (k / p ^ i % p)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) *
      ↑(∏ x ∈ range a, (n / p ^ x % p).choose (k / p ^ x % p)) [ZMOD
    ↑p]
tactic: rw [prod_range_succ, cast_mul, ← mul_assoc, mul_right_comm]
state_before: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a).choose (k / p ^ a)) * ↑(∏ i ∈ range a, (n / p ^ i % p).choose (k / p ^ i % p)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) *
      ↑(∏ x ∈ range a, (n / p ^ x % p).choose (k / p ^ x % p)) [ZMOD
    ↑p]
state_after: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a).choose (k / p ^ a)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]
tactic: gcongr
state_before: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a).choose (k / p ^ a)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]
state_after: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / p ^ a / p).choose (k / p ^ a / p)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]
tactic: apply choose_modEq_choose_mod_mul_choose_div.trans
state_before: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / p ^ a / p).choose (k / p ^ a / p)) ≡
    ↑((n / p ^ a.succ).choose (k / p ^ a.succ)) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]
state_after: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / (p * p ^ a)).choose (k / (p * p ^ a))) ≡
    ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / (p * p ^ a)).choose (k / (p * p ^ a))) [ZMOD ↑p]
tactic: simp_rw [pow_succ, Nat.div_div_eq_div_mul, mul_comm]
state_before: case h
n k p : ℕ
inst✝ : Fact (Nat.Prime p)
a✝ a : ℕ
⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / (p * p ^ a)).choose (k / (p * p ^ a))) ≡
    ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / (p * p ^ a)).choose (k / (p * p ^ a))) [ZMOD ↑p]
state_after: no goals
tactic: rfl
Theorem: RCLike.realRingEquiv_symm_apply
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = x
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = ↑(re x) + ↑(im x) * I
tactic: nth_rw 2 [← re_add_im x]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = ↑(re x) + ↑(im x) * I
state_after: no goals
tactic: simp [h]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
⊢ ∀ (x y : K),
    { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
      { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun x *
        { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: simp [im_eq_zero h]
Theorem: ContextFreeRule.rewrites_iff
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
⊢ (∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q) → r.Rewrites u v
state_after: case intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
p q : List (Symbol T N)
⊢ r.Rewrites (p ++ [Symbol.nonterminal r.input] ++ q) (p ++ r.output ++ q)
tactic: rintro ⟨p, q, rfl, rfl⟩
state_before: case intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
p q : List (Symbol T N)
⊢ r.Rewrites (p ++ [Symbol.nonterminal r.input] ++ q) (p ++ r.output ++ q)
state_after: no goals
tactic: apply rewrites_of_exists_parts
Theorem: _private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.HD_bound_aux2
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f✝ : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
f : GromovHausdorff.Cb X Y
C : ℝ
⊢ BddAbove (range fun y => ⨅ x, f (inl x, inr y) + C)
state_after: case intro
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f✝ : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
f : GromovHausdorff.Cb X Y
C Cf : ℝ
hCf : Cf ∈ upperBounds (range ⇑f)
⊢ BddAbove (range fun y => ⨅ x, f (inl x, inr y) + C)
tactic: obtain ⟨Cf, hCf⟩ := f.isBounded_range.bddAbove
state_before: case intro
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f✝ : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
f : GromovHausdorff.Cb X Y
C Cf : ℝ
hCf : Cf ∈ upperBounds (range ⇑f)
⊢ BddAbove (range fun y => ⨅ x, f (inl x, inr y) + C)
state_after: case intro
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f✝ : GromovHausdorff.ProdSpaceFun X Y
x y✝ z t : X ⊕ Y
f : GromovHausdorff.Cb X Y
C Cf : ℝ
hCf : Cf ∈ upperBounds (range ⇑f)
y : Y
⊢ ⨅ x, f (inl x, inr y) + C ≤ Cf + C
tactic: refine ⟨Cf + C, forall_mem_range.2 fun y => ?_⟩
state_before: case intro
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f✝ : GromovHausdorff.ProdSpaceFun X Y
x y✝ z t : X ⊕ Y
f : GromovHausdorff.Cb X Y
C Cf : ℝ
hCf : Cf ∈ upperBounds (range ⇑f)
y : Y
⊢ ⨅ x, f (inl x, inr y) + C ≤ Cf + C
state_after: no goals
tactic: calc
    ⨅ x, f (inl x, inr y) + C ≤ f (inl default, inr y) + C := ciInf_le (HD_below_aux2 C) default
    _ ≤ Cf + C := add_le_add ((fun x => hCf (mem_range_self x)) _) le_rfl