ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: KummerDedekind.multiplicity_factors_map_eq_multiplicity
File: Mathlib/NumberTheory/KummerDedekind.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
x : S
I : Ideal R
inst✝³ : IsDomain R
inst✝² : IsIntegrallyClosed R
inst✝¹ : IsDedekindDomain S
inst✝ : NoZeroSMulDivisors R S
hI : I.IsMaximal
hI' : I ≠ ⊥
hx : comap (algebraMap R S) (conductor R x) ⊔ I = ⊤
hx' : _root_.IsIntegral R x
J : Ideal S
hJ : J ∈ normalizedFactors (Ideal.map (algebraMap R S) I)
⊢ multiplicity J (Ideal.map (algebraMap R S) I) =
    multiplicity (↑((normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx') ⟨J, hJ⟩))
      (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))
state_after: no goals
tactic: rw [normalizedFactorsMapEquivNormalizedFactorsMinPolyMk, Equiv.coe_trans, Function.comp_apply,
    multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity,
    normalizedFactorsEquivOfQuotEquiv_multiplicity_eq_multiplicity]
Theorem: Real.measure_ext_Ioo_rat
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
⊢ ∀ s ∈ ⋃ a, ⋃ b, ⋃ (_ : a < b), {Ioo ↑a ↑b}, μ s = ν s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
⊢ ∀ (s : Set ℝ), (∃ i i_1, ∃ (_ : i < i_1), s = Ioo ↑i ↑i_1) → μ s = ν s
tactic: simp only [mem_iUnion, mem_singleton_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
⊢ ∀ (s : Set ℝ), (∃ i i_1, ∃ (_ : i < i_1), s = Ioo ↑i ↑i_1) → μ s = ν s
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
a b : ℚ
⊢ μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
tactic: rintro _ ⟨a, b, -, rfl⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
a b : ℚ
⊢ μ (Ioo ↑a ↑b) = ν (Ioo ↑a ↑b)
state_after: no goals
tactic: apply h
Theorem: Polynomial.div_eq_quo_add_rem_div
File: Mathlib/RingTheory/IntegralDomain.lean

Proof steps:
state_before: R : Type u_1
G : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : Group G
K : Type
inst✝² : Field K
inst✝¹ : Algebra R[X] K
inst✝ : IsFractionRing R[X] K
f g : R[X]
hg : g.Monic
⊢ ∃ q r,
    r.degree < g.degree ∧
      (algebraMap R[X] K) f / (algebraMap R[X] K) g =
        (algebraMap R[X] K) q + (algebraMap R[X] K) r / (algebraMap R[X] K) g
state_after: case refine_1
R : Type u_1
G : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : Group G
K : Type
inst✝² : Field K
inst✝¹ : Algebra R[X] K
inst✝ : IsFractionRing R[X] K
f g : R[X]
hg : g.Monic
⊢ (f %ₘ g).degree < g.degree

case refine_2
R : Type u_1
G : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : Group G
K : Type
inst✝² : Field K
inst✝¹ : Algebra R[X] K
inst✝ : IsFractionRing R[X] K
f g : R[X]
hg : g.Monic
⊢ (algebraMap R[X] K) f / (algebraMap R[X] K) g =
    (algebraMap R[X] K) (f /ₘ g) + (algebraMap R[X] K) (f %ₘ g) / (algebraMap R[X] K) g
tactic: refine ⟨f /ₘ g, f %ₘ g, ?_, ?_⟩
Theorem: ProbabilityTheory.hasDerivAt_neg_exp_mul_exp
File: Mathlib/Probability/Distributions/Exponential.lean

Proof steps:
state_before: r x : ℝ
⊢ HasDerivAt (fun a => -rexp (-(r * a))) (r * rexp (-(r * x))) x
state_after: case h.e'_6
r x : ℝ
⊢ (fun a => -rexp (-(r * a))) = fun y => -1 * rexp (-r * id y)

case h.e'_7
r x : ℝ
⊢ r * rexp (-(r * x)) = -1 * (rexp (-r * id x) * (-r * 1))
tactic: convert (((hasDerivAt_id x).const_mul (-r)).exp.const_mul (-1)) using 1
state_before: case h.e'_7
r x : ℝ
⊢ r * rexp (-(r * x)) = -1 * (rexp (-r * id x) * (-r * 1))
state_after: no goals
tactic: simp only [id_eq, neg_mul, mul_one, mul_neg, one_mul, neg_neg, mul_comm]
Theorem: ContinuousOn.angle_sign_comp
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
f : α → Angle
s : Set α
hf : ContinuousOn f s
hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π
⊢ ContinuousOn (sign ∘ f) s
state_after: α : Type u_1
inst✝ : TopologicalSpace α
f : α → Angle
s : Set α
hf : ContinuousOn f s
hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π
θ : Angle
hθ : θ ∈ f '' s
⊢ ContinuousAt sign θ
tactic: refine (ContinuousAt.continuousOn fun θ hθ => ?_).comp hf (Set.mapsTo_image f s)
state_before: α : Type u_1
inst✝ : TopologicalSpace α
f : α → Angle
s : Set α
hf : ContinuousOn f s
hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π
θ : Angle
hθ : θ ∈ f '' s
⊢ ContinuousAt sign θ
state_after: case intro.intro
α : Type u_1
inst✝ : TopologicalSpace α
f : α → Angle
s : Set α
hf : ContinuousOn f s
hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π
z : α
hz : z ∈ s
⊢ ContinuousAt sign (f z)
tactic: obtain ⟨z, hz, rfl⟩ := hθ
state_before: case intro.intro
α : Type u_1
inst✝ : TopologicalSpace α
f : α → Angle
s : Set α
hf : ContinuousOn f s
hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π
z : α
hz : z ∈ s
⊢ ContinuousAt sign (f z)
state_after: no goals
tactic: exact continuousAt_sign (hs _ hz).1 (hs _ hz).2
Theorem: MeasurableEmbedding.comap_apply
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set α
⊢ (Measure.comap f μ) s = (Measure.comap f μ) (f ⁻¹' (f '' s))
state_after: no goals
tactic: rw [hf.injective.preimage_image]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set α
⊢ (Measure.map f (Measure.comap f μ)) (f '' s) = μ (f '' s)
state_after: no goals
tactic: rw [hf.map_comap, restrict_apply' hf.measurableSet_range,
        inter_eq_self_of_subset_left (image_subset_range _ _)]
Theorem: List.pairwise_join
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
L : List (List α)
⊢ Pairwise R L.join ↔
    (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L
state_after: no goals
tactic: induction L with
  | nil => simp
  | cons l L IH =>
    simp only [join, pairwise_append, IH, mem_join, exists_imp, and_imp, forall_mem_cons,
      pairwise_cons, and_assoc, and_congr_right_iff]
    rw [and_comm, and_congr_left_iff]
    intros; exact ⟨fun h a b c d e => h c d e a b, fun h c d e a b => h a b c d e⟩
Theorem: MeasureTheory.weightedSMul_smul_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
⊢ weightedSMul (c • μ) s = c.toReal • weightedSMul μ s
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ (weightedSMul (c • μ) s) x = (c.toReal • weightedSMul μ s) x
tactic: ext1 x
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ (weightedSMul (c • μ) s) x = (c.toReal • weightedSMul μ s) x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ (weightedSMul (c • μ) s) x = (c.toReal • ⇑(weightedSMul μ s)) x
tactic: push_cast
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ (weightedSMul (c • μ) s) x = (c.toReal • ⇑(weightedSMul μ s)) x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ((c • μ) s).toReal • x = c.toReal • (μ s).toReal • x
tactic: simp_rw [Pi.smul_apply, weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ((c • μ) s).toReal • x = c.toReal • (μ s).toReal • x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ((c • ⇑μ) s).toReal • x = c.toReal • (μ s).toReal • x
tactic: push_cast
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ((c • ⇑μ) s).toReal • x = c.toReal • (μ s).toReal • x
state_after: no goals
tactic: simp_rw [Pi.smul_apply, smul_eq_mul, toReal_mul, smul_smul]
Theorem: Pretrivialization.coe_linearMapAt
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✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ ⇑(Pretrivialization.linearMapAt R e b) = fun y => if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0
state_after: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ ⇑(if hb : b ∈ e.baseSet then ↑(linearEquivAt R e b hb) else 0) = fun y =>
    if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0
tactic: rw [Pretrivialization.linearMapAt]
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ ⇑(if hb : b ∈ e.baseSet then ↑(linearEquivAt R e b hb) else 0) = fun y =>
    if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: Partrec.sum_casesOn_left
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β ⊕ γ
g : α → β →. σ
h : α → γ → σ
hf : Computable f
hg : Partrec₂ g
hh : Computable₂ h
a : α
⊢ Sum.casesOn (Sum.casesOn (f a) (fun b => Sum.inr (a, b).2) fun b => Sum.inl (a, b).2) (fun b => Part.some (h a b))
      (g a) =
    Sum.casesOn (f a) (g a) fun c => Part.some (h a c)
state_after: no goals
tactic: cases f a <;> simp
Theorem: MeasureTheory.IsStoppingTime.measurableSet_le'
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
⊢ MeasurableSet {ω | τ ω ≤ i}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
⊢ MeasurableSet ({ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j})
tactic: intro j
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
⊢ MeasurableSet ({ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
this : {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j} = {ω | τ ω ≤ min i j}
⊢ MeasurableSet ({ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j})
tactic: have : {ω : Ω | τ ω ≤ i} ∩ {ω : Ω | τ ω ≤ j} = {ω : Ω | τ ω ≤ min i j} := by
    ext1 ω; simp only [Set.mem_inter_iff, Set.mem_setOf_eq, le_min_iff]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
this : {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j} = {ω | τ ω ≤ min i j}
⊢ MeasurableSet ({ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
this : {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j} = {ω | τ ω ≤ min i j}
⊢ MeasurableSet {ω | τ ω ≤ min i j}
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i j : ι
this : {ω | τ ω ≤ i} ∩ {ω | τ ω ≤ j} = {ω | τ ω ≤ min i j}
⊢ MeasurableSet {ω | τ ω ≤ min i j}
state_after: no goals
tactic: exact f.mono (min_le_right i j) _ (hτ _)
Theorem: sup_idem
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b c d a : α
⊢ a ⊔ a = a
state_after: no goals
tactic: simp
Theorem: Nat.Primrec.pow
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: p : ℕ
⊢ unpaired
      (fun z n =>
        Nat.rec 1
          (fun y IH =>
            unpaired (fun x x_1 => x * x_1)
              (Nat.pair (unpair (unpair (Nat.pair z (Nat.pair y IH))).2).2 (unpair (Nat.pair z (Nat.pair y IH))).1))
          n)
      p =
    unpaired (fun x x_1 => x ^ x_1) p
state_after: p : ℕ
⊢ Nat.rec 1 (fun y IH => IH * (unpair p).1) (unpair p).2 = (unpair p).1 ^ (unpair p).2
tactic: simp
state_before: p : ℕ
⊢ Nat.rec 1 (fun y IH => IH * (unpair p).1) (unpair p).2 = (unpair p).1 ^ (unpair p).2
state_after: no goals
tactic: induction p.unpair.2 <;> simp [*, Nat.pow_succ]
Theorem: Filter.bind_inf_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : α → Filter β
s✝ s : Set β
⊢ (s ∈ f.bind fun x => g x ⊓ 𝓟 s✝) ↔ s ∈ f.bind g ⊓ 𝓟 s✝
state_after: no goals
tactic: simp only [mem_bind, mem_inf_principal]
Theorem: Sym2.card_image_diag
File: Mathlib/Data/Sym/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ (image Sym2.mk s.diag).card = s.card
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ Set.InjOn Sym2.mk ↑s.diag
tactic: rw [card_image_of_injOn, diag_card]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ Set.InjOn Sym2.mk ↑s.diag
state_after: case mk
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
x₂✝ : α × α
a✝ : x₂✝ ∈ ↑s.diag
h : s(x₀, x₁) = Sym2.mk x₂✝
⊢ (x₀, x₁) = x₂✝
tactic: rintro ⟨x₀, x₁⟩ hx _ _ h
state_before: case mk
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
x₂✝ : α × α
a✝ : x₂✝ ∈ ↑s.diag
h : s(x₀, x₁) = Sym2.mk x₂✝
⊢ (x₀, x₁) = x₂✝
state_after: case mk.refl
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx a✝ : (x₀, x₁) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₀, x₁)
⊢ (x₀, x₁) = (x₀, x₁)

case mk.swap
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
a✝ : (x₁, x₀) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₁, x₀)
⊢ (x₀, x₁) = (x₁, x₀)
tactic: cases Sym2.eq.1 h
Theorem: norm_inf_le_add
File: Mathlib/Analysis/Normed/Order/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
tactic: have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
state_after: no goals
tactic: simpa only [inf_idem, sub_zero] using h
Theorem: Polynomial.toContinuousMapOn_apply
File: Mathlib/Topology/ContinuousFunction/Polynomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Semiring R
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalSemiring R
p : R[X]
X : Set R
⊢ Continuous fun x => p.toContinuousMap ↑x
state_after: no goals
tactic: fun_prop
Theorem: biInf_le
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
inst✝ : CompleteLattice α
f✝ g s✝ t : ι✝ → α
a b : α
ι : Type u_9
s : Set ι
f : ι → α
i : ι
hi : i ∈ s
⊢ ⨅ i ∈ s, f i ≤ f i
state_after: no goals
tactic: simpa only [iInf_subtype'] using iInf_le (ι := s) (f := f ∘ (↑)) ⟨i, hi⟩
Theorem: Ideal.norm_dvd_iff
File: Mathlib/RingTheory/Ideal/Norm.lean

Proof steps:
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ (Algebra.norm ℤ) x ∣ y ↔ x ∣ ↑y
state_after: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ Nat.Prime (absNorm (span {x}))
tactic: rw [← Ideal.mem_span_singleton (y := x), ← eq_intCast (algebraMap ℤ S), ← Ideal.mem_comap,
    ← Ideal.span_singleton_absNorm, Ideal.mem_span_singleton, Ideal.absNorm_span_singleton,
    Int.natAbs_dvd]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ Nat.Prime (absNorm (span {x}))
state_after: no goals
tactic: rwa [Ideal.absNorm_span_singleton, ← Int.prime_iff_natAbs_prime]
Theorem: AddLECancellable.tsub_mul
File: Mathlib/Algebra/Order/Ring/Canonical.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝³ : CanonicallyOrderedCommSemiring α
a b c : α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
h : AddLECancellable (b * c)
⊢ (a - b) * c = a * c - b * c
state_after: α : Type u
β : Type u_1
inst✝³ : CanonicallyOrderedCommSemiring α
a b c : α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
h : AddLECancellable (c * b)
⊢ c * (a - b) = c * a - c * b
tactic: simp only [mul_comm _ c] at *
state_before: α : Type u
β : Type u_1
inst✝³ : CanonicallyOrderedCommSemiring α
a b c : α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
h : AddLECancellable (c * b)
⊢ c * (a - b) = c * a - c * b
state_after: no goals
tactic: exact h.mul_tsub
Theorem: List.length_join
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
⊢ L.join.length = (map length L).sum
state_after: no goals
tactic: induction L <;> [rfl; simp only [*, join, map, sum_cons, length_append]]
Theorem: IsTrichotomous.swap
File: Mathlib/Order/RelClasses.lean

Proof steps:
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s : β → β → Prop
r : α → α → Prop
inst✝ : IsTrichotomous α r
a b : α
⊢ Function.swap r a b ∨ a = b ∨ Function.swap r b a
state_after: no goals
tactic: simpa [Function.swap, or_comm, or_left_comm] using trichotomous_of r a b
Theorem: List.continuousAt_length
File: Mathlib/Topology/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α), ContinuousAt length l
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α), Tendsto length (𝓝 l) (pure l.length)
tactic: simp only [ContinuousAt, nhds_discrete]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α), Tendsto length (𝓝 l) (pure l.length)
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ Tendsto length (pure []) (pure [].length)

case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α) (a : α),
    Tendsto length (𝓝 l) (pure l.length) → Tendsto (fun p => (p.1 :: p.2).length) (𝓝 a ×ˢ 𝓝 l) (pure (a :: l).length)
tactic: refine tendsto_nhds ?_ ?_
Theorem: div_two_sub_self
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
a : α
⊢ a / 2 - a = -(a / 2)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
a : α
⊢ a / 2 - (a / 2 + a / 2) = -(a / 2)
tactic: suffices a / 2 - (a / 2 + a / 2) = -(a / 2) by rwa [add_halves] at this
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
a : α
⊢ a / 2 - (a / 2 + a / 2) = -(a / 2)
state_after: no goals
tactic: rw [sub_add_eq_sub_sub, sub_self, zero_sub]
Theorem: MeasureTheory.IsProjectiveLimit.measure_univ_unique
File: Mathlib/MeasureTheory/Constructions/Projective.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
⊢ μ univ = ν univ
state_after: no goals
tactic: rw [hμ.measure_univ_eq (∅ : Finset ι), hν.measure_univ_eq (∅ : Finset ι)]
Theorem: NormedSpace.exp_zsmul
File: Mathlib/Analysis/NormedSpace/Exponential.lean

Proof steps:
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝³ : RCLike 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
z : ℤ
x : 𝔸
⊢ exp 𝕂 (z • x) = exp 𝕂 x ^ z
state_after: case intro.inl
𝕂 : Type u_1
𝔸 : Type u_2
inst✝³ : RCLike 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
n : ℕ
⊢ exp 𝕂 (↑n • x) = exp 𝕂 x ^ ↑n

case intro.inr
𝕂 : Type u_1
𝔸 : Type u_2
inst✝³ : RCLike 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
n : ℕ
⊢ exp 𝕂 (-↑n • x) = exp 𝕂 x ^ (-↑n)
tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
Theorem: Polynomial.natDegree_removeFactor
File: Mathlib/FieldTheory/SplittingField/Construction.lean

Proof steps:
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
⊢ f.removeFactor.natDegree = f.natDegree - 1
state_after: no goals
tactic: rw [removeFactor, natDegree_divByMonic (map (AdjoinRoot.of f.factor) f) (monic_X_sub_C _),
    natDegree_map, natDegree_X_sub_C]