ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: TensorProduct.map_smul_right
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ map f (r • g) = r • map f g
state_after: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (r • g))) x✝¹) x✝ = (((mk R M N).compr₂ (r • map f g)) x✝¹) x✝
tactic: ext
state_before: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (r • g))) x✝¹) x✝ = (((mk R M N).compr₂ (r • map f g)) x✝¹) x✝
state_after: no goals
tactic: simp only [smul_tmul, compr₂_apply, mk_apply, map_tmul, smul_apply, tmul_smul]
Theorem: LowerSet.compl_sSup
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : LowerSet α
a : α
S : Set (LowerSet α)
⊢ ↑(sSup S).compl = ↑(⨆ s ∈ S, s.compl)
state_after: no goals
tactic: simp only [coe_compl, coe_sSup, compl_iUnion₂, UpperSet.coe_iSup₂]
Theorem: List.count_replicate
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
n : Nat
⊢ count a (replicate n b) = if a = b then n else 0
state_after: case isTrue
α : Type u_1
inst✝ : DecidableEq α
a b : α
n : Nat
h✝ : a = b
⊢ count a (replicate n b) = n

case isFalse
α : Type u_1
inst✝ : DecidableEq α
a b : α
n : Nat
h✝ : ¬a = b
⊢ count a (replicate n b) = 0
tactic: split
state_before: case isTrue
α : Type u_1
inst✝ : DecidableEq α
a b : α
n : Nat
h✝ : a = b
⊢ count a (replicate n b) = n

case isFalse
α : Type u_1
inst✝ : DecidableEq α
a b : α
n : Nat
h✝ : ¬a = b
⊢ count a (replicate n b) = 0
state_after: no goals
tactic: exacts [‹a = b› ▸ count_replicate_self .., count_eq_zero.2 <| mt eq_of_mem_replicate ‹a ≠ b›]
Theorem: PowerBasis.natDegree_minpoly
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ (minpoly A pb.gen).natDegree = pb.dim
state_after: no goals
tactic: rw [← minpolyGen_eq, natDegree_minpolyGen]
Theorem: Subalgebra.range_comp_val
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
⊢ (f.comp S.val).range = map f S
state_after: no goals
tactic: rw [AlgHom.range_comp, range_val]
Theorem: MeasureTheory.toFinite_apply
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ μ.toFinite s = (μ.toFiniteAux Set.univ)⁻¹ * μ.toFiniteAux s
state_after: no goals
tactic: rw [Measure.toFinite, ProbabilityTheory.cond_apply _ MeasurableSet.univ, Set.univ_inter]
Theorem: same_sub_div
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionRing K
a✝ b✝ c d a b : K
h : b ≠ 0
⊢ (b - a) / b = 1 - a / b
state_after: no goals
tactic: simpa only [← @div_self _ _ b h] using (div_sub_div_same b a b).symm
Theorem: Polynomial.nextCoeff_eq_zero_of_eraseLead_eq_zero
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
⊢ f.nextCoeff = 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
h₂ : ¬f.nextCoeff = 0
⊢ False
tactic: by_contra h₂
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
h₂ : ¬f.nextCoeff = 0
⊢ False
state_after: no goals
tactic: exact leadingCoeff_ne_zero.mp (leadingCoeff_eraseLead_eq_nextCoeff h₂ ▸ h₂) h
Theorem: StrictMono.sign_comp
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝⁶ : Zero α
inst✝⁵ : LinearOrder α
a✝ : α
β : Type u_2
F : Type u_3
inst✝⁴ : Zero β
inst✝³ : Preorder β
inst✝² : DecidableRel fun x x_1 => x < x_1
inst✝¹ : FunLike F α β
inst✝ : ZeroHomClass F α β
f : F
hf : StrictMono ⇑f
a : α
⊢ sign (f a) = sign a
state_after: no goals
tactic: simp only [sign_apply, ← map_zero f, hf.lt_iff_lt]
Theorem: Matrix.map_id
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
M : Matrix m n α
⊢ M.map id = M
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
M : Matrix m n α
i✝ : m
j✝ : n
⊢ M.map id i✝ j✝ = M i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
M : Matrix m n α
i✝ : m
j✝ : n
⊢ M.map id i✝ j✝ = M i✝ j✝
state_after: no goals
tactic: rfl
Theorem: DFinsupp.single_apply
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (single i b) i' = if h : i = i' then Eq.recOn h b else 0
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (if h : i' = i then ⋯ ▸ b else 0 i') = if h : i = i' then Eq.recOn h b else 0
tactic: rw [single_eq_pi_single, Pi.single, Function.update]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (if h : i' = i then ⋯ ▸ b else 0 i') = if h : i = i' then Eq.recOn h b else 0
state_after: no goals
tactic: simp [@eq_comm _ i i']
Theorem: Submodule.inf_genEigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

Proof steps:
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
k : ℕ
μ : R
hfp : ∀ x ∈ p, f x ∈ p
⊢ p ⊓ (f.genEigenspace μ) k = Submodule.map p.subtype ((genEigenspace (LinearMap.restrict f hfp) μ) k)
state_after: no goals
tactic: rw [f.genEigenspace_restrict _ _ _ hfp, Submodule.map_comap_eq, Submodule.range_subtype]
Theorem: LucasLehmer.X.card_units_lt
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: q : ℕ+
w : 1 < q
⊢ Fintype.card (X q)ˣ < ↑q ^ 2
state_after: q : ℕ+
w : 1 < q
this : Fact (1 < ↑q)
⊢ Fintype.card (X q)ˣ < ↑q ^ 2
tactic: have : Fact (1 < (q : ℕ)) := ⟨w⟩
state_before: q : ℕ+
w : 1 < q
this : Fact (1 < ↑q)
⊢ Fintype.card (X q)ˣ < ↑q ^ 2
state_after: case h.e'_4
q : ℕ+
w : 1 < q
this : Fact (1 < ↑q)
⊢ ↑q ^ 2 = Fintype.card (X q)
tactic: convert card_units_lt (X q)
state_before: case h.e'_4
q : ℕ+
w : 1 < q
this : Fact (1 < ↑q)
⊢ ↑q ^ 2 = Fintype.card (X q)
state_after: no goals
tactic: rw [card_eq]
Theorem: Fintype.card_filter_piFinset_eq
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
⊢ (filter (fun f => f i = a) (piFinset s)).card = if a ∈ s i then ∏ b ∈ univ.erase i, (s b).card else 0
state_after: case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
h : a ∈ s i
⊢ (filter (fun f => f i = a) (piFinset s)).card = ∏ b ∈ univ.erase i, (s b).card

case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
h : a ∉ s i
⊢ (filter (fun f => f i = a) (piFinset s)).card = 0
tactic: split_ifs with h
Theorem: HomogeneousLocalization.val_add
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ (Quotient.mk'' y1 + Quotient.mk'' y2).val = val (Quotient.mk'' y1) + val (Quotient.mk'' y2)
state_after: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 + y2).num ⟨↑(y1 + y2).den, ⋯⟩ =
    Localization.mk (↑⟨↑y1.den, ⋯⟩ * ↑y2.num + ↑⟨↑y2.den, ⋯⟩ * ↑y1.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)
