ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddOreLocalization.eq_of_num_factor_eq
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
⊢ r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s
state_after: case mk.mk
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s
tactic: rcases oreCondition r₁ t with ⟨r₁', t', hr₁⟩
state_before: case mk.mk
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s
state_after: case mk.mk
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ t' • (r₁ * r * r₂) /ₒ (t' * s) = t' • (r₁ * r' * r₂) /ₒ (t' * s)
tactic: rw [OreLocalization.expand' _ s t', OreLocalization.expand' _ s t']
state_before: case mk.mk
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ t' • (r₁ * r * r₂) /ₒ (t' * s) = t' • (r₁ * r' * r₂) /ₒ (t' * s)
state_after: case mk.mk.e_r
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ t' • (r₁ * r * r₂) = t' • (r₁ * r' * r₂)
tactic: congr 1
state_before: case mk.mk.e_r
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.24237
inst✝ : MulAction R X
r r' r₁ r₂ : R
s t : ↥S
h : ↑t * r = ↑t * r'
r₁' : R
t' : ↥S
hr₁ : ↑t' * r₁ = r₁' * ↑t
⊢ t' • (r₁ * r * r₂) = t' • (r₁ * r' * r₂)
state_after: no goals
tactic: calc (t' : R) * (r₁ * r * r₂)
      = t' * r₁ * r * r₂ := by simp [← mul_assoc]
    _ = r₁' * t * r * r₂ := by rw [hr₁]
    _ = r₁' * (t * r) * r₂ := by simp [← mul_assoc]
    _ = r₁' * (t * r') * r₂ := by rw [h]
    _ = r₁' * t * r' * r₂ := by simp [← mul_assoc]
    _ = t' * r₁ * r' * r₂ := by rw [hr₁]
    _ = t' * (r₁ * r' * r₂) := by simp [← mul_assoc]
Theorem: CategoryTheory.IsHomLift.commSq
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
inst✝ : p.IsHomLift f φ
⊢ p.map φ ≫ eqToHom ⋯ = eqToHom ⋯ ≫ f
state_after: no goals
tactic: simp only [fac p f φ, eqToHom_trans_assoc, eqToHom_refl, id_comp]
Theorem: SkyscraperPresheafFunctor.map'_comp
File: Mathlib/Topology/Sheaves/Skyscraper.lean

Proof steps:
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a b c : C
f : a ⟶ b
g : b ⟶ c
⊢ map' p₀ (f ≫ g) = map' p₀ f ≫ map' p₀ g
state_after: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a b c : C
f : a ⟶ b
g : b ⟶ c
U : Opens ↑X
⊢ (map' p₀ (f ≫ g)).app (op U) = (map' p₀ f ≫ map' p₀ g).app (op U)
tactic: ext U
state_before: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a b c : C
f : a ⟶ b
g : b ⟶ c
U : Opens ↑X
⊢ (map' p₀ (f ≫ g)).app (op U) = (map' p₀ f ≫ map' p₀ g).app (op U)
state_after: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a b c : C
f : a ⟶ b
g : b ⟶ c
U : Opens ↑X
⊢ (if h : p₀ ∈ U then eqToHom ⋯ ≫ (f ≫ g) ≫ eqToHom ⋯
    else (⋯ ▸ terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj (op U))) =
    (map' p₀ f ≫ map' p₀ g).app (op U)
tactic: simp only [SkyscraperPresheafFunctor.map'_app, NatTrans.comp_app]
state_before: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a b c : C
f : a ⟶ b
g : b ⟶ c
U : Opens ↑X
⊢ (if h : p₀ ∈ U then eqToHom ⋯ ≫ (f ≫ g) ≫ eqToHom ⋯
    else (⋯ ▸ terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj (op U))) =
    (map' p₀ f ≫ map' p₀ g).app (op U)
state_after: no goals
tactic: split_ifs with h <;> aesop_cat
Theorem: LSeries.term_neg_apply
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f : ℕ → ℂ
s : ℂ
n : ℕ
⊢ term (-f) s n = -term f s n
state_after: no goals
tactic: rw [term_neg, Pi.neg_apply]
Theorem: Submodule.finrank_quotient_add_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
⊢ finrank K (V ⧸ s) + finrank K ↥s = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : Module.rank K (V ⧸ s) + Module.rank K ↥s = Module.rank K V
⊢ finrank K (V ⧸ s) + finrank K ↥s = finrank K V
tactic: have := rank_quotient_add_rank s
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : Module.rank K (V ⧸ s) + Module.rank K ↥s = Module.rank K V
⊢ finrank K (V ⧸ s) + finrank K ↥s = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : ↑(finrank K (V ⧸ s)) + ↑(finrank K ↥s) = ↑(finrank K V)
⊢ finrank K (V ⧸ s) + finrank K ↥s = finrank K V
tactic: rw [← finrank_eq_rank, ← finrank_eq_rank, ← finrank_eq_rank] at this
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : ↑(finrank K (V ⧸ s)) + ↑(finrank K ↥s) = ↑(finrank K V)
⊢ finrank K (V ⧸ s) + finrank K ↥s = finrank K V
state_after: no goals
tactic: exact mod_cast this
Theorem: Int.floor_le_neg_one_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ ≤ -1 ↔ a < 0
state_after: no goals
tactic: rw [← zero_sub (1 : ℤ), floor_le_sub_one_iff, cast_zero]
Theorem: Hindman.FP_drop_subset_FP
File: Mathlib/Combinatorics/Hindman.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
⊢ FP (Stream'.drop n a) ⊆ FP a
state_after: case zero
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
⊢ FP (Stream'.drop 0 a) ⊆ FP a

case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop (n + 1) a) ⊆ FP a
tactic: induction' n with n ih
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop (n + 1) a) ⊆ FP a
state_after: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop 1 (Stream'.drop n a)) ⊆ FP a
tactic: rw [Nat.add_comm, ← Stream'.drop_drop]
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop 1 (Stream'.drop n a)) ⊆ FP a
state_after: no goals
tactic: exact _root_.trans (FP.tail _) ih
Theorem: IsClosed.union
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
⊢ IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∪ s₂)
state_after: no goals
tactic: simpa only [← isOpen_compl_iff, compl_union] using IsOpen.inter
Theorem: Orientation.oangle_ne_zero_and_ne_pi_iff_linearIndependent
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ o.oangle x y ≠ 0 ∧ o.oangle x y ≠ ↑π ↔ LinearIndependent ℝ ![x, y]
state_after: no goals
tactic: rw [← not_or, ← not_iff_not, Classical.not_not,
    oangle_eq_zero_or_eq_pi_iff_not_linearIndependent]
Theorem: MeasureTheory.VectorMeasure.AbsolutelyContinuous.ennrealToMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
μ : VectorMeasure α ℝ≥0∞
⊢ (∀ ⦃s : Set α⦄, μ.ennrealToMeasure s = 0 → ↑v s = 0) ↔ v ≪ᵥ μ
state_after: case mp
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
μ : VectorMeasure α ℝ≥0∞
h : ∀ ⦃s : Set α⦄, μ.ennrealToMeasure s = 0 → ↑v s = 0
⊢ v ≪ᵥ μ

case mpr
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
μ : VectorMeasure α ℝ≥0∞
h : v ≪ᵥ μ
⊢ ∀ ⦃s : Set α⦄, μ.ennrealToMeasure s = 0 → ↑v s = 0
tactic: constructor <;> intro h
Theorem: Equiv.Perm.support_cycleOf_le
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x : α
⊢ (f.cycleOf x).support ≤ f.support
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
hy : y ∈ (f.cycleOf x).support
⊢ y ∈ f.support
tactic: intro y hy
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
hy : y ∈ (f.cycleOf x).support
⊢ y ∈ f.support
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
hy : (if f.SameCycle x y then f y else y) ≠ y
⊢ y ∈ f.support
tactic: rw [mem_support, cycleOf_apply] at hy
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
hy : (if f.SameCycle x y then f y else y) ≠ y
⊢ y ∈ f.support
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
h✝ : f.SameCycle x y
hy : f y ≠ y
⊢ y ∈ f.support

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝³ : DecidableRel f✝.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
x y : α
h✝ : ¬f.SameCycle x y
hy : y ≠ y
⊢ y ∈ f.support
tactic: split_ifs at hy
Theorem: CategoryTheory.SingleFunctors.shiftIso_add'_inv_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.21503, u_1} C
inst✝⁶ : Category.{?u.21507, u_2} D
inst✝⁵ : Category.{?u.21511, u_3} E
inst✝⁴ : Category.{?u.21515, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
n m mn : A
hnm : m + n = mn
a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ mn + a = a''
state_after: no goals
tactic: rw [← hnm, ← ha'', ← ha', add_assoc]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{u_7, u_1} C
inst✝⁶ : Category.{u_6, u_2} D
inst✝⁵ : Category.{?u.21511, u_3} E
inst✝⁴ : Category.{?u.21515, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
n m mn : A
hnm : m + n = mn
a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ (F.shiftIso mn a a'' ⋯).inv.app X =
    (F.shiftIso n a a' ha').inv.app X ≫
      (shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
        (shiftFunctorAdd' D m n mn hnm).inv.app ((F.functor a'').obj X)
state_after: no goals
tactic: simp [F.shiftIso_add' n m mn hnm a a' a'' ha' ha'']
Theorem: Real.sub_le_dist
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : ℝ
⊢ x - y ≤ dist x y
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : ℝ
⊢ x - y ≤ x - y ∨ x - y ≤ -(x - y)
tactic: rw [Real.dist_eq, le_abs]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : ℝ
⊢ x - y ≤ x - y ∨ x - y ≤ -(x - y)
state_after: no goals
tactic: exact Or.inl (le_refl _)
Theorem: Lagrange.interpolate_eq_nodalWeight_mul_nodal_div_X_sub_C
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
j : ι
hj : j ∈ s
⊢ C (r j) * Lagrange.basis s v j = C (nodalWeight s v j) * (nodal s v / (X - C (v j))) * C (r j)
state_after: no goals
tactic: rw [mul_comm, basis_eq_prod_sub_inv_mul_nodal_div hj]
Theorem: IntermediateField.rank_eq_one_iff
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ Module.rank F ↥K = 1 ↔ K = ⊥
state_after: no goals
tactic: rw [← toSubalgebra_eq_iff, ← rank_eq_rank_subalgebra, Subalgebra.rank_eq_one_iff,
    bot_toSubalgebra]
Theorem: Real.abs_cos_eq_sqrt_one_sub_sin_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ |cos x| = √(1 - sin x ^ 2)
state_after: no goals
tactic: rw [← cos_sq', sqrt_sq_eq_abs]
Theorem: LieSubalgebra.ad_comp_incl_eq
File: Mathlib/Algebra/Lie/OfAssociative.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
K : LieSubalgebra R L
x : ↥K
⊢ (ad R L) ↑x ∘ₗ ↑K.incl = ↑K.incl ∘ₗ (ad R ↥K) x
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
K : LieSubalgebra R L
x y : ↥K
⊢ ((ad R L) ↑x ∘ₗ ↑K.incl) y = (↑K.incl ∘ₗ (ad R ↥K) x) y
tactic: ext y
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
K : LieSubalgebra R L
x y : ↥K
⊢ ((ad R L) ↑x ∘ₗ ↑K.incl) y = (↑K.incl ∘ₗ (ad R ↥K) x) y
state_after: no goals
tactic: simp only [ad_apply, LieHom.coe_toLinearMap, LieSubalgebra.coe_incl, LinearMap.coe_comp,
    LieSubalgebra.coe_bracket, Function.comp_apply]
Theorem: IsPathConnected.isConnected
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ IsConnected F
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ ConnectedSpace ↑F
tactic: rw [isConnected_iff_connectedSpace]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : IsPathConnected F
⊢ ConnectedSpace ↑F
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : PathConnectedSpace ↑F
⊢ ConnectedSpace ↑F
tactic: rw [isPathConnected_iff_pathConnectedSpace] at hF
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hF : PathConnectedSpace ↑F
⊢ ConnectedSpace ↑F
state_after: no goals
tactic: exact @PathConnectedSpace.connectedSpace _ _ hF
Theorem: Bifunctor.snd_fst
File: Mathlib/Control/Bifunctor.lean

Proof steps:
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ : Type u₀
β₀ β₁ : Type u₁
f : α₀ → α₁
f' : β₀ → β₁
x : F α₀ β₀
⊢ snd f' (fst f x) = bimap f f' x
state_after: no goals
tactic: simp [snd, bimap_bimap]
Theorem: Real.sin_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ sin (-x) = -sin x
state_after: no goals
tactic: simp [sin, exp_neg, (neg_div _ _).symm, add_mul]
Theorem: CategoryTheory.Limits.isIso_π_of_isTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u
inst✝² : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
⊢ limit.π F j ≫ limit.lift F (coneOfDiagramTerminal I F) = 𝟙 (limit F)
state_after: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u
inst✝² : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramTerminal I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝
tactic: ext
state_before: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u
inst✝² : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramTerminal I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u
inst✝² : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
⊢ limit.lift F (coneOfDiagramTerminal I F) ≫ limit.π F j = 𝟙 (F.obj j)
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Substructure.mem_iInf
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S✝ : L.Substructure M
ι : Sort u_3
S : ι → L.Substructure M
x : M
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: List.cons_merge_cons_pos
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a b : α
s : α → α → Bool
l r : List α
h : s a b = true
⊢ merge s (a :: l) (b :: r) = a :: merge s l (b :: r)
state_after: no goals
tactic: rw [cons_merge_cons, if_pos h]
Theorem: ProbabilityTheory.Indep_iff
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ Indep m₁ m₂ μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ (∀ (t1 t2 : Set Ω), t1 ∈ {s | MeasurableSet s} → t2 ∈ {s | MeasurableSet s} → μ (t1 ∩ t2) = μ t1 * μ t2) ↔
    ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
tactic: rw [Indep_iff_IndepSets, IndepSets_iff]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ (∀ (t1 t2 : Set Ω), t1 ∈ {s | MeasurableSet s} → t2 ∈ {s | MeasurableSet s} → μ (t1 ∩ t2) = μ t1 * μ t2) ↔
    ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Measure.withDensity_rnDeriv_eq_zero
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) = 0 ↔ μ ⟂ₘ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ ν.withDensity (μ.rnDeriv ν) = 0 ↔ μ ⟂ₘ ν
tactic: have h_dec := haveLebesgueDecomposition_add μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ ν.withDensity (μ.rnDeriv ν) = 0 ↔ μ ⟂ₘ ν
state_after: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : ν.withDensity (μ.rnDeriv ν) = 0
⊢ μ ⟂ₘ ν

case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : μ ⟂ₘ ν
⊢ ν.withDensity (μ.rnDeriv ν) = 0
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: AddChar.mulShift_mul
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s : R
⊢ ψ.mulShift r * ψ.mulShift s = ψ.mulShift (r + s)
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ (ψ.mulShift r * ψ.mulShift s) x✝ = (ψ.mulShift (r + s)) x✝
tactic: ext
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ (ψ.mulShift r * ψ.mulShift s) x✝ = (ψ.mulShift (r + s)) x✝
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ (ψ.mulShift r * ψ.mulShift s) x✝ = ψ (r * x✝) * ψ (s * x✝)
tactic: rw [mulShift_apply, right_distrib, map_add_eq_mul]
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ (ψ.mulShift r * ψ.mulShift s) x✝ = ψ (r * x✝) * ψ (s * x✝)
state_after: no goals
tactic: norm_cast