ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieSubmodule.sInf_coe
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
S : Set (LieSubmodule R L M)
⊢ ↑(sInf S) = ⋂ s ∈ S, ↑s
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
S : Set (LieSubmodule R L M)
⊢ ⋂ p ∈ {x | ∃ s ∈ S, ↑s = x}, ↑p = ⋂ s ∈ S, ↑s
tactic: rw [← LieSubmodule.coe_toSubmodule, sInf_coe_toSubmodule, Submodule.sInf_coe]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
S : Set (LieSubmodule R L M)
⊢ ⋂ p ∈ {x | ∃ s ∈ S, ↑s = x}, ↑p = ⋂ s ∈ S, ↑s
state_after: case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
S : Set (LieSubmodule R L M)
m : M
⊢ m ∈ ⋂ p ∈ {x | ∃ s ∈ S, ↑s = x}, ↑p ↔ m ∈ ⋂ s ∈ S, ↑s
tactic: ext m
state_before: case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
S : Set (LieSubmodule R L M)
m : M
⊢ m ∈ ⋂ p ∈ {x | ∃ s ∈ S, ↑s = x}, ↑p ↔ m ∈ ⋂ s ∈ S, ↑s
state_after: no goals
tactic: simp only [mem_iInter, mem_setOf_eq, forall_apply_eq_imp_iff₂, exists_imp,
    and_imp, SetLike.mem_coe, mem_coeSubmodule]
Theorem: Class.mem_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y : Class
⊢ y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
state_after: case mp
x y : Class
⊢ y ∈ ⋃₀ x → ∃ z ∈ x, y ∈ z

case mpr
x y : Class
⊢ (∃ z ∈ x, y ∈ z) → y ∈ ⋃₀ x
tactic: constructor
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_const
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
c : ℝ≥0
⊢ μ.testAgainstNN (const Ω c) = c * μ.mass
state_after: no goals
tactic: simp [← ENNReal.coe_inj]
Theorem: Polynomial.mirror_mul_of_domain
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
⊢ (p * q).mirror = p.mirror * q.mirror
state_after: case pos
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : p = 0
⊢ (p * q).mirror = p.mirror * q.mirror

case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
⊢ (p * q).mirror = p.mirror * q.mirror
tactic: by_cases hp : p = 0
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
⊢ (p * q).mirror = p.mirror * q.mirror
state_after: case pos
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : q = 0
⊢ (p * q).mirror = p.mirror * q.mirror

case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ (p * q).mirror = p.mirror * q.mirror
tactic: by_cases hq : q = 0
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ (p * q).mirror = p.mirror * q.mirror
state_after: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ p.reverse * q.reverse * (X ^ p.natTrailingDegree * X ^ q.natTrailingDegree) =
    p.reverse * X ^ p.natTrailingDegree * (q.reverse * X ^ q.natTrailingDegree)
tactic: rw [mirror, mirror, mirror, reverse_mul_of_domain, natTrailingDegree_mul hp hq, pow_add]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ p.reverse * q.reverse * (X ^ p.natTrailingDegree * X ^ q.natTrailingDegree) =
    p.reverse * X ^ p.natTrailingDegree * (q.reverse * X ^ q.natTrailingDegree)
state_after: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ p.reverse * (X ^ p.natTrailingDegree * q.reverse * X ^ q.natTrailingDegree) =
    p.reverse * X ^ p.natTrailingDegree * (q.reverse * X ^ q.natTrailingDegree)
tactic: rw [mul_assoc, ← mul_assoc q.reverse, ← X_pow_mul (p := reverse q)]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ p.reverse * (X ^ p.natTrailingDegree * q.reverse * X ^ q.natTrailingDegree) =
    p.reverse * X ^ p.natTrailingDegree * (q.reverse * X ^ q.natTrailingDegree)
state_after: no goals
tactic: repeat' rw [mul_assoc]
Theorem: WithTop.isLUB_sSup'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrderBot α
β : Type u_5
inst✝ : ConditionallyCompleteLattice β
s : Set (WithTop β)
hs : s.Nonempty
⊢ IsLUB s (sSup s)
state_after: case left
α : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrderBot α
β : Type u_5
inst✝ : ConditionallyCompleteLattice β
s : Set (WithTop β)
hs : s.Nonempty
⊢ sSup s ∈ upperBounds s

