ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matroid.finite_setOf_restriction
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
N M : Matroid α
inst✝ : M.Finite
⊢ {N | N ≤r M} ⊆ (fun R => M ↾ R) '' {b | b ⊆ M.E}
state_after: case intro.intro
α : Type u_1
M✝ : Matroid α
R✝ I J X Y : Set α
N M : Matroid α
inst✝ : M.Finite
R : Set α
hR : R ⊆ M.E
⊢ M ↾ R ∈ (fun R => M ↾ R) '' {b | b ⊆ M.E}
tactic: rintro _ ⟨R, hR, rfl⟩
state_before: case intro.intro
α : Type u_1
M✝ : Matroid α
R✝ I J X Y : Set α
N M : Matroid α
inst✝ : M.Finite
R : Set α
hR : R ⊆ M.E
⊢ M ↾ R ∈ (fun R => M ↾ R) '' {b | b ⊆ M.E}
state_after: no goals
tactic: exact ⟨_, hR, rfl⟩
Theorem: WittVector.FractionRing.p_nonzero
File: Mathlib/RingTheory/WittVector/Identities.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : Nontrivial R
inst✝ : CharP R p
⊢ ↑p ≠ 0
state_after: no goals
tactic: simpa using (IsFractionRing.injective (𝕎 R) (FractionRing (𝕎 R))).ne (WittVector.p_nonzero _ _)
Theorem: AddSubmonoid.LocalizationMap.add_neg_right
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
w z : N
⊢ z = w * ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ ↔ z * f ↑y = w
state_after: no goals
tactic: rw [eq_comm, mul_inv_left h, mul_comm, eq_comm]
Theorem: LinearPMap.left_le_sup
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
⊢ f ≤ f.sup g h
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ = ↑(f.sup g h) z₂
tactic: refine ⟨le_sup_left, fun z₁ z₂ hz => ?_⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ + ↑g 0 = ↑(f.sup g h) z₂
tactic: rw [← add_zero (f _), ← g.map_zero]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ + ↑g 0 = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑z₁ + ↑0 = ↑z₂
tactic: refine (sup_apply h _ _ _ ?_).symm
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑z₁ + ↑0 = ↑z₂
state_after: no goals
tactic: simpa
Theorem: EReal.coe_toReal
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : EReal
hx : x ≠ ⊤
h'x : x ≠ ⊥
⊢ ↑x.toReal = x
state_after: case intro
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
⊢ ↑(↑x).toReal = ↑x
tactic: lift x to ℝ using ⟨hx, h'x⟩
state_before: case intro
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
⊢ ↑(↑x).toReal = ↑x
state_after: no goals
tactic: rfl
Theorem: HurwitzZeta.hurwitzZeta_zero
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: ⊢ hurwitzZeta 0 = riemannZeta
state_after: case h
s : ℂ
⊢ hurwitzZeta 0 s = riemannZeta s
tactic: ext1 s
state_before: case h
s : ℂ
⊢ hurwitzZeta 0 s = riemannZeta s
state_after: no goals
tactic: simpa [hurwitzZeta, hurwitzZetaEven_zero] using hurwitzZetaOdd_neg 0 s
Theorem: tsum_subtype
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∏' (x : ↑s), f ↑x = ∏' (x : β), s.mulIndicator f x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b
tactic: rw [← tprod_subtype_eq_of_mulSupport_subset Set.mulSupport_mulIndicator_subset, tprod_congr]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b
state_after: no goals
tactic: simp
Theorem: FractionalIdeal.spanSingleton_le_iff_mem
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x : P
I : FractionalIdeal S P
⊢ spanSingleton S x ≤ I ↔ x ∈ I
state_after: no goals
tactic: rw [← coe_le_coe, coe_spanSingleton, Submodule.span_singleton_le_iff_mem, mem_coe]
Theorem: List.ofFn_congr
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
m n : ℕ
h : m = n
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)
state_after: α : Type u
m : ℕ
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)
tactic: subst h
state_before: α : Type u
m : ℕ
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)
state_after: no goals
tactic: simp_rw [Fin.cast_refl, id]
Theorem: WeierstrassCurve.Affine.baseChange_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
⊢ (baseChange W B).toAffine.polynomialY = Polynomial.map (mapRingHom ↑f) (baseChange W A).toAffine.polynomialY
state_after: no goals
tactic: rw [← map_polynomialY, map_baseChange]
Theorem: MeasureTheory.SimpleFunc.integrable_pair
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
f : α →ₛ E
g : α →ₛ F
⊢ Integrable (↑f) μ → Integrable (↑g) μ → Integrable (↑(f.pair g)) μ
state_after: no goals
tactic: simpa only [integrable_iff_finMeasSupp] using FinMeasSupp.pair
Theorem: mem_perms_of_finset_iff
File: Mathlib/Data/Fintype/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∀ {s : Finset α} {f : Equiv.Perm α}, f ∈ permsOfFinset s ↔ ∀ {x : α}, f x ≠ x → x ∈ s
state_after: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
val✝ : Multiset α
l : List α
hs : Multiset.Nodup (Quot.mk Setoid.r l)
f : Equiv.Perm α
⊢ f ∈ permsOfFinset { val := Quot.mk Setoid.r l, nodup := hs } ↔
    ∀ {x : α}, f x ≠ x → x ∈ { val := Quot.mk Setoid.r l, nodup := hs }
