ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ideal.iInf_span_singleton_natCast
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R✝ : Type u
ι✝ : Type u_1
inst✝² : CommSemiring R✝
I✝ J K L : Ideal R✝
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Fintype ι
I : ι → ℕ
hI : Pairwise fun i j => (I i).Coprime (I j)
⊢ ⨅ i, span {↑(I i)} = span {↑(∏ i : ι, I i)}
state_after: R✝ : Type u
ι✝ : Type u_1
inst✝² : CommSemiring R✝
I✝ J K L : Ideal R✝
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Fintype ι
I : ι → ℕ
hI : Pairwise fun i j => (I i).Coprime (I j)
⊢ ∀ (i j : ι), i ≠ j → IsCoprime ↑(I i) ↑(I j)
tactic: rw [iInf_span_singleton, Nat.cast_prod]
state_before: R✝ : Type u
ι✝ : Type u_1
inst✝² : CommSemiring R✝
I✝ J K L : Ideal R✝
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Fintype ι
I : ι → ℕ
hI : Pairwise fun i j => (I i).Coprime (I j)
⊢ ∀ (i j : ι), i ≠ j → IsCoprime ↑(I i) ↑(I j)
state_after: no goals
tactic: exact fun i j h ↦ (hI h).cast
Theorem: CategoryTheory.id_of_comp_right_id
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X
state_after: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X ≫ f
tactic: convert w (𝟙 X)
state_before: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X ≫ f
state_after: no goals
tactic: simp
Theorem: Set.indicator_iUnion_apply
File: Mathlib/Algebra/Order/Group/Indicator.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : CompleteLattice M
inst✝ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
⊢ (⋃ i, s i).mulIndicator f x = ⨆ i, (s i).mulIndicator f x
state_after: case pos
ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : CompleteLattice M
inst✝ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
hx : x ∈ ⋃ i, s i
⊢ (⋃ i, s i).mulIndicator f x = ⨆ i, (s i).mulIndicator f x

case neg
ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : CompleteLattice M
inst✝ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
hx : x ∉ ⋃ i, s i
⊢ (⋃ i, s i).mulIndicator f x = ⨆ i, (s i).mulIndicator f x
tactic: by_cases hx : x ∈ ⋃ i, s i
Theorem: ae_not_liouvilleWith
File: Mathlib/NumberTheory/Liouville/Measure.lean

Proof steps:
state_before: ⊢ ∀ᵐ (x : ℝ), ∀ p > 2, ¬LiouvilleWith p x
state_after: no goals
tactic: simpa only [ae_iff, not_forall, Classical.not_not, setOf_exists] using
    volume_iUnion_setOf_liouvilleWith
Theorem: Real.cos_three_mul
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℝ
⊢ ↑(cos (3 * x)) = ↑(4 * cos x ^ 3 - 3 * cos x)
tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ ↑(cos (3 * x)) = ↑(4 * cos x ^ 3 - 3 * cos x)
state_after: no goals
tactic: simp [cos_three_mul]
Theorem: CategoryTheory.Presheaf.IsSheaf.amalgamate_map
File: Mathlib/CategoryTheory/Sites/Sheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
A✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} A✝
J : GrothendieckTopology C
A : Type u₂
inst✝ : Category.{v₂, u₂} A
E : A
X : C
P : Cᵒᵖ ⥤ A
hP : IsSheaf J P
S : J.Cover X
x : (I : S.Arrow) → E ⟶ P.obj (op I.Y)
hx : ∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂), x I₁ ≫ P.map r.g₁.op = x I₂ ≫ P.map r.g₂.op
I : S.Arrow
⊢ hP.amalgamate S x hx ≫ P.map I.f.op = x I
state_after: no goals
tactic: apply (hP _ _ S.condition).valid_glue
Theorem: CategoryTheory.coalgebraEquivOver_functor
File: Mathlib/CategoryTheory/Monad/Products.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
A : (prodComonad X).Coalgebra
⊢ (((𝟭 (prodComonad X).Coalgebra).obj A).a ≫
        (prodComonad X).map (Iso.refl ((𝟭 (prodComonad X).Coalgebra).obj A).A).hom) ≫
      prod.fst =
    ((Iso.refl ((𝟭 (prodComonad X).Coalgebra).obj A).A).hom ≫ ((coalgebraToOver X ⋙ overToCoalgebra X).obj A).a) ≫
      prod.fst
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
A : (prodComonad X).Coalgebra
⊢ (((𝟭 (prodComonad X).Coalgebra).obj A).a ≫
        (prodComonad X).map (Iso.refl ((𝟭 (prodComonad X).Coalgebra).obj A).A).hom) ≫
      prod.snd =
    ((Iso.refl ((𝟭 (prodComonad X).Coalgebra).obj A).A).hom ≫ ((coalgebraToOver X ⋙ overToCoalgebra X).obj A).a) ≫
      prod.snd
