ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rel.image_comp
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
⊢ (r • s).image t = s.image (r.image t)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ z ∈ (r • s).image t ↔ z ∈ s.image (r.image t)
tactic: ext z
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ z ∈ (r • s).image t ↔ z ∈ s.image (r.image t)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ (∃ x ∈ t, (r • s) x z) ↔ ∃ x, (∃ x_1 ∈ t, r x_1 x) ∧ s x z
tactic: simp only [mem_image]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ (∃ x ∈ t, (r • s) x z) ↔ ∃ x, (∃ x_1 ∈ t, r x_1 x) ∧ s x z
state_after: case h.mp
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ (∃ x ∈ t, (r • s) x z) → ∃ x, (∃ x_1 ∈ t, r x_1 x) ∧ s x z

case h.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set α
z : γ
⊢ (∃ x, (∃ x_1 ∈ t, r x_1 x) ∧ s x z) → ∃ x ∈ t, (r • s) x z
tactic: constructor
Theorem: Prod.covBy_iff
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x ⋖ y ↔ x.1 ⋖ y.1 ∧ x.2 = y.2 ∨ x.2 ⋖ y.2 ∧ x.1 = y.1
state_after: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⋖ y ↔ (fst✝, snd✝).1 ⋖ y.1 ∧ (fst✝, snd✝).2 = y.2 ∨ (fst✝, snd✝).2 ⋖ y.2 ∧ (fst✝, snd✝).1 = y.1
tactic: cases x
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⋖ y ↔ (fst✝, snd✝).1 ⋖ y.1 ∧ (fst✝, snd✝).2 = y.2 ∨ (fst✝, snd✝).2 ⋖ y.2 ∧ (fst✝, snd✝).1 = y.1
state_after: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⋖ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).1 ⋖ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 = (fst✝, snd✝).2 ∨
      (fst✝¹, snd✝¹).2 ⋖ (fst✝, snd✝).2 ∧ (fst✝¹, snd✝¹).1 = (fst✝, snd✝).1
tactic: cases y
state_before: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⋖ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).1 ⋖ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 = (fst✝, snd✝).2 ∨
      (fst✝¹, snd✝¹).2 ⋖ (fst✝, snd✝).2 ∧ (fst✝¹, snd✝¹).1 = (fst✝, snd✝).1
state_after: no goals
tactic: exact mk_covBy_mk_iff
Theorem: tsum_of_norm_bounded
File: Mathlib/Analysis/Normed/Group/InfiniteSum.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
g : ι → ℝ
a : ℝ
hg : HasSum g a
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ ‖∑' (i : ι), f i‖ ≤ a
state_after: case pos
ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
g : ι → ℝ
a : ℝ
hg : HasSum g a
h : ∀ (i : ι), ‖f i‖ ≤ g i
hf : Summable f
⊢ ‖∑' (i : ι), f i‖ ≤ a

case neg
ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
g : ι → ℝ
a : ℝ
hg : HasSum g a
h : ∀ (i : ι), ‖f i‖ ≤ g i
hf : ¬Summable f
⊢ ‖∑' (i : ι), f i‖ ≤ a
tactic: by_cases hf : Summable f
Theorem: IsPiSystem.singleton
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
S : Set α
⊢ IsPiSystem {S}
state_after: α : Type u_1
S s : Set α
h_s : s ∈ {S}
t : Set α
h_t : t ∈ {S}
a✝ : (s ∩ t).Nonempty
⊢ s ∩ t ∈ {S}
tactic: intro s h_s t h_t _
state_before: α : Type u_1
S s : Set α
h_s : s ∈ {S}
t : Set α
h_t : t ∈ {S}
a✝ : (s ∩ t).Nonempty
⊢ s ∩ t ∈ {S}
state_after: no goals
tactic: rw [Set.mem_singleton_iff.1 h_s, Set.mem_singleton_iff.1 h_t, Set.inter_self,
    Set.mem_singleton_iff]