tactic: rintro ⟨⟨l⟩, hs⟩ f
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
val✝ : Multiset α
l : List α
hs : Multiset.Nodup (Quot.mk Setoid.r l)
f : Equiv.Perm α
⊢ f ∈ permsOfFinset { val := Quot.mk Setoid.r l, nodup := hs } ↔
    ∀ {x : α}, f x ≠ x → x ∈ { val := Quot.mk Setoid.r l, nodup := hs }
state_after: no goals
tactic: exact mem_permsOfList_iff
Theorem: CategoryTheory.kernel_zero_of_nonzero_from_simple
File: Mathlib/CategoryTheory/Simple.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
⊢ kernel.ι f = 0
state_after: no goals
tactic: classical
    by_contra h
    haveI := isIso_of_mono_of_nonzero h
    exact w (eq_zero_of_epi_kernel f)
Theorem: ProbabilityTheory.Kernel.indep_bot_right
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
⊢ Indep m' ⊥ κ μ
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t ∈ {s | MeasurableSet s}
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t
tactic: intros s t _ ht
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t ∈ {s | MeasurableSet s}
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t = ∅ ∨ t = Set.univ
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t
tactic: rw [Set.mem_setOf_eq, MeasurableSpace.measurableSet_bot_iff] at ht
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t = ∅ ∨ t = Set.univ
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t = ∅ ∨ t = Set.univ
a : α
⊢ (κ a) (s ∩ t) = (κ a) s * (κ a) t
tactic: refine Filter.eventually_of_forall (fun a ↦ ?_)
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
ht : t = ∅ ∨ t = Set.univ
a : α
⊢ (κ a) (s ∩ t) = (κ a) s * (κ a) t
state_after: case inl
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
a : α
ht : t = ∅
⊢ (κ a) (s ∩ t) = (κ a) s * (κ a) t

case inr
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m' _mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s t : Set Ω
a✝ : s ∈ {s | MeasurableSet s}
a : α
ht : t = Set.univ
⊢ (κ a) (s ∩ t) = (κ a) s * (κ a) t
tactic: cases' ht with ht ht
Theorem: orderEmbeddingOfInjective_apply
File: Mathlib/Order/Hom/Lattice.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : SemilatticeInf α
inst✝¹ : SemilatticeInf β
f : F
inst✝ : InfHomClass F α β
hf : Injective ⇑f
x y : α
⊢ f x ≤ f y ↔ x ≤ y
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : SemilatticeInf α
inst✝¹ : SemilatticeInf β
f : F
inst✝ : InfHomClass F α β
hf : Injective ⇑f
x y : α
h : f x ≤ f y
⊢ x ≤ y
tactic: refine ⟨fun h ↦ ?_, fun h ↦ OrderHomClass.mono f h⟩
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : SemilatticeInf α
inst✝¹ : SemilatticeInf β
f : F
inst✝ : InfHomClass F α β
hf : Injective ⇑f
x y : α
h : f x ≤ f y
⊢ x ≤ y
state_after: no goals
tactic: rwa [← inf_eq_left, ← hf.eq_iff, map_inf, inf_eq_left]
Theorem: isAddRegular_add_and_add_iff
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
⊢ IsRegular (a * b) ∧ IsRegular (b * a) ↔ IsRegular a ∧ IsRegular b
state_after: case refine_1
R : Type u_1
inst✝ : Semigroup R
a b : R
⊢ IsRegular (a * b) ∧ IsRegular (b * a) → IsRegular a ∧ IsRegular b

