ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Action.functorCategoryMonoidalEquivalence.ε_app
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (Monoidal.fromTransported (functorCategoryEquivalence V G).symm).ε.app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
tactic: dsimp only [functorCategoryMonoidalEquivalence]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (Monoidal.fromTransported (functorCategoryEquivalence V G).symm).ε.app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ ((functorCategoryEquivalence V G).symm.unitIso.hom.app (𝟙_ (SingleObj ↑G ⥤ V))).app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
tactic: simp only [Monoidal.fromTransported_toLaxMonoidalFunctor_ε]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ ((functorCategoryEquivalence V G).symm.unitIso.hom.app (𝟙_ (SingleObj ↑G ⥤ V))).app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
state_after: no goals
tactic: rfl
Theorem: span_gcd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ Ideal.span {gcd x y} = Ideal.span {x, y}
state_after: no goals
tactic: rw [← IsBezout.span_gcd, IsBezout.span_gcd_eq_span_gcd]
Theorem: AbstractCompletion.uniformContinuous_extend
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

Proof steps:
state_before: α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
⊢ UniformContinuous (pkg.extend f)
state_after: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (pkg.extend f)

case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (pkg.extend f)
tactic: by_cases hf : UniformContinuous f
Theorem: IsAlgebraic.algebraMap
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : Algebra R S
inst✝¹ : Algebra S A
inst✝ : IsScalarTower R S A
a : S
x✝ : IsAlgebraic R a
f : R[X]
hf₁ : f ≠ 0
hf₂ : (aeval a) f = 0
⊢ (aeval ((algebraMap S A) a)) f = 0
state_after: no goals
tactic: rw [aeval_algebraMap_apply, hf₂, map_zero]
Theorem: Finset.ruzsa_triangle_inequality_mul_mul_div
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C).card * B.card ≤ (A * B).card * (B / C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C⁻¹).card * B.card ≤ (A * B).card * (B * C⁻¹).card
tactic: rw [← div_inv_eq_mul, div_eq_mul_inv B]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C⁻¹).card * B.card ≤ (A * B).card * (B * C⁻¹).card
state_after: no goals
tactic: exact ruzsa_triangle_inequality_div_mul_mul _ _ _
Theorem: FirstOrder.Language.BoundedFormula.not_all_isQF
File: Mathlib/ModelTheory/Complexity.lean

Proof steps:
state_before: L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∀'φ).IsQF
⊢ False
state_after: case of_isAtomic
L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∀'φ).IsAtomic
⊢ False
tactic: cases' con with _ con
state_before: case of_isAtomic
L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∀'φ).IsAtomic
⊢ False
state_after: no goals
tactic: exact φ.not_all_isAtomic con
Theorem: Bornology.isBounded_prod_self
File: Mathlib/Topology/Bornology/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
s : Set α
t : Set β
S : (i : ι) → Set (π i)
⊢ IsBounded (s ×ˢ s) ↔ IsBounded s
state_after: case inl
α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
t : Set β
S : (i : ι) → Set (π i)
⊢ IsBounded (∅ ×ˢ ∅) ↔ IsBounded ∅

case inr
α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
s : Set α
t : Set β
S : (i : ι) → Set (π i)
hs : s.Nonempty
⊢ IsBounded (s ×ˢ s) ↔ IsBounded s
tactic: rcases s.eq_empty_or_nonempty with (rfl | hs)
state_before: case inr
α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
s : Set α
t : Set β
S : (i : ι) → Set (π i)
hs : s.Nonempty
⊢ IsBounded (s ×ˢ s) ↔ IsBounded s
state_after: no goals
tactic: exact (isBounded_prod_of_nonempty (hs.prod hs)).trans and_self_iff
Theorem: EuclideanSpace.volume_closedBall
File: Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean

Proof steps:
state_before: ι : Type u_1
inst✝¹ : Nonempty ι
inst✝ : Fintype ι
x : EuclideanSpace ℝ ι
r : ℝ
⊢ volume (Metric.closedBall x r) = ENNReal.ofReal r ^ card ι * ENNReal.ofReal (√π ^ card ι / Gamma (↑(card ι) / 2 + 1))
state_after: no goals
tactic: rw [addHaar_closedBall_eq_addHaar_ball, EuclideanSpace.volume_ball]
Theorem: Matroid.setOf_basis_eq
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
B I J X Y : Set α
e : α
M : Matroid α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ {I | M.Basis I X} = maximals (fun x x_1 => x ⊆ x_1) ({I | M.Indep I} ∩ Iic X)
state_after: case h
α : Type u_1
M✝ : Matroid α
B I✝ J X Y : Set α
e : α
M : Matroid α
hX : autoParam (X ⊆ M.E) _auto✝
I : Set α
⊢ I ∈ {I | M.Basis I X} ↔ I ∈ maximals (fun x x_1 => x ⊆ x_1) ({I | M.Indep I} ∩ Iic X)
tactic: ext I
state_before: case h
α : Type u_1
M✝ : Matroid α
B I✝ J X Y : Set α
e : α
M : Matroid α
hX : autoParam (X ⊆ M.E) _auto✝
I : Set α
⊢ I ∈ {I | M.Basis I X} ↔ I ∈ maximals (fun x x_1 => x ⊆ x_1) ({I | M.Indep I} ∩ Iic X)
state_after: no goals
tactic: simp [Matroid.Basis, maximals, iff_true_intro hX]
Theorem: jacobiSym.quadratic_reciprocity_if
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: case inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha1 : a % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

case inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
tactic: rcases Nat.odd_mod_four_iff.mp ha2 with ha1 | ha3
state_before: case inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: case inr.inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb1 : b % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

case inr.inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb3 : b % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
tactic: rcases Nat.odd_mod_four_iff.mp hb2 with hb1 | hb3
state_before: case inr.inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb3 : b % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: no goals
tactic: simpa [ha3, hb3] using (jacobiSym.quadratic_reciprocity_three_mod_four ha3 hb3).symm
Theorem: PartialEquiv.refl_prod_refl
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
⊢ (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β)
state_after: no goals
tactic: ext ⟨x, y⟩ <;> simp
Theorem: continuousWithinAt_Ioc_iff_Ioi
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIciTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Ioc a b) a ↔ ContinuousWithinAt f (Ioi a) a
state_after: no goals
tactic: simp only [ContinuousWithinAt, nhdsWithin_Ioc_eq_nhdsWithin_Ioi h]
Theorem: jacobiTheta₂_fderiv_undef
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
hτ : τ.im ≤ 0
⊢ jacobiTheta₂_fderiv z τ = 0
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂_term_fderiv b z τ
tactic: apply tsum_eq_zero_of_not_summable
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂_term_fderiv b z τ
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
tactic: rw [summable_jacobiTheta₂_term_fderiv_iff]
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
state_after: no goals
tactic: exact not_lt.mpr hτ
Theorem: Ordnode.delta_lt_false
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
a b : ℕ
h₁ : delta * a < b
h₂ : delta * b < a
⊢ 0 < delta
state_after: no goals
tactic: decide
state_before: α : Type u_1
a b : ℕ
h₁ : delta * a < b
h₂ : delta * b < a
⊢ a ≤ delta * (delta * a)
state_after: no goals
tactic: simpa [mul_assoc] using Nat.mul_le_mul_right a (by decide : 1 ≤ delta * delta)
Theorem: Matrix.det_eq_of_eq_mul_det_one
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B C : Matrix n n R
hC : C.det = 1
hA : A = B * C
⊢ B.det * C.det = B.det
state_after: no goals
tactic: rw [hC, mul_one]
Theorem: Function.Periodic.const_inv_smul
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
state_after: no goals
tactic: simpa only [inv_inv] using h.const_smul a⁻¹
Theorem: Function.Injective.smulCommClass
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝⁴ : SMul M α
inst✝³ : SMul N α
inst✝² : SMul M β
inst✝¹ : SMul N β
inst✝ : SMulCommClass M N β
f : α → β
hf : Injective f
h₁ : ∀ (c : M) (x : α), f (c • x) = c • f x
h₂ : ∀ (c : N) (x : α), f (c • x) = c • f x
c₁ : M
c₂ : N
x : α
⊢ f (c₁ • c₂ • x) = f (c₂ • c₁ • x)
state_after: no goals
tactic: simp only [h₁, h₂, smul_comm c₁ c₂ (f x)]
Theorem: TopCat.isoOfHomeo_hom
File: Mathlib/Topology/Category/TopCat/Basic.lean