case right
α : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrderBot α
β : Type u_5
inst✝ : ConditionallyCompleteLattice β
s : Set (WithTop β)
hs : s.Nonempty
⊢ sSup s ∈ lowerBounds (upperBounds s)
tactic: constructor
Theorem: intervalIntegral.integral_mono_interval
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in a..b, f x ∂μ ≤ ∫ (x : ℝ) in c..d, f x ∂μ
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in Ioc a b, f x ∂μ ≤ ∫ (x : ℝ) in Ioc c d, f x ∂μ
tactic: rw [integral_of_le hab, integral_of_le (hca.trans (hab.trans hbd))]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in Ioc a b, f x ∂μ ≤ ∫ (x : ℝ) in Ioc c d, f x ∂μ
state_after: no goals
tactic: exact setIntegral_mono_set hfi.1 hf (Ioc_subset_Ioc hca hbd).eventuallyLE
Theorem: symmDiff_symmDiff_inf
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b ∆ (a ⊓ b) = a ⊔ b
state_after: no goals
tactic: rw [← symmDiff_sdiff_inf a, sdiff_symmDiff_eq_sup, symmDiff_sup_inf]
Theorem: SimplexCategory.continuous_toTopMap
File: Mathlib/AlgebraicTopology/TopologicalSimplex.lean

Proof steps:
state_before: x y : SimplexCategory
f : x ⟶ y
⊢ Continuous (toTopMap f)
state_after: x y : SimplexCategory
f : x ⟶ y
i : (forget SimplexCategory).obj y
⊢ Continuous fun a => ∑ j ∈ Finset.filter (fun x_1 => f x_1 = i) Finset.univ, ↑a j
tactic: refine Continuous.subtype_mk (continuous_pi fun i => ?_) _
state_before: x y : SimplexCategory
f : x ⟶ y
i : (forget SimplexCategory).obj y
⊢ Continuous fun a => ∑ j ∈ Finset.filter (fun x_1 => f x_1 = i) Finset.univ, ↑a j
state_after: no goals
tactic: exact continuous_finset_sum _ (fun j _ => (continuous_apply _).comp continuous_subtype_val)
Theorem: Function.comp_iterate_pred_of_pos
File: Mathlib/Logic/Function/Iterate.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → α
n : ℕ
hn : 0 < n
⊢ f ∘ f^[n.pred] = f^[n]
state_after: no goals
tactic: rw [← iterate_succ', Nat.succ_pred_eq_of_pos hn]
Theorem: Int.toNat_le_toNat
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c d m n a b : ℤ
h : a ≤ b
⊢ a.toNat ≤ b.toNat
state_after: a✝ b✝ c d m n a b : ℤ
h : a ≤ b
⊢ a ≤ ↑b.toNat
tactic: rw [toNat_le]
state_before: a✝ b✝ c d m n a b : ℤ
h : a ≤ b
⊢ a ≤ ↑b.toNat
state_after: no goals
tactic: exact Int.le_trans h (self_le_toNat b)
Theorem: Matrix.rank_mul_le_left
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ (A * B).rank ≤ A.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range A.mulVecLin)
tactic: rw [rank, rank, mulVecLin_mul]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range A.mulVecLin)
state_after: no goals
tactic: exact Cardinal.toNat_le_toNat (LinearMap.rank_comp_le_left _ _) (rank_lt_aleph0 _ _)
Theorem: LinearMap.IsSymm.tmul
File: Mathlib/LinearAlgebra/BilinearForm/TensorProduct.lean

Proof steps:
state_before: ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinMap A M₁ A
B₂ : BilinMap R M₂ R
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ IsSymm (B₁.tmul B₂)
state_after: ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinMap A M₁ A
B₂ : BilinMap R M₂ R
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ B₁.tmul B₂ = flip (B₁.tmul B₂)
tactic: rw [LinearMap.isSymm_iff_eq_flip]
state_before: ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinMap A M₁ A
B₂ : BilinMap R M₂ R
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ B₁.tmul B₂ = flip (B₁.tmul B₂)
state_after: case a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinMap A M₁ A
B₂ : BilinMap R M₂ R
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
x₁ : M₁
x₂ : M₂
y₁ : M₁
y₂ : M₂
⊢ ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (B₁.tmul B₂)) x₁) x₂)) y₁) y₂ =
    ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (flip (B₁.tmul B₂))) x₁) x₂)) y₁) y₂