case refine_2
R : Type u_1
inst✝ : Semigroup R
a b : R
⊢ IsRegular a ∧ IsRegular b → IsRegular (a * b) ∧ IsRegular (b * a)
tactic: refine ⟨?_, ?_⟩
Theorem: List.drop_take_succ_join_eq_get
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ drop (take (↑i) (map length L)).sum (take (take (↑i + 1) (map length L)).sum L.join) = L.get i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ L[↑i] = L.get i
tactic: rw [drop_take_succ_join_eq_getElem _ _ i.2]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ L[↑i] = L.get i
state_after: no goals
tactic: simp
Theorem: Nat.add_mod_eq_add_mod_left
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
H : a % d = b % d
⊢ (c + a) % d = (c + b) % d
state_after: no goals
tactic: rw [Nat.add_comm, add_mod_eq_add_mod_right _ H, Nat.add_comm]
Theorem: ProbabilityTheory.Kernel.IndepSets.indep_aux
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m₂ m : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
p1 p2 : Set (Set Ω)
h2 : m₂ ≤ m
hp2 : IsPiSystem p2
hpm2 : m₂ = generateFrom p2
hyp : IndepSets p1 p2 κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ p1
ht1m : MeasurableSet t1
ht2m : MeasurableSet t2
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
state_after: case refine_1
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m₂ m : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
p1 p2 : Set (Set Ω)
h2 : m₂ ≤ m
hp2 : IsPiSystem p2
hpm2 : m₂ = generateFrom p2
hyp : IndepSets p1 p2 κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ p1
ht1m : MeasurableSet t1
ht2m : MeasurableSet t2
⊢ (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) ∅

case refine_2
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m₂ m : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
p1 p2 : Set (Set Ω)
h2 : m₂ ≤ m
hp2 : IsPiSystem p2
hpm2 : m₂ = generateFrom p2
hyp : IndepSets p1 p2 κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ p1
ht1m : MeasurableSet t1
ht2m : MeasurableSet t2
⊢ ∀ t ∈ p2, (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) t

case refine_3
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m₂ m : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
p1 p2 : Set (Set Ω)
h2 : m₂ ≤ m
hp2 : IsPiSystem p2
hpm2 : m₂ = generateFrom p2
hyp : IndepSets p1 p2 κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ p1
ht1m : MeasurableSet t1
ht2m : MeasurableSet t2
⊢ ∀ (t : Set Ω),
    MeasurableSet t →
      (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) t →
        (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) tᶜ

case refine_4
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
m₂ m : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
p1 p2 : Set (Set Ω)
h2 : m₂ ≤ m
hp2 : IsPiSystem p2
hpm2 : m₂ = generateFrom p2
hyp : IndepSets p1 p2 κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ p1
ht1m : MeasurableSet t1
ht2m : MeasurableSet t2
⊢ ∀ (f : ℕ → Set Ω),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) →
        (∀ (i : ℕ), (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) (f i)) →
          (fun t => ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t) = (κ a) t1 * (κ a) t) (⋃ i, f i)
tactic: refine @induction_on_inter _ (fun t ↦ ∀ᵐ a ∂μ, κ a (t1 ∩ t) = κ a t1 * κ a t) _
    m₂ hpm2 hp2 ?_ ?_ ?_ ?_ t2 ht2m
Theorem: NNReal.toNNReal_coe_nat
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
n : ℕ
⊢ ↑(↑n).toNNReal = ↑↑n
state_after: no goals
tactic: simp [Real.coe_toNNReal]
Theorem: approxOrderOf.smul_subset_of_coprime
File: Mathlib/NumberTheory/WellApproximable.lean

