ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddSubmonoid.mem_iSup_iff_exists_dfinsupp'
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ x ∈ iSup S ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (sumAddHom fun i => (S i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
tactic: rw [AddSubmonoid.mem_iSup_iff_exists_dfinsupp]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (sumAddHom fun i => (S i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (f.sum fun x => ⇑(S x).subtype) = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
tactic: simp_rw [sumAddHom_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (f.sum fun x => ⇑(S x).subtype) = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: no goals
tactic: rfl
Theorem: IsPrimitiveRoot.card_nthRoots_one
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ Multiset.card (nthRoots n 1) = n
state_after: no goals
tactic: rw [card_nthRoots h, if_pos ⟨ζ, h.pow_eq_one⟩]
Theorem: padicValRat.multiplicity_sub_multiplicity
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ (multiplicity p q.den).Dom
state_after: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den
tactic: rw [← finite_iff_dom, finite_nat_iff]
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den
state_after: no goals
tactic: exact ⟨hp, q.pos⟩
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ padicValRat p q = ↑((multiplicity (↑p) q.num).get ⋯) - ↑((multiplicity p q.den).get ⋯)
state_after: case hc
p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den

p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ q.num ≠ 0
tactic: rw [padicValRat, padicValInt.of_ne_one_ne_zero hp, padicValNat, dif_pos]
Theorem: AddUnits.add_left_inj
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c✝ u a : αˣ
b c : α
h : b * ↑a = c * ↑a
⊢ b = c
state_after: no goals
tactic: simpa only [mul_inv_cancel_right] using congr_arg (fun x : α => x * ↑(a⁻¹ : αˣ)) h
Theorem: MvPolynomial.bind₂_map
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : S →+* MvPolynomial σ T
g : R →+* S
φ : MvPolynomial σ R
⊢ (bind₂ f) ((map g) φ) = (bind₂ (f.comp g)) φ
state_after: no goals
tactic: simp [bind₂]
Theorem: Multiset.toFinsupp_symm_apply
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s : Multiset α
a : α
⊢ a ∈ s.toFinset ↔ (fun a => count a s) a ≠ 0
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ ((fun s => { support := s.toFinset, toFun := fun a => count a s, mem_support_toFun := ⋯ })
        ((fun f => Finsupp.toMultiset f) f))
      a =
    f a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ f a = 0 → 0 = f a
tactic: simp only [Finsupp.toMultiset_apply, Finsupp.sum, Multiset.count_sum',
        Multiset.count_singleton, mul_boole, Finsupp.coe_mk, Finsupp.mem_support_iff,
        Multiset.count_nsmul, Finset.sum_ite_eq, ite_not, ite_eq_right_iff]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ f a = 0 → 0 = f a
state_after: no goals
tactic: exact Eq.symm
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s : Multiset α
⊢ (fun f => Finsupp.toMultiset f)
      ((fun s => { support := s.toFinset, toFun := fun a => count a s, mem_support_toFun := ⋯ }) s) =
    s
state_after: no goals
tactic: simp only [Finsupp.toMultiset_apply, Finsupp.sum, Finsupp.coe_mk,
    Multiset.toFinset_sum_count_nsmul_eq]
Theorem: IsUnifLocDoublingMeasure.eventually_measure_le_scaling_constant_mul'
File: Mathlib/MeasureTheory/Measure/Doubling.lean

Proof steps:
state_before: α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
hK : 0 < K
⊢ ∀ᶠ (r : ℝ) in 𝓝[>] 0, ∀ (x : α), μ (closedBall x r) ≤ ↑(scalingConstantOf μ K⁻¹) * μ (closedBall x (K * r))
state_after: case h.e'_2.h.h.h.e'_3.h.e'_6.h.e'_4
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
hK : 0 < K
x✝ : ℝ
a✝ : α
⊢ x✝ = K⁻¹ * (K * x✝)
tactic: convert eventually_nhdsWithin_pos_mul_left hK (eventually_measure_le_scaling_constant_mul μ K⁻¹)
state_before: case h.e'_2.h.h.h.e'_3.h.e'_6.h.e'_4
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
hK : 0 < K
x✝ : ℝ
a✝ : α
⊢ x✝ = K⁻¹ * (K * x✝)
state_after: no goals
tactic: simp [inv_mul_cancel_left₀ hK.ne']
Theorem: Fin.snocCases_snoc
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
P : ((i : Fin (n + 1)) → α i) → Sort u_1
h : (x : (i : Fin n) → α i.castSucc) → (x₀ : α (last n)) → P (snoc x x₀)
x : (i : Fin n) → init α i
x₀ : α (last n)
⊢ snocCases h (snoc x x₀) = h x x₀
state_after: no goals
tactic: rw [snocCases, cast_eq_iff_heq, Fin.init_snoc, Fin.snoc_last]
Theorem: MeasureTheory.L1.integrable_coeFn
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : ↥(Lp β 1 μ)
⊢ Integrable (↑↑f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : ↥(Lp β 1 μ)
⊢ Memℒp (↑↑f) 1 μ
tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : ↥(Lp β 1 μ)
⊢ Memℒp (↑↑f) 1 μ
state_after: no goals
tactic: exact Lp.memℒp f
Theorem: isTotallyDisconnected_iff_lt
File: Mathlib/Topology/Order/IntermediateValue.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
s : Set α
⊢ IsTotallyDisconnected s ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Ioo x y
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
s : Set α
⊢ (∀ t ⊆ s, t.OrdConnected → ∀ x ∈ t, ∀ x_1 ∈ t, ¬x < x_1) ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Ioo x y
tactic: simp only [IsTotallyDisconnected, isPreconnected_iff_ordConnected, ← not_nontrivial_iff,
    nontrivial_iff_exists_lt, not_exists, not_and]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
s : Set α
⊢ (∀ t ⊆ s, t.OrdConnected → ∀ x ∈ t, ∀ x_1 ∈ t, ¬x < x_1) ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Ioo x y
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
s : Set α
h : ∀ t ⊆ s, t.OrdConnected → ∀ x ∈ t, ∀ x_1 ∈ t, ¬x < x_1
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x < y
⊢ ∃ z ∉ s, z ∈ Ioo x y

case refine_2
α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
s : Set α
h : ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Ioo x y
t : Set α
hts : t ⊆ s
ht : t.OrdConnected
x : α
hx : x ∈ t
y : α
hy : y ∈ t
hxy : x < y
⊢ False
tactic: refine ⟨fun h x hx y hy hxy ↦ ?_, fun h t hts ht x hx y hy hxy ↦ ?_⟩
Theorem: Finset.sigmaAntidiagonalEquivProd_symm_apply_fst
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
⊢ LeftInverse (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) fun x => ↑x.snd
state_after: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h : (k, l) ∈ antidiagonal n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h⟩⟩) = ⟨n, ⟨(k, l), h⟩⟩
tactic: rintro ⟨n, ⟨k, l⟩, h⟩
state_before: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h : (k, l) ∈ antidiagonal n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h⟩⟩) = ⟨n, ⟨(k, l), h⟩⟩
state_after: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h✝ : (k, l) ∈ antidiagonal n
h : (k, l).1 + (k, l).2 = n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h✝⟩⟩) = ⟨n, ⟨(k, l), h✝⟩⟩
tactic: rw [mem_antidiagonal] at h
state_before: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h✝ : (k, l) ∈ antidiagonal n
h : (k, l).1 + (k, l).2 = n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h✝⟩⟩) = ⟨n, ⟨(k, l), h✝⟩⟩
state_after: no goals
tactic: exact Sigma.subtype_ext h rfl
Theorem: Multiset.card_nsmul_le_sum
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : ∀ x ∈ s, a ≤ x
⊢ a ^ card s ≤ s.prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : ∀ x ∈ s, a ≤ x
⊢ (map (Function.const α a) s).prod ≤ s.prod
tactic: rw [← Multiset.prod_replicate, ← Multiset.map_const]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : ∀ x ∈ s, a ≤ x
⊢ (map (Function.const α a) s).prod ≤ s.prod
state_after: no goals
tactic: exact prod_map_le_prod _ h
Theorem: BoundedContinuousFunction.norm_eq_iSup_norm
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
⊢ ‖f‖ = ⨆ x, ‖f x‖
state_after: no goals
tactic: simp_rw [norm_def, dist_eq_iSup, coe_zero, Pi.zero_apply, dist_zero_right]
Theorem: Set.preimage_const_add_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) ⁻¹' Ico b c = Ico (b - a) (c - a)
state_after: no goals
tactic: simp [← Ici_inter_Iio]
Theorem: FreeGroup.Red.Step.not_rev
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
⊢ Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂)
state_after: no goals
tactic: cases b <;> exact Step.not
Theorem: CategoryTheory.IsHomLift.eqToHom_codomain_lift_id
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a b : 𝒳
hab : a = b
S : 𝒮
hS : p.obj b = S
⊢ p.IsHomLift (𝟙 S) (eqToHom hab)
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (eqToHom ⋯)
tactic: subst hS hab
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (eqToHom ⋯)
state_after: no goals
tactic: simp
Theorem: OrderIso.funUnique_toEquiv
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : Preorder α✝
inst✝³ : Preorder β✝
inst✝² : Preorder γ
α : Type u_6
β : Type u_7
inst✝¹ : Unique α
inst✝ : Preorder β
⊢ ∀ {a b : α → β}, (Equiv.funUnique α β) a ≤ (Equiv.funUnique α β) b ↔ a ≤ b
state_after: no goals
tactic: simp [Pi.le_def, Unique.forall_iff]
Theorem: Int.odd_add'
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ Odd (m + n) ↔ (Odd n ↔ Even m)
state_after: no goals
tactic: rw [add_comm, odd_add]
Theorem: List.Perm.erase
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
⊢ l₁.erase a ~ l₂.erase a
state_after: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁.erase a ~ l₂.erase a
tactic: have h₂ : a ∉ l₂ := mt p.mem_iff.2 h₁
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁.erase a ~ l₂.erase a
state_after: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁ ~ l₂
tactic: rw [erase_of_not_mem h₁, erase_of_not_mem h₂]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁ ~ l₂
state_after: no goals
tactic: exact p
Theorem: UpperSet.map_Ici
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✝¹ : Preorder α
inst✝ : Preorder β
s : UpperSet α
a✝ b : α
f : α ≃o β
a : α
⊢ (map f) (Ici a) = Ici (f a)
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : UpperSet α
a✝ b : α
f : α ≃o β
a : α
x✝ : β
⊢ x✝ ∈ ↑((map f) (Ici a)) ↔ x✝ ∈ ↑(Ici (f a))
tactic: ext
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : UpperSet α
a✝ b : α
f : α ≃o β
a : α
x✝ : β
⊢ x✝ ∈ ↑((map f) (Ici a)) ↔ x✝ ∈ ↑(Ici (f a))
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.mem_list_cycles_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
⊢ σ ∈ l ↔ σ.IsCycle ∧ ∀ (a : α), σ a ≠ a → σ a = l.prod a
state_after: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
⊢ σ.IsCycle → (σ ∈ l ↔ ∀ (a : α), σ a ≠ a → σ a = l.prod a)
tactic: suffices σ.IsCycle → (σ ∈ l ↔ ∀ a, σ a ≠ a → σ a = l.prod a) by
    exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
⊢ σ.IsCycle → (σ ∈ l ↔ ∀ (a : α), σ a ≠ a → σ a = l.prod a)
state_after: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
h3 : σ.IsCycle
⊢ σ ∈ l ↔ ∀ (a : α), σ a ≠ a → σ a = l.prod a
tactic: intro h3
Theorem: imageToKernel_unop
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : Category.{?u.8253, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.unop ≫ f.unop = 0
state_after: no goals
tactic: rw [← unop_comp, w, unop_zero]
state_before: V : Type u_1
inst✝¹ : Category.{?u.8253, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0
state_after: no goals
tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ =
    (imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
tactic: ext
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopOp g).unop.symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
tactic: dsimp only [imageUnopUnop]
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopOp g).unop.symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
state_after: no goals
tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelUnopUnop_inv, Category.assoc,
    imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, cokernel.π_desc, Iso.unop_inv,
    ← unop_comp, factorThruImage_comp_imageUnopOp_inv, Quiver.Hom.unop_op, imageSubobject_arrow]
Theorem: Ideal.mul_eq_bot
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R✝ : Type u
ι : Type u_1
inst✝² : CommSemiring R✝
I✝ J✝ K L : Ideal R✝
R : Type u_2
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
I J : Ideal R
h : I = ⊥ ∨ J = ⊥
⊢ I * J = ⊥
state_after: no goals
tactic: cases' h with h h <;> rw [← Ideal.mul_bot, h, Ideal.mul_comm]
Theorem: ComplexShape.instTotalComplexShape_π
File: Mathlib/Algebra/Homology/ComplexShapeSigns.lean

Proof steps:
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
I : Type u_4
inst✝¹ : AddMonoid I
c : ComplexShape I
inst✝ : c.TensorSigns
i₁✝ i₁'✝ i₂✝ i₂'✝ : I
h : c.Rel i₁✝ i₁'✝
x✝ : c.Rel i₂✝ i₂'✝
⊢ (fun x =>
          match x with
          | (p, snd) => c.ε p)
        (i₁✝, i₂✝) *
      (fun x => 1) (i₁✝, i₂'✝) =
    -(fun x => 1) (i₁✝, i₂✝) *
      (fun x =>
          match x with
          | (p, snd) => c.ε p)
        (i₁'✝, i₂✝)
state_after: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
I : Type u_4
inst✝¹ : AddMonoid I
c : ComplexShape I
inst✝ : c.TensorSigns
i₁✝ i₁'✝ i₂✝ i₂'✝ : I
h : c.Rel i₁✝ i₁'✝
x✝ : c.Rel i₂✝ i₂'✝
⊢ c.ε i₁✝ * 1 = -1 * c.ε i₁'✝
tactic: dsimp
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
I : Type u_4
inst✝¹ : AddMonoid I
c : ComplexShape I
inst✝ : c.TensorSigns
i₁✝ i₁'✝ i₂✝ i₂'✝ : I
h : c.Rel i₁✝ i₁'✝
x✝ : c.Rel i₂✝ i₂'✝
⊢ c.ε i₁✝ * 1 = -1 * c.ε i₁'✝
state_after: no goals
tactic: rw [neg_mul, one_mul, mul_one, c.ε_succ h, neg_neg]
Theorem: MeasureTheory.FiniteMeasure.coeFn_add
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
⊢ ⇑(μ + ν) = ⇑μ + ⇑ν
state_after: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ (μ + ν) x✝ = (⇑μ + ⇑ν) x✝
tactic: funext
state_before: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ (μ + ν) x✝ = (⇑μ + ⇑ν) x✝
state_after: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ ↑(μ + ν) x✝ = ↑μ x✝ + ↑ν x✝
tactic: simp only [Pi.add_apply, ← ENNReal.coe_inj, ne_eq, ennreal_coeFn_eq_coeFn_toMeasure,
    ENNReal.coe_add]
state_before: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ ↑(μ + ν) x✝ = ↑μ x✝ + ↑ν x✝
state_after: no goals
tactic: norm_cast
Theorem: FreeAddMonoid.toPiTensorProduct
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
p : FreeAddMonoid (R × ((i : ι) → s i))
⊢ ↑p = (List.map (fun x => x.1 • ⨂ₜ[R] (i : ι), x.2 i) p).sum
state_after: no goals
tactic: match p with
  | [] => rw [List.map_nil, List.sum_nil]; rfl
  | x :: ps => rw [List.map_cons, List.sum_cons, ← List.singleton_append, ← toPiTensorProduct ps,
                 ← tprodCoeff_eq_smul_tprod]; rfl