tactic: rw [← mk_add, val_mk, val_mk, val_mk, Localization.add_mk]
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 + y2).num ⟨↑(y1 + y2).den, ⋯⟩ =
    Localization.mk (↑⟨↑y1.den, ⋯⟩ * ↑y2.num + ↑⟨↑y2.den, ⋯⟩ * ↑y1.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)
state_after: no goals
tactic: rfl
Theorem: Int.eq_pow_of_mul_eq_pow_odd_left
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
⊢ ∃ d, a = d ^ k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : Associated (d ^ k) a
⊢ ∃ d, a = d ^ k
tactic: obtain ⟨d, hd⟩ := exists_associated_pow_of_mul_eq_pow' hab h
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : Associated (d ^ k) a
⊢ ∃ d, a = d ^ k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : Associated a (d ^ k)
⊢ ∃ d, a = d ^ k
tactic: replace hd := hd.symm
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : Associated a (d ^ k)
⊢ ∃ d, a = d ^ k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : a = d ^ k ∨ a = (-d) ^ k
⊢ ∃ d, a = d ^ k
tactic: rw [associated_iff_natAbs, natAbs_eq_natAbs_iff, ← hk.neg_pow] at hd
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
d : ℤ
hd : a = d ^ k ∨ a = (-d) ^ k
⊢ ∃ d, a = d ^ k
state_after: no goals
tactic: obtain rfl | rfl := hd <;> exact ⟨_, rfl⟩
Theorem: Frm.Iso.mk_hom_toFun
File: Mathlib/Order/Category/Frm.lean

Proof steps:
state_before: α β : Frm
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
      { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } =
    𝟙 α
state_after: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 α) x✝
tactic: ext
state_before: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : Frm
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
      { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } =
    𝟙 β