tactic: ext x₁ x₂ y₁ y₂
state_before: case a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinMap A M₁ A
B₂ : BilinMap R M₂ R
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
x₁ : M₁
x₂ : M₂
y₁ : M₁
y₂ : M₂
⊢ ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (B₁.tmul B₂)) x₁) x₂)) y₁) y₂ =
    ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (flip (B₁.tmul B₂))) x₁) x₂)) y₁) y₂
state_after: no goals
tactic: exact congr_arg₂ (HSMul.hSMul) (hB₂ x₂ y₂) (hB₁ x₁ y₁)
Theorem: min_mul_distrib'
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyLinearOrderedCommMonoid α
a b c : α
⊢ min (a * b) c = min (min a c * min b c) c
state_after: no goals
tactic: simpa [min_comm _ c] using min_mul_distrib c a b
Theorem: AddCommGroup.DirectLimit.map_comp
File: Mathlib/Algebra/DirectLimit.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →+ G' i
g₂ : (i : ι) → G' i →+ G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i)
hg₂ : ∀ (i j : ι) (h : i ≤ j), (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)
i j : ι
h : i ≤ j
⊢ ((fun i => (g₂ i).comp (g₁ i)) j).comp (f i j h) = (f'' i j h).comp ((fun i => (g₂ i).comp (g₁ i)) i)
state_after: no goals
tactic: rw [AddMonoidHom.comp_assoc, hg₁ i, ← AddMonoidHom.comp_assoc, hg₂ i,
        AddMonoidHom.comp_assoc]
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →+ G' i
g₂ : (i : ι) → G' i →+ G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i)
hg₂ : ∀ (i j : ι) (h : i ≤ j), (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)
x : DirectLimit G f
⊢ IsEmpty ι → ((map g₂ hg₂).comp (map g₁ hg₁)) x = (map (fun i => (g₂ i).comp (g₁ i)) ⋯) x
state_after: no goals
tactic: subsingleton
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g✝ : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) ((f i j hij) x) = (g✝ i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →+ G' i
g₂ : (i : ι) → G' i →+ G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i)
hg₂ : ∀ (i j : ι) (h : i ≤ j), (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)
x : DirectLimit G f
x✝ : Nonempty ι
i : ι
g : G i
⊢ ((map g₂ hg₂).comp (map g₁ hg₁)) ((of G f i) g) = (map (fun i => (g₂ i).comp (g₁ i)) ⋯) ((of G f i) g)
state_after: no goals
tactic: simp
Theorem: Fintype.piFinset_image
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
⊢ (piFinset fun a => image (f a) (s a)) = image (fun b a => f a (b a)) (piFinset s)
state_after: case a
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
a✝ : (a : α) → δ a
⊢ (a✝ ∈ piFinset fun a => image (f a) (s a)) ↔ a✝ ∈ image (fun b a => f a (b a)) (piFinset s)
tactic: ext
state_before: case a
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
a✝ : (a : α) → δ a
⊢ (a✝ ∈ piFinset fun a => image (f a) (s a)) ↔ a✝ ∈ image (fun b a => f a (b a)) (piFinset s)
state_after: no goals
tactic: simp only [mem_piFinset, mem_image, Classical.skolem, forall_and, Function.funext_iff]
Theorem: Complex.arg_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
hz : z.im < 0
⊢ z.arg = -Real.arccos (z.re / abs z)
state_after: a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ z.arg = -Real.arccos (z.re / abs z)
tactic: have h₀ : z ≠ 0 := mt (congr_arg im) hz.ne
state_before: a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ z.arg = -Real.arccos (z.re / abs z)
state_after: case hx₁
a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ 0 ≤ -z.arg

case hx₂
a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ -z.arg ≤ π
tactic: rw [← cos_arg h₀, ← Real.cos_neg, Real.arccos_cos, neg_neg]
state_before: case hx₁
a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ 0 ≤ -z.arg

case hx₂
a x z✝ z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ -z.arg ≤ π
state_after: no goals
tactic: exacts [neg_nonneg.2 (arg_neg_iff.2 hz).le, neg_le.2 (neg_pi_lt_arg z).le]
Theorem: WittVector.mulN_coeff
File: Mathlib/RingTheory/WittVector/MulP.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
x : 𝕎 R
k : ℕ
⊢ (x * ↑n).coeff k = (aeval x.coeff) (wittMulN p n k)
state_after: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
⊢ (x * ↑0).coeff k = (aeval x.coeff) (wittMulN p 0 k)

case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
n : ℕ
ih : ∀ (k : ℕ), (x * ↑n).coeff k = (aeval x.coeff) (wittMulN p n k)
k : ℕ
⊢ (x * ↑(n + 1)).coeff k = (aeval x.coeff) (wittMulN p (n + 1) k)
tactic: induction' n with n ih generalizing k
Theorem: AkraBazziRecurrence.strictAntiOn_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn ε (Set.Ioi 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)
tactic: show StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => (log x)⁻¹) (Set.Ioi 1)
tactic: simp_rw [one_div]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => (log x)⁻¹) (Set.Ioi 1)
state_after: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn log (Set.Ioi 1)
tactic: refine StrictAntiOn.comp_strictMonoOn inv_strictAntiOn ?log fun _ hx => log_pos hx
state_before: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn log (Set.Ioi 1)
state_after: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : x ∈ Set.Ioi 1
⊢ x ∈ Set.Ioi 0
tactic: refine StrictMonoOn.mono strictMonoOn_log (fun x hx => ?_)
state_before: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : x ∈ Set.Ioi 1
⊢ x ∈ Set.Ioi 0
state_after: no goals
tactic: exact Set.Ioi_subset_Ioi zero_le_one hx
Theorem: FiberBundle.chartedSpace_chartAt_symm_fst
File: Mathlib/Geometry/Manifold/VectorBundle/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy : y ∈ (chartAt (ModelProd HB F) x).target
⊢ (↑(chartAt (ModelProd HB F) x).symm y).proj = ↑(chartAt HB x.proj).symm y.1
state_after: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy :
  y ∈ (chartAt HB x.proj).target ×ˢ univ ∧
    ↑((chartAt HB x.proj).prod (PartialEquiv.refl F)).symm y ∈ (trivializationAt F E x.proj).target