Theorem: eq_open_union_countable
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
⊢ ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i
state_after: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
⊢ ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i
tactic: have : IsLindelof (⋃ i, U i) := HereditarilyLindelof_LindelofSets (⋃ i, U i)
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
⊢ ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i
state_after: case intro.intro
X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t✝ : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
t : Set ι
htc : t.Countable
htu : ⋃ i, U i ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i
tactic: rcases isLindelof_iff_countable_subcover.mp this U h (Eq.subset rfl) with ⟨t, ⟨htc, htu⟩⟩
state_before: case intro.intro
X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t✝ : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
t : Set ι
htc : t.Countable
htu : ⋃ i, U i ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i
state_after: case right
X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t✝ : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
t : Set ι
htc : t.Countable
htu : ⋃ i, U i ⊆ ⋃ i ∈ t, U i
⊢ ⋃ i ∈ t, U i = ⋃ i, U i
tactic: use t, htc
state_before: case right
X : Type u
Y : Type v
ι✝ : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t✝ : Set X
inst✝ : HereditarilyLindelofSpace X
ι : Type u
U : ι → Set X
h : ∀ (i : ι), IsOpen (U i)
this : IsLindelof (⋃ i, U i)
t : Set ι
htc : t.Countable
htu : ⋃ i, U i ⊆ ⋃ i ∈ t, U i
⊢ ⋃ i ∈ t, U i = ⋃ i, U i
state_after: no goals
tactic: apply eq_of_subset_of_subset (iUnion₂_subset_iUnion (fun i ↦ i ∈ t) fun i ↦ U i) htu
Theorem: PartialEquiv.pi_trans
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
ι : Type u_5
αi : ι → Type u_6
βi : ι → Type u_7
γi : ι → Type u_8
ei : (i : ι) → PartialEquiv (αi i) (βi i)
ei' : (i : ι) → PartialEquiv (βi i) (γi i)
⊢ (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = PartialEquiv.pi fun i => (ei i).trans (ei' i)
state_after: no goals
tactic: ext <;> simp [forall_and]
Theorem: Set.toFinset_diff
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s \ t)
⊢ (s \ t).toFinset = s.toFinset \ t.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s \ t)
a✝ : α
⊢ a✝ ∈ (s \ t).toFinset ↔ a✝ ∈ s.toFinset \ t.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s \ t)
a✝ : α
⊢ a✝ ∈ (s \ t).toFinset ↔ a✝ ∈ s.toFinset \ t.toFinset
state_after: no goals
tactic: simp
Theorem: ZMod.prime_ne_zero
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
hpq : p ≠ q
⊢ ↑q ≠ 0
state_after: no goals
tactic: rwa [← Nat.cast_zero, Ne, eq_iff_modEq_nat, Nat.modEq_zero_iff_dvd, ←
    hp.1.coprime_iff_not_dvd, Nat.coprime_primes hp.1 hq.1]
Theorem: Submonoid.mem_sup
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
N : Type u_4
inst✝ : CommMonoid N
s t : Submonoid N
x : N
⊢ x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x
state_after: no goals
tactic: simp only [sup_eq_range, mem_mrange, coprod_apply, coe_subtype, Prod.exists,
    Subtype.exists, exists_prop]
Theorem: SemidirectProduct.inl_aut
File: Mathlib/GroupTheory/SemidirectProduct.lean

Proof steps:
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
g : G
n : N
⊢ inl ((φ g) n) = inr g * inl n * inr g⁻¹
state_after: no goals
tactic: ext <;> simp
Theorem: Ordinal.le_nadd_self
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
⊢ a ≤ b ♯ a
state_after: no goals
tactic: simpa using nadd_le_nadd_right (Ordinal.zero_le b) a
Theorem: ZMod.not_isUnit_of_mem_primeFactors
File: Mathlib/Data/ZMod/Units.lean