state_after: no goals
tactic: simpa using A.counit
Theorem: Orientation.kahler_rightAngleRotation_left
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.kahler (o.rightAngleRotation x)) y = -Complex.I * (o.kahler x) y
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ↑((o.areaForm x) y) + -↑⟪x, y⟫_ℝ * Complex.I = -Complex.I * (↑⟪x, y⟫_ℝ + ↑((o.areaForm x) y) * Complex.I)
tactic: simp only [o.areaForm_rightAngleRotation_left, o.inner_rightAngleRotation_left,
    o.kahler_apply_apply, Complex.ofReal_neg, Complex.real_smul]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ↑((o.areaForm x) y) + -↑⟪x, y⟫_ℝ * Complex.I = -Complex.I * (↑⟪x, y⟫_ℝ + ↑((o.areaForm x) y) * Complex.I)
state_after: no goals
tactic: linear_combination ω x y * Complex.I_sq
Theorem: FreeAlgebra.toTensor_ι
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ toTensor (ι R m) = (TensorAlgebra.ι R) m
state_after: no goals
tactic: simp [toTensor]
Theorem: Finset.card_biUnion_le
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
this : DecidableEq α
⊢ (∅.biUnion t).card ≤ ∑ a ∈ ∅, (t a).card
state_after: no goals
tactic: simp
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ ((insert a s).biUnion t).card ≤ (t a).card + (s.biUnion t).card
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ (t a ∪ s.biUnion t).card ≤ (t a).card + (s.biUnion t).card
tactic: rw [biUnion_insert]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ (t a ∪ s.biUnion t).card ≤ (t a).card + (s.biUnion t).card
state_after: no goals
tactic: exact Finset.card_union_le _ _
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ (t a).card + (s.biUnion t).card ≤ ∑ a ∈ insert a s, (t a).card
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ (t a).card + (s.biUnion t).card ≤ (t a).card + ∑ x ∈ s, (t x).card
tactic: rw [sum_insert has]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : a ∉ s
ih : (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
⊢ (t a).card + (s.biUnion t).card ≤ (t a).card + ∑ x ∈ s, (t x).card
state_after: no goals
tactic: exact Nat.add_le_add_left ih _
Theorem: QPF.Fix.dest_mk
File: Mathlib/Data/QPF/Univariate/Basic.lean

Proof steps:
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk x).dest = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ rec (Functor.map mk) (mk x) = x
tactic: unfold Fix.dest
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ rec (Functor.map mk) (mk x) = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = x
tactic: rw [Fix.rec_eq, ← Fix.dest, ← comp_map]
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x
tactic: conv =>
    rhs
    rw [← id_map x]
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x
state_after: case e_a.h
F : Type u → Type u
q : QPF F
x✝ : F (Fix F)
x : Fix F
⊢ (mk ∘ dest) x = id x
tactic: congr with x
state_before: case e_a.h
F : Type u → Type u
q : QPF F
x✝ : F (Fix F)
x : Fix F
⊢ (mk ∘ dest) x = id x
state_after: no goals
tactic: apply Fix.mk_dest
Theorem: AddSubgroup.le_normalizer_map
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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x✝ : N
⊢ x✝ ∈ map f H.normalizer → x✝ ∈ (map f H).normalizer
state_after: 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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x✝ : N
⊢ ∀ (x : G),
    (∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H) → f x = x✝ → ∀ (h : N), (∃ x ∈ H, f x = h) ↔ ∃ x ∈ H, f x = x✝ * h * x✝⁻¹
tactic: simp only [and_imp, exists_prop, mem_map, exists_imp, mem_normalizer_iff]
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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x✝ : N
⊢ ∀ (x : G),
    (∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H) → f x = x✝ → ∀ (h : N), (∃ x ∈ H, f x = h) ↔ ∃ x ∈ H, f x = x✝ * h * x✝⁻¹
state_after: 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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x : G
hx : ∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H
n : N
⊢ (∃ x ∈ H, f x = n) ↔ ∃ x_1 ∈ H, f x_1 = f x * n * (f x)⁻¹
tactic: rintro x hx rfl n
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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x : G
hx : ∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H
n : N
⊢ (∃ x ∈ H, f x = n) ↔ ∃ x_1 ∈ H, f x_1 = f x * n * (f x)⁻¹
state_after: case mp
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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x : G
hx : ∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H
n : N
⊢ (∃ x ∈ H, f x = n) → ∃ x_1 ∈ H, f x_1 = f x * n * (f x)⁻¹