state_after: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 β) x✝
tactic: ext
state_before: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: ProbabilityTheory.Kernel.IndepSets.bUnion
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
⊢ IndepSets (⋃ n ∈ u, s n) s' κ μ
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ ⋃ n ∈ u, s n
ht2 : t2 ∈ s'
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
tactic: intro t1 t2 ht1 ht2
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ ⋃ n ∈ u, s n
ht2 : t2 ∈ s'
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht2 : t2 ∈ s'
ht1 : ∃ i, ∃ (_ : i ∈ u), t1 ∈ s i
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
tactic: simp_rw [Set.mem_iUnion] at ht1
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht2 : t2 ∈ s'
ht1 : ∃ i, ∃ (_ : i ∈ u), t1 ∈ s i
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
state_after: case intro.intro
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht2 : t2 ∈ s'
n : ι
hpn : n ∈ u
ht1 : t1 ∈ s n
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
tactic: rcases ht1 with ⟨n, hpn, ht1⟩
state_before: case intro.intro
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → Set (Set Ω)
s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
u : Set ι
hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ
t1 t2 : Set Ω
ht2 : t2 ∈ s'
n : ι
hpn : n ∈ u
ht1 : t1 ∈ s n
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
state_after: no goals
tactic: exact hyp n hpn t1 t2 ht1 ht2
Theorem: ae_not_liouville
File: Mathlib/NumberTheory/Liouville/Measure.lean

Proof steps:
state_before: x : ℝ
h₁ : ∀ p > 2, ¬LiouvilleWith p x
h₂ : Liouville x
⊢ 3 > 2
state_after: no goals
tactic: norm_num
Theorem: PadicSeq.norm_eq
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : f ≈ 0
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : f ≈ 0
hg : g ≈ 0
⊢ f.norm = g.norm
tactic: have hg : g ≈ 0 := equiv_zero_of_val_eq_of_equiv_zero h hf
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : f ≈ 0
hg : g ≈ 0
⊢ f.norm = g.norm
state_after: no goals
tactic: simp only [hf, hg, norm, dif_pos]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ f.norm = g.norm
tactic: have hg : ¬g ≈ 0 := fun hg ↦
      hf <| equiv_zero_of_val_eq_of_equiv_zero (by simp only [h, forall_const, eq_self_iff_true]) hg
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ padicNorm p (↑f (stationaryPoint ⋯)) = padicNorm p (↑g (stationaryPoint ⋯))
tactic: simp only [hg, hf, norm, dif_neg, not_false_iff]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ padicNorm p (↑f (stationaryPoint ⋯)) = padicNorm p (↑g (stationaryPoint ⋯))
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
i : ℕ := max (stationaryPoint hf) (stationaryPoint hg)
⊢ padicNorm p (↑f (stationaryPoint ⋯)) = padicNorm p (↑g (stationaryPoint ⋯))
tactic: let i := max (stationaryPoint hf) (stationaryPoint hg)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : ¬f ≈ 0
hg : ¬g ≈ 0
i : ℕ := max (stationaryPoint hf) (stationaryPoint hg)
hpf : padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑f i)
hpg : padicNorm p (↑g (stationaryPoint hg)) = padicNorm p (↑g i)
⊢ padicNorm p (↑f (stationaryPoint ⋯)) = padicNorm p (↑g (stationaryPoint ⋯))
state_after: no goals
tactic: rw [hpf, hpg, h]
Theorem: PartitionOfUnity.eventually_fintsupport_subset
File: Mathlib/Topology/PartitionOfUnity.lean

Proof steps:
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ : X
⊢ ∀ᶠ (y : X) in 𝓝 x₀, ρ.fintsupport y ⊆ ρ.fintsupport x₀
state_after: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ : X
⊢ ∀ (x : X),
    {i | x ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))} → ρ.fintsupport x ⊆ ρ.fintsupport x₀
tactic: apply (ρ.locallyFinite.closure.eventually_subset (fun _ ↦ isClosed_closure) x₀).mono
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ : X
⊢ ∀ (x : X),
    {i | x ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))} → ρ.fintsupport x ⊆ ρ.fintsupport x₀
state_after: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ y : X
hy : {i | y ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))}
z : ι
hz : z ∈ ρ.fintsupport y
⊢ z ∈ ρ.fintsupport x₀
tactic: intro y hy z hz
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ y : X
hy : {i | y ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))}
z : ι
hz : z ∈ ρ.fintsupport y
⊢ z ∈ ρ.fintsupport x₀
state_after: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ y : X
hy : {i | y ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))}
z : ι
hz : y ∈ tsupport ⇑(ρ z)
⊢ x₀ ∈ tsupport ⇑(ρ z)
tactic: rw [PartitionOfUnity.mem_fintsupport_iff] at *
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀ y : X
hy : {i | y ∈ closure (support ⇑(ρ i))} ⊆ {i | x₀ ∈ closure (support ⇑(ρ i))}
z : ι
hz : y ∈ tsupport ⇑(ρ z)
⊢ x₀ ∈ tsupport ⇑(ρ z)
state_after: no goals
tactic: exact hy hz
Theorem: Orientation.sin_oangle_sub_left_mul_norm_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x - y) x).sin * ‖x - y‖ = ‖y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin * ‖x - y‖ = ‖y‖
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).sin * ‖x - y‖ = ‖y‖
state_after: no goals
tactic: exact (-o).sin_oangle_sub_right_mul_norm_of_oangle_eq_pi_div_two h