⊢ (↑(trivializationAt F E x.proj).symm (↑((chartAt HB x.proj).prod (PartialHomeomorph.refl F)).symm y)).proj =
    ↑(chartAt HB x.proj).symm y.1
tactic: simp only [FiberBundle.chartedSpace_chartAt, mfld_simps] at hy ⊢
state_before: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy :
  y ∈ (chartAt HB x.proj).target ×ˢ univ ∧
    ↑((chartAt HB x.proj).prod (PartialEquiv.refl F)).symm y ∈ (trivializationAt F E x.proj).target
⊢ (↑(trivializationAt F E x.proj).symm (↑((chartAt HB x.proj).prod (PartialHomeomorph.refl F)).symm y)).proj =
    ↑(chartAt HB x.proj).symm y.1
state_after: no goals
tactic: exact (trivializationAt F E x.proj).proj_symm_apply hy.2
Theorem: AlgHom.card
File: Mathlib/FieldTheory/PrimitiveElement.lean

Proof steps:
state_before: F : Type u_1
E : Type u_2
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
inst✝⁴ : FiniteDimensional F E
inst✝³ : Algebra.IsSeparable F E
K : Type u_3
inst✝² : Field K
inst✝¹ : IsAlgClosed K
inst✝ : Algebra F K
⊢ Fintype.card (E →ₐ[F] K) = finrank F E
state_after: no goals
tactic: convert (AlgHom.card_of_powerBasis (L := K) (Field.powerBasisOfFiniteOfSeparable F E)
    (Algebra.IsSeparable.isSeparable _ _) (IsAlgClosed.splits_codomain _)).trans
      (PowerBasis.finrank _).symm