Proof steps:
state_before: X Y : TopCat
f : ↑X ≃ₜ ↑Y
⊢ f.toContinuousMap ≫ f.symm.toContinuousMap = 𝟙 X
state_after: case w
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : (forget TopCat).obj X
⊢ (f.toContinuousMap ≫ f.symm.toContinuousMap) x✝ = (𝟙 X) x✝
tactic: ext
state_before: case w
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : (forget TopCat).obj X
⊢ (f.toContinuousMap ≫ f.symm.toContinuousMap) x✝ = (𝟙 X) x✝
state_after: no goals
tactic: exact f.symm_apply_apply _
state_before: X Y : TopCat
f : ↑X ≃ₜ ↑Y
⊢ f.symm.toContinuousMap ≫ f.toContinuousMap = 𝟙 Y
state_after: case w
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : (forget TopCat).obj Y
⊢ (f.symm.toContinuousMap ≫ f.toContinuousMap) x✝ = (𝟙 Y) x✝
tactic: ext
state_before: case w
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : (forget TopCat).obj Y
⊢ (f.symm.toContinuousMap ≫ f.toContinuousMap) x✝ = (𝟙 Y) x✝
state_after: no goals
tactic: exact f.apply_symm_apply _
Theorem: MeasureTheory.Measure.compProd_apply
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝¹ : SFinite μ
inst✝ : IsSFiniteKernel κ
s : Set (α × β)
hs : MeasurableSet s
⊢ (μ ⊗ₘ κ) s = ∫⁻ (a : α), (κ a) (Prod.mk a ⁻¹' s) ∂μ
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝¹ : SFinite μ
inst✝ : IsSFiniteKernel κ
s : Set (α × β)
hs : MeasurableSet s
⊢ ∫⁻ (b : α), (κ b) {c | (b, c) ∈ s} ∂μ = ∫⁻ (a : α), (κ a) (Prod.mk a ⁻¹' s) ∂μ
tactic: simp_rw [compProd, Kernel.compProd_apply _ _ _ hs, Kernel.const_apply, Kernel.prodMkLeft_apply']
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝¹ : SFinite μ
inst✝ : IsSFiniteKernel κ
s : Set (α × β)
hs : MeasurableSet s
⊢ ∫⁻ (b : α), (κ b) {c | (b, c) ∈ s} ∂μ = ∫⁻ (a : α), (κ a) (Prod.mk a ⁻¹' s) ∂μ
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_tsum_measure
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : μ univ < ∑' (i : ι), μ (s i)
⊢ ∃ i j, i ≠ j ∧ (s i ∩ s j).Nonempty
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
⊢ ∑' (i : ι), μ (s i) ≤ μ univ
tactic: contrapose! H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
⊢ ∑' (i : ι), μ (s i) ≤ μ univ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
⊢ Pairwise (AEDisjoint μ on s)
tactic: apply tsum_measure_le_measure_univ hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
⊢ Pairwise (AEDisjoint μ on s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
i j : ι
hij : i ≠ j
⊢ (AEDisjoint μ on s) i j
tactic: intro i j hij
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), NullMeasurableSet (s i) μ
H : ∀ (i j : ι), i ≠ j → s i ∩ s j = ∅
i j : ι
hij : i ≠ j
⊢ (AEDisjoint μ on s) i j
state_after: no goals
tactic: exact (disjoint_iff_inter_eq_empty.mpr (H i j hij)).aedisjoint
Theorem: List.attach_map_coe'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
f : α → β
⊢ map (fun i => f ↑i) l.attach = map f l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
f : α → β
⊢ pmap (fun a h => f ↑⟨a, h⟩) l ⋯ = map f l
tactic: rw [attach, attachWith, map_pmap]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
f : α → β
⊢ pmap (fun a h => f ↑⟨a, h⟩) l ⋯ = map f l
state_after: no goals
tactic: exact pmap_eq_map _ _ _ _
Theorem: TypeVec.snd_prod_mk
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
⊢ prod.snd ⊚ (f ⊗' g) = g ⊚ prod.snd
state_after: case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.snd ⊚ (f ⊗' g)) i = (g ⊚ prod.snd) i
tactic: funext i
state_before: case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.snd ⊚ (f ⊗' g)) i = (g ⊚ prod.snd) i
state_after: no goals
tactic: induction i with
  | fz => rfl
  | fs _ i_ih => apply i_ih
Theorem: nat_log_eq_padicValNat_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ log p n = padicValNat p n ↔ n < p ^ (padicValNat p n + 1)
state_after: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ n < p ^ (padicValNat p n + 1) → p ^ padicValNat p n ≤ n
tactic: rw [Nat.log_eq_iff (Or.inr ⟨(Nat.Prime.one_lt' p).out, by omega⟩), and_iff_right_iff_imp]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ n < p ^ (padicValNat p n + 1) → p ^ padicValNat p n ≤ n
state_after: no goals
tactic: exact fun _ => Nat.le_of_dvd hn pow_padicValNat_dvd
Theorem: SimpleGraph.Walk.coe_support
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ ↑p.support = {u} + ↑p.support.tail
state_after: no goals
tactic: cases p <;> rfl
Theorem: Real.volume_pi_Ioo_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ (volume (univ.pi fun i => Ioo (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
state_after: no goals
tactic: simp only [volume_pi_Ioo, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
Theorem: Finset.addETransformRight_neg
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap
state_after: no goals
tactic: simp [-op_inv, op_smul_eq_smul, mulETransformLeft, mulETransformRight]
Theorem: PiTensorProduct.piTensorHomMap_tprod_eq_map
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ f : (i : ι) → s i →ₗ[R] t i
⊢ piTensorHomMap ((tprod R) f) = map f
state_after: case H.H
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ f : (i : ι) → s i →ₗ[R] t i
x✝ : (i : ι) → s i
⊢ ((piTensorHomMap ((tprod R) f)).compMultilinearMap (tprod R)) x✝ = ((map f).compMultilinearMap (tprod R)) x✝
tactic: ext
state_before: case H.H
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ f : (i : ι) → s i →ₗ[R] t i
x✝ : (i : ι) → s i
⊢ ((piTensorHomMap ((tprod R) f)).compMultilinearMap (tprod R)) x✝ = ((map f).compMultilinearMap (tprod R)) x✝
state_after: no goals
tactic: simp
Theorem: MulChar.one_mul
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
⊢ 1 * χ = χ
state_after: case h
R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a✝ : Rˣ
⊢ (1 * χ) ↑a✝ = χ ↑a✝
tactic: ext
state_before: case h
R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a✝ : Rˣ
⊢ (1 * χ) ↑a✝ = χ ↑a✝
state_after: no goals
tactic: simp only [one_mul, Pi.mul_apply, MulChar.coeToFun_mul, MulChar.one_apply_coe]
Theorem: List.map_diff
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
l₁ l₂ : List α
⊢ map f (l₁.diff l₂) = (map f l₁).diff (map f l₂)
state_after: no goals
tactic: simp only [diff_eq_foldl, foldl_map, map_foldl_erase finj]
Theorem: Finset.Icc_diff_Ico_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ Icc a b \ Ico a b = {b}
state_after: no goals
tactic: simp [← coe_inj, h]
Theorem: MulChar.apply_mem_rootsOfUnity
File: Mathlib/NumberTheory/MulChar/Lemmas.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing R'
inst✝ : Fintype Rˣ
a : Rˣ
χ : MulChar R R'
⊢ (equivToUnitHom χ) a ∈ rootsOfUnity ⟨Fintype.card Rˣ, ⋯⟩ R'
state_after: no goals
tactic: rw [mem_rootsOfUnity, ← map_pow, ← (equivToUnitHom χ).map_one, PNat.mk_coe, pow_card_eq_one]
Theorem: Monoid.lcm_orderOf_dvd_exponent
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ Finset.univ.lcm orderOf ∣ exponent G
state_after: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ ∀ b ∈ Finset.univ, orderOf b ∣ exponent G
tactic: apply Finset.lcm_dvd
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ ∀ b ∈ Finset.univ, orderOf b ∣ exponent G
state_after: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
a✝ : g ∈ Finset.univ
⊢ orderOf g ∣ exponent G
tactic: intro g _
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
a✝ : g ∈ Finset.univ
⊢ orderOf g ∣ exponent G
state_after: no goals
tactic: exact order_dvd_exponent g