Proof steps:
state_before: n✝ m n p : ℕ
h : p ∈ n.primeFactors
⊢ ¬IsUnit ↑p
state_after: n✝ m n p : ℕ
h : p ∈ n.primeFactors
⊢ ¬p.Coprime n
tactic: rw [isUnit_iff_coprime]
state_before: n✝ m n p : ℕ
h : p ∈ n.primeFactors
⊢ ¬p.Coprime n
state_after: no goals
tactic: exact (Prime.dvd_iff_not_coprime <| prime_of_mem_primeFactors h).mp <| dvd_of_mem_primeFactors h
Theorem: Matrix.PosSemidef.zpow
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 R
hM : M.PosSemidef
z : ℤ
⊢ (M ^ z).PosSemidef
state_after: case intro.inl
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✝ R
hM : M.PosSemidef
n : ℕ
⊢ (M ^ ↑n).PosSemidef

case intro.inr
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✝ R
hM : M.PosSemidef
n : ℕ
⊢ (M ^ (-↑n)).PosSemidef
tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
Theorem: Fin.nndist_insertNth_insertNth
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α✝
π : β → Type u_3
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
n : ℕ
α : Fin (n + 1) → Type u_4
inst✝ : (i : Fin (n + 1)) → PseudoMetricSpace (α i)
i : Fin (n + 1)
x y : α i
f g : (j : Fin n) → α (i.succAbove j)
c : ℝ≥0
⊢ nndist (i.insertNth x f) (i.insertNth y g) ≤ c ↔ max (nndist x y) (nndist f g) ≤ c
state_after: no goals
tactic: simp [nndist_pi_le_iff, i.forall_iff_succAbove]
Theorem: AlgebraicGeometry.Scheme.OpenCover.iSup_opensRange
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

Proof steps:
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ↑(⨆ i, Hom.opensRange (𝒰.map i)) = ↑⊤
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ⋃ i, ↑(Hom.opensRange (𝒰.map i)) = ↑⊤
tactic: rw [Opens.coe_iSup]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
⊢ ⋃ i, ↑(Hom.opensRange (𝒰.map i)) = ↑⊤
state_after: no goals
tactic: exact 𝒰.iUnion_range
Theorem: Filter.inv_cobounded₀
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NormedDivisionRing α
a : α
⊢ (cobounded α)⁻¹ = 𝓝[≠] 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NormedDivisionRing α
a : α
⊢ comap Inv.inv (comap norm atTop) = comap norm (comap Inv.inv atTop)
tactic: rw [← comap_norm_atTop, ← Filter.comap_inv, ← comap_norm_nhdsWithin_Ioi_zero,
    ← inv_atTop₀, ← Filter.comap_inv]
Theorem: pow_zmod_val_inv_pow
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
n : ℕ
hn : (Nat.card α).Coprime n
a : α
⊢ (a ^ (↑n)⁻¹.val) ^ n = a
state_after: no goals
tactic: rw [← pow_mul', ← pow_mod_natCard, ← ZMod.val_natCast, Nat.cast_mul, ZMod.mul_val_inv hn.symm,
    ZMod.val_one_eq_one_mod, pow_mod_natCard, pow_one]
Theorem: Ideal.pointwise_smul_subset_iff
File: Mathlib/RingTheory/Ideal/Pointwise.lean