Proof steps:
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
⊢ a • approxOrderOf A n δ ⊆ approxOrderOf A (orderOf a * n) δ
state_after: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
⊢ ⋃ i, ⋃ (_ : orderOf i = n), ball (a * i) δ ⊆ ⋃ x, ⋃ (_ : orderOf x = orderOf a * n), ball x δ
tactic: simp_rw [approxOrderOf, thickening_eq_biUnion_ball, ← image_smul, image_iUnion₂, image_smul,
    smul_ball'', smul_eq_mul, mem_setOf_eq]
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
⊢ ⋃ i, ⋃ (_ : orderOf i = n), ball (a * i) δ ⊆ ⋃ x, ⋃ (_ : orderOf x = orderOf a * n), ball x δ
state_after: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ c ∈ ⋃ x, ⋃ (_ : orderOf x = orderOf a * n), ball x δ
tactic: refine iUnion₂_subset_iff.mpr fun b hb c hc => ?_
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ c ∈ ⋃ x, ⋃ (_ : orderOf x = orderOf a * n), ball x δ
state_after: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ ∃ i, orderOf i = orderOf a * n ∧ c ∈ ball i δ
tactic: simp only [mem_iUnion, exists_prop]
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ ∃ i, orderOf i = orderOf a * n ∧ c ∈ ball i δ
state_after: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ orderOf (a * b) = orderOf a * n
tactic: refine ⟨a * b, ?_, hc⟩
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
han : (orderOf a).Coprime n
b : A
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ orderOf (a * b) = orderOf a * n
state_after: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
b : A
han : (orderOf a).Coprime (orderOf b)
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ orderOf (a * b) = orderOf a * orderOf b
tactic: rw [← hb] at han ⊢
state_before: A : Type u_1
inst✝ : SeminormedCommGroup A
a : A
m n : ℕ
δ : ℝ
b : A
han : (orderOf a).Coprime (orderOf b)
hb : orderOf b = n
c : A
hc : c ∈ ball (a * b) δ
⊢ orderOf (a * b) = orderOf a * orderOf b
state_after: no goals
tactic: exact (Commute.all a b).orderOf_mul_eq_mul_orderOf_of_coprime han
Theorem: eq_affineCombination_of_mem_affineSpan_of_fintype
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p1 : P
p : ι → P
h : p1 ∈ affineSpan k (Set.range p)
⊢ ∃ w, ∑ i : ι, w i = 1 ∧ p1 = (Finset.affineCombination k Finset.univ p) w
state_after: no goals
tactic: classical
    obtain ⟨s, w, hw, rfl⟩ := eq_affineCombination_of_mem_affineSpan h
    refine
      ⟨(s : Set ι).indicator w, ?_, Finset.affineCombination_indicator_subset w p s.subset_univ⟩
    simp only [Finset.mem_coe, Set.indicator_apply, ← hw]
    rw [Fintype.sum_extend_by_zero s w]
Theorem: Ordinal.one_out_eq
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
x : (Quotient.out 1).α
⊢ 0 < type fun x x_1 => x < x_1
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.opEquivalence_unitIso
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
⊢ (opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X) =
    𝟙 ((opFunctor V c).obj X)
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ ((opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X)).f i✝ =
    (𝟙 ((opFunctor V c).obj X)).f i✝
tactic: ext
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ ((opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X)).f i✝ =
    (𝟙 ((opFunctor V c).obj X)).f i✝
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ (Iso.refl ((unop X).op.unopSymm.X i✝)).hom.op ≫
      (Iso.refl (((opInverse V c ⋙ opFunctor V c).obj ((opFunctor V c).obj X)).X i✝)).hom =
    (𝟙 ((opFunctor V c).obj X)).f i✝
tactic: simp only [opUnitIso, opCounitIso, NatIso.ofComponents_hom_app, Iso.op_hom, comp_f,
      opFunctor_map_f, Quiver.Hom.unop_op, Hom.isoOfComponents_hom_f]
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ (Iso.refl ((unop X).op.unopSymm.X i✝)).hom.op ≫
      (Iso.refl (((opInverse V c ⋙ opFunctor V c).obj ((opFunctor V c).obj X)).X i✝)).hom =
    (𝟙 ((opFunctor V c).obj X)).f i✝
state_after: no goals
tactic: exact Category.comp_id _
Theorem: Multiset.trop_inf
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Multiset R
⊢ trop s.inf = (map trop s).sum
state_after: case empty
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
⊢ trop (inf 0) = (map trop 0).sum

case cons
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : R
x : Multiset R
IH : trop x.inf = (map trop x).sum
⊢ trop (s ::ₘ x).inf = (map trop (s ::ₘ x)).sum
tactic: induction' s using Multiset.induction with s x IH