case mpr
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
H K : Subgroup G
N : Type u_5
inst✝ : Group N
f : G →* N
x : G
hx : ∀ (h : G), h ∈ H ↔ x * h * x⁻¹ ∈ H
n : N
⊢ (∃ x_1 ∈ H, f x_1 = f x * n * (f x)⁻¹) → ∃ x ∈ H, f x = n
tactic: constructor
Theorem: Submodule.span_neg
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ span R (-s) = span R (⇑(-LinearMap.id) '' s)
state_after: no goals
tactic: simp
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ map (-LinearMap.id) (span R s) = span R s
state_after: no goals
tactic: simp
Theorem: MeasureTheory.OuterMeasure.trim_eq_trim_iff
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
⊢ m₁.trim = m₂.trim ↔ ∀ (s : Set α), MeasurableSet s → m₁ s = m₂ s
state_after: no goals
tactic: simp only [le_antisymm_iff, trim_le_trim_iff, forall_and]
Theorem: Quaternion.normSq_smul
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r✝ x y z : R
a b c : ℍ[R]
r : R
q : ℍ[R]
⊢ normSq (r • q) = r ^ 2 * normSq q
state_after: no goals
tactic: simp only [normSq_def', smul_re, smul_imI, smul_imJ, smul_imK, mul_pow, mul_add, smul_eq_mul]
Theorem: Units.mk0_inj
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b✝ a b : G₀
ha : a ≠ 0
hb : b ≠ 0
h : mk0 a ha = mk0 b hb
⊢ a = b
state_after: no goals
tactic: injection h
Theorem: Set.offDiag_union
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
h : Disjoint s t
⊢ (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
state_after: case h
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ x ∈ (s ∪ t).offDiag ↔ x ∈ s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
tactic: ext x
state_before: case h
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ x ∈ (s ∪ t).offDiag ↔ x ∈ s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
state_after: case h
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ (x.1 ∈ s ∨ x.1 ∈ t) ∧ (x.2 ∈ s ∨ x.2 ∈ t) ∧ ¬x.1 = x.2 ↔
    ((x.1 ∈ s ∧ x.2 ∈ s ∧ ¬x.1 = x.2 ∨ x.1 ∈ t ∧ x.2 ∈ t ∧ ¬x.1 = x.2) ∨ x.1 ∈ s ∧ x.2 ∈ t) ∨ x.1 ∈ t ∧ x.2 ∈ s
tactic: simp only [mem_offDiag, mem_union, ne_eq, mem_prod]
state_before: case h
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ (x.1 ∈ s ∨ x.1 ∈ t) ∧ (x.2 ∈ s ∨ x.2 ∈ t) ∧ ¬x.1 = x.2 ↔
    ((x.1 ∈ s ∧ x.2 ∈ s ∧ ¬x.1 = x.2 ∨ x.1 ∈ t ∧ x.2 ∈ t ∧ ¬x.1 = x.2) ∨ x.1 ∈ s ∧ x.2 ∈ t) ∨ x.1 ∈ t ∧ x.2 ∈ s
state_after: case h.mp
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ (x.1 ∈ s ∨ x.1 ∈ t) ∧ (x.2 ∈ s ∨ x.2 ∈ t) ∧ ¬x.1 = x.2 →
    ((x.1 ∈ s ∧ x.2 ∈ s ∧ ¬x.1 = x.2 ∨ x.1 ∈ t ∧ x.2 ∈ t ∧ ¬x.1 = x.2) ∨ x.1 ∈ s ∧ x.2 ∈ t) ∨ x.1 ∈ t ∧ x.2 ∈ s

case h.mpr
α : Type u_1
s t : Set α
x✝ : α × α
a : α
h : Disjoint s t
x : α × α
⊢ ((x.1 ∈ s ∧ x.2 ∈ s ∧ ¬x.1 = x.2 ∨ x.1 ∈ t ∧ x.2 ∈ t ∧ ¬x.1 = x.2) ∨ x.1 ∈ s ∧ x.2 ∈ t) ∨ x.1 ∈ t ∧ x.2 ∈ s →
    (x.1 ∈ s ∨ x.1 ∈ t) ∧ (x.2 ∈ s ∨ x.2 ∈ t) ∧ ¬x.1 = x.2
tactic: constructor
Theorem: Complex.arg_coe_angle_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x y : ℂ
⊢ ↑x.arg = ↑y.arg ↔ x.arg = y.arg
state_after: no goals
tactic: simp_rw [← Real.Angle.toReal_inj, arg_coe_angle_toReal_eq_arg]
Theorem: Set.Ioi_mul_Ici_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
⊢ Ioi a * Ici b ⊆ Ioi (a * b)
state_after: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.11614) (N : Type ?u.11613) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ioi a * Ici b ⊆ Ioi (a * b)
tactic: haveI := covariantClass_le_of_lt
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.11614) (N : Type ?u.11613) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ioi a * Ici b ⊆ Ioi (a * b)
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.11614) (N : Type ?u.11613) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Ioi a
z : α
hzb : z ∈ Ici b
⊢ (fun x x_1 => x * x_1) y z ∈ Ioi (a * b)
tactic: rintro x ⟨y, hya, z, hzb, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.11614) (N : Type ?u.11613) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Ioi a
z : α
hzb : z ∈ Ici b
⊢ (fun x x_1 => x * x_1) y z ∈ Ioi (a * b)
state_after: no goals
tactic: exact mul_lt_mul_of_lt_of_le hya hzb
Theorem: Finset.sum_attach_univ
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid α
inst✝ : Fintype ι
f : { i // i ∈ univ } → α
⊢ ∀ (x : { x // x ∈ univ }), f x = f ⟨(Equiv.subtypeUnivEquiv ⋯) x, ⋯⟩
state_after: no goals
tactic: simp
Theorem: PadicInt.valuation_nonneg
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
⊢ 0 ≤ x.valuation
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x = 0
⊢ 0 ≤ x.valuation

case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
⊢ 0 ≤ x.valuation
tactic: by_cases hx : x = 0
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
⊢ 0 ≤ x.valuation
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ 0 ≤ x.valuation
tactic: have h : (1 : ℝ) < p := mod_cast hp.1.one_lt
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ 0 ≤ x.valuation
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ 0
tactic: rw [← neg_nonpos, ← (zpow_strictMono h).le_iff_le]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ 0
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ‖x‖ ≤ ↑p ^ 0
tactic: rw [← norm_eq_pow_val hx]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ‖x‖ ≤ ↑p ^ 0
state_after: no goals
tactic: simpa using x.property
Theorem: Subfield.mem_iSup_of_directed
File: Mathlib/Algebra/Field/Subfield.lean

Proof steps:
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
state_after: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
s : Subfield K :=
  let __spread.0 := (⨆ i, (S i).toSubring).copy (⋃ i, ↑(S i).toSubring) ⋯;
  { toSubring := __spread.0, inv_mem' := ⋯ }
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
tactic: let s : Subfield K :=
    { __ := Subring.copy _ _ (Subring.coe_iSup_of_directed hS).symm
      inv_mem' := fun _ hx ↦ have ⟨i, hi⟩ := Set.mem_iUnion.mp hx
        Set.mem_iUnion.mpr ⟨i, (S i).inv_mem hi⟩ }
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
s : Subfield K :=
  let __spread.0 := (⨆ i, (S i).toSubring).copy (⋃ i, ↑(S i).toSubring) ⋯;
  { toSubring := __spread.0, inv_mem' := ⋯ }
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
state_after: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
s : Subfield K :=
  let __spread.0 := (⨆ i, (S i).toSubring).copy (⋃ i, ↑(S i).toSubring) ⋯;
  { toSubring := __spread.0, inv_mem' := ⋯ }
this : iSup S = s
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
tactic: have : iSup S = s := le_antisymm
    (iSup_le fun i ↦ le_iSup (fun i ↦ (S i : Set K)) i) (Set.iUnion_subset fun _ ↦ le_iSup S _)
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
s : Subfield K :=
  let __spread.0 := (⨆ i, (S i).toSubring).copy (⋃ i, ↑(S i).toSubring) ⋯;
  { toSubring := __spread.0, inv_mem' := ⋯ }
this : iSup S = s
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
state_after: no goals
tactic: exact this ▸ Set.mem_iUnion
Theorem: Subgroup.mem_center_iff
File: Mathlib/GroupTheory/Subgroup/Center.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
z : G
⊢ z ∈ center G ↔ ∀ (g : G), g * z = z * g
state_after: G : Type u_1
inst✝ : Group G
z : G
⊢ z ∈ center G ↔ z ∈ Set.center G
tactic: rw [← Semigroup.mem_center_iff]
state_before: G : Type u_1
inst✝ : Group G
z : G
⊢ z ∈ center G ↔ z ∈ Set.center G
state_after: no goals
tactic: exact Iff.rfl