Proof steps:
state_before: M : Type u_1
R : Type u_2
inst✝² : Group M
inst✝¹ : CommRing R
inst✝ : MulSemiringAction M R
a : M
S T : Ideal R
⊢ a • S ≤ T ↔ S ≤ a⁻¹ • T
state_after: no goals
tactic: rw [← pointwise_smul_le_pointwise_smul_iff (a := a⁻¹), inv_smul_smul]
Theorem: dist_inv_inv₀
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NormedDivisionRing α
a z w : α
hz : z ≠ 0
hw : w ≠ 0
⊢ dist z⁻¹ w⁻¹ = dist z w / (‖z‖ * ‖w‖)
state_after: no goals
tactic: rw [dist_eq_norm, inv_sub_inv' hz hw, norm_mul, norm_mul, norm_inv, norm_inv, mul_comm ‖z‖⁻¹,
    mul_assoc, dist_eq_norm', div_eq_mul_inv, mul_inv]
Theorem: Finsupp.smul_single_one
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Semiring R
a : α
b : R
⊢ b • single a 1 = single a b
state_after: no goals
tactic: rw [smul_single, smul_eq_mul, mul_one]
Theorem: Sum.LiftRel.lex
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
s : β → β → Prop
a b : α ⊕ β
h : LiftRel r s a b
⊢ Lex r s a b
state_after: case inl
α : Type u_1
β : Type u_2
r : α → α → Prop
s : β → β → Prop
a✝¹ c✝ : α
a✝ : r a✝¹ c✝
⊢ Lex r s (inl a✝¹) (inl c✝)

case inr
α : Type u_1
β : Type u_2
r : α → α → Prop
s : β → β → Prop
b✝ d✝ : β
a✝ : s b✝ d✝
⊢ Lex r s (inr b✝) (inr d✝)
tactic: cases h
Theorem: clusterPt_lift'_closure_iff
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
F : Filter X
⊢ ClusterPt x (F.lift' closure) ↔ ClusterPt x F
state_after: no goals
tactic: simp [clusterPt_iff_lift'_closure, lift'_lift'_assoc (monotone_closure X) (monotone_closure X)]
Theorem: NumberField.ComplexEmbedding.isReal_comp_iff
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k ≃+* K
φ : K →+* ℂ
H : IsReal (φ.comp ↑f)
⊢ IsReal φ
state_after: case h.e'_3
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k ≃+* K
φ : K →+* ℂ
H : IsReal (φ.comp ↑f)
⊢ φ = (φ.comp ↑f).comp f.symm.toRingHom
tactic: convert H.comp f.symm.toRingHom
state_before: case h.e'_3
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k ≃+* K
φ : K →+* ℂ
H : IsReal (φ.comp ↑f)
⊢ φ = (φ.comp ↑f).comp f.symm.toRingHom
state_after: case h.e'_3.a
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k ≃+* K
φ : K →+* ℂ
H : IsReal (φ.comp ↑f)
x✝ : K
⊢ φ x✝ = ((φ.comp ↑f).comp f.symm.toRingHom) x✝
tactic: ext1
state_before: case h.e'_3.a
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k ≃+* K
φ : K →+* ℂ
H : IsReal (φ.comp ↑f)
x✝ : K
⊢ φ x✝ = ((φ.comp ↑f).comp f.symm.toRingHom) x✝
state_after: no goals
tactic: simp
Theorem: NumberField.Units.fundSystem_mk
File: Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
i : Fin (rank K)
⊢ Additive.ofMul ⟦fundSystem K i⟧ = (basisModTorsion K) i
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
i : Fin (rank K)
⊢ Additive.toMul ((basisModTorsion K) i) = Additive.ofMul.symm ((basisModTorsion K) i)
tactic: rw [fundSystem, Equiv.apply_eq_iff_eq_symm_apply, @Quotient.mk_eq_iff_out,
    Quotient.out', Quotient.out_equiv_out]
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
i : Fin (rank K)
⊢ Additive.toMul ((basisModTorsion K) i) = Additive.ofMul.symm ((basisModTorsion K) i)
state_after: no goals
tactic: rfl
Theorem: padicNorm.nonarchimedean
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
state_after: case inr
p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
this : ∀ {q r : ℚ}, padicValRat p q ≤ padicValRat p r → padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
hle : ¬padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)

p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hle : padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
tactic: wlog hle : padicValRat p q ≤ padicValRat p r generalizing q r
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hle : padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
state_after: no goals
tactic: exact nonarchimedean_aux hle
Theorem: Polynomial.derivative_of_natDegree_zero
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : p.natDegree = 0
⊢ derivative p = 0
state_after: no goals
tactic: rw [eq_C_of_natDegree_eq_zero hp, derivative_C]
Theorem: CategoryTheory.Limits.KernelFork.IsLimit.isIso_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
⊢ IsIso (Fork.ι c)
tactic: let e : c.pt ≅ X := IsLimit.conePointUniqueUpToIso hc
    (KernelFork.IsLimit.ofId (f : X ⟶ Y) hf)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (Fork.ι c)
tactic: have eq : e.inv ≫ c.ι = 𝟙 X := Fork.IsLimit.lift_ι hc
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
this : IsIso (e.inv ≫ Fork.ι c)
⊢ IsIso (Fork.ι c)
tactic: haveI : IsIso (e.inv ≫ c.ι) := by
    rw [eq]
    infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
this : IsIso (e.inv ≫ Fork.ι c)
⊢ IsIso (Fork.ι c)
state_after: no goals
tactic: exact IsIso.of_isIso_comp_left e.inv c.ι
Theorem: List.nodup_ofFn
File: Mathlib/Data/List/FinRange.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ (ofFn f).Nodup ↔ Function.Injective f
state_after: α : Type u
n : ℕ
f : Fin n → α
⊢ (ofFn f).Nodup → Function.Injective f
tactic: refine ⟨?_, nodup_ofFn_ofInjective⟩
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ (ofFn f).Nodup → Function.Injective f
state_after: case refine_1
α : Type u
n : ℕ
f : Fin n → α
⊢ (ofFn Fin.elim0).Nodup → Function.Injective Fin.elim0

case refine_2
α : Type u
n : ℕ
f : Fin n → α
n✝ : ℕ
x₀ : α
xs : Fin n✝ → α
ih : (ofFn xs).Nodup → Function.Injective xs
⊢ (ofFn (Fin.cons x₀ xs)).Nodup → Function.Injective (Fin.cons x₀ xs)
tactic: refine Fin.consInduction ?_ (fun x₀ xs ih => ?_) f
Theorem: descPochhammer_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
⊢ descPochhammer R 1 = X
state_after: no goals
tactic: simp [descPochhammer]
Theorem: MeasureTheory.Integrable.condexpKernel_ae
File: Mathlib/Probability/Kernel/Condexp.lean

Proof steps:
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ ∀ᵐ (ω : Ω) ∂μ, Integrable f ((condexpKernel μ m) ω)
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ ∀ᵐ (ω : Ω) ∂μ, Integrable f (((condDistrib id id μ).comap id ⋯) ω)
tactic: rw [condexpKernel]
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ ∀ᵐ (ω : Ω) ∂μ, Integrable f (((condDistrib id id μ).comap id ⋯) ω)
state_after: no goals
tactic: convert Integrable.condDistrib_ae
    (aemeasurable_id'' μ (inf_le_right : m ⊓ mΩ ≤ mΩ)) aemeasurable_id
    (hf_int.comp_snd_map_prod_id (inf_le_right : m ⊓ mΩ ≤ mΩ)) using 1
Theorem: Finset.update_piecewise_of_mem
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∈ s
v : π i
⊢ update (s.piecewise f g) i v = s.piecewise (update f i v) g
state_after: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∈ s
v : π i
⊢ s.piecewise (update f i v) (update g i v) = s.piecewise (update f i v) g
tactic: rw [update_piecewise]
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∈ s
v : π i
⊢ s.piecewise (update f i v) (update g i v) = s.piecewise (update f i v) g
state_after: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∈ s
v : π i
j : ι
hj : j ∉ s
⊢ j ≠ i
tactic: refine s.piecewise_congr (fun _ _ => rfl) fun j hj => update_noteq ?_ _ _
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∈ s
v : π i
j : ι
hj : j ∉ s
⊢ j ≠ i
state_after: no goals
tactic: exact fun h => hj (h.symm ▸ hi)
Theorem: Relation.ReflGen.mono
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d : α
p : α → α → Prop
hp : ∀ (a b : α), r a b → p a b
a : α
⊢ ReflGen p a a
state_after: no goals
tactic: rfl