ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AhlswedeZhang.infSum_compls_add_supSum
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
inst✝ : Nonempty α
𝒜 : Finset (Finset α)
⊢ infSum 𝒜ᶜˢ + supSum 𝒜 = ↑(card α) * ∑ k ∈ range (card α), (↑k)⁻¹ + 1
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
inst✝ : Nonempty α
𝒜 : Finset (Finset α)
⊢ ∑ s : Finset α, ↑(𝒜ᶜˢ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ↑(card α) * ∑ k ∈ range (card α), (↑k)⁻¹ + 1
tactic: unfold infSum supSum
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
inst✝ : Nonempty α
𝒜 : Finset (Finset α)
⊢ ∑ s : Finset α, ↑(𝒜ᶜˢ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ↑(card α) * ∑ k ∈ range (card α), (↑k)⁻¹ + 1
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
inst✝ : Nonempty α
𝒜 : Finset (Finset α)
⊢ ∑ x : Finset α,
        ↑(𝒜ᶜˢ.truncatedInf ({ toFun := compl, inj' := ⋯ } x)).card /
          (↑({ toFun := compl, inj' := ⋯ } x).card * ↑((card α).choose ({ toFun := compl, inj' := ⋯ } x).card)) +
      ∑ s ∈ map { toFun := compl, inj' := ⋯ } univ,
        ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ↑(card α) * ∑ k ∈ range (card α), (↑k)⁻¹ + 1
tactic: rw [← @map_univ_of_surjective (Finset α) _ _ _ ⟨compl, compl_injective⟩ compl_surjective, sum_map]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
inst✝ : Nonempty α
𝒜 : Finset (Finset α)
⊢ ∑ x : Finset α,
        ↑(𝒜ᶜˢ.truncatedInf ({ toFun := compl, inj' := ⋯ } x)).card /
          (↑({ toFun := compl, inj' := ⋯ } x).card * ↑((card α).choose ({ toFun := compl, inj' := ⋯ } x).card)) +
      ∑ s ∈ map { toFun := compl, inj' := ⋯ } univ,
        ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ↑(card α) * ∑ k ∈ range (card α), (↑k)⁻¹ + 1
state_after: no goals
tactic: simp only [Function.Embedding.coeFn_mk, univ_map_embedding, ← compl_truncatedSup,
    ← sum_add_distrib, card_compl, cast_sub (card_le_univ _), choose_symm (card_le_univ _),
    div_add_div_same, sub_add_cancel, Fintype.sum_div_mul_card_choose_card]
Theorem: PFun.preimage_univ
File: Mathlib/Data/PFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α →. β
⊢ f.preimage Set.univ = f.Dom
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α →. β
x✝ : α
⊢ x✝ ∈ f.preimage Set.univ ↔ x✝ ∈ f.Dom
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α →. β
x✝ : α
⊢ x✝ ∈ f.preimage Set.univ ↔ x✝ ∈ f.Dom
state_after: no goals
tactic: simp [mem_preimage, mem_dom]
Theorem: Filter.map_atTop_finset_prod_le_of_prod_eq
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b
⊢ map (fun s => ∏ b ∈ s, f b) atTop ≤ map (fun s => ∏ x ∈ s, g x) atTop
state_after: no goals
tactic: classical
    refine ((atTop_basis.map _).le_basis_iff (atTop_basis.map _)).2 fun b _ => ?_
    let ⟨v, hv⟩ := h_eq b
    refine ⟨v, trivial, ?_⟩
    simpa [image_subset_iff] using hv
Theorem: ENNReal.rpow_one
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
⊢ x ^ 1 = x
state_after: case top

⊢ ⊤ ^ 1 = ⊤

case coe
x✝ : ℝ≥0
⊢ ↑x✝ ^ 1 = ↑x✝
tactic: cases x
Theorem: Ordinal.nfpBFamily_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < c.cof
hc' : Cardinal.lift.{v, u} o.card < c.cof
hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c, f i hi b < c
a : Ordinal.{max u v}
⊢ Cardinal.lift.{v, u} #(Quotient.out o).α < c.cof
state_after: no goals
tactic: rwa [mk_ordinal_out]
Theorem: EMetric.hausdorffEdist_closure₂
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ hausdorffEdist s (closure t) = hausdorffEdist s t
state_after: no goals
tactic: simp [@hausdorffEdist_comm _ _ s _]
Theorem: OrthonormalBasis.coe_mk
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : ι → E
hon : Orthonormal 𝕜 v
hsp : ⊤ ≤ span 𝕜 (range v)
⊢ ⇑(OrthonormalBasis.mk hon hsp) = v
state_after: no goals
tactic: classical rw [OrthonormalBasis.mk, _root_.Basis.coe_toOrthonormalBasis, Basis.coe_mk]
Theorem: Nat.cast_div_div_div_cancel_right
File: Mathlib/Data/Nat/Cast/Field.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n
state_after: case inl
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n : ℕ
hn : 0 ∣ n
hm : 0 ∣ m
⊢ ↑(m / 0) / ↑(n / 0) = ↑m / ↑n

case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n
tactic: rcases eq_or_ne d 0 with (rfl | hd)
state_before: case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n
state_after: case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : ↑d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n
tactic: replace hd : (d : α) ≠ 0 := by norm_cast
state_before: case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : ↑d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n
state_after: no goals
tactic: rw [cast_div hm, cast_div hn, div_div_div_cancel_right _ hd] <;> exact hd
Theorem: Nat.succ_descFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1 - 0) * (n + 1).descFactorial 0 = (n + 1) * n.descFactorial 0
state_after: no goals
tactic: rw [Nat.sub_zero, descFactorial_zero, descFactorial_zero]
state_before: n k : ℕ
⊢ (n + 1 - (k + 1)) * (n + 1).descFactorial (k + 1) = (n + 1) * n.descFactorial (k + 1)
state_after: no goals
tactic: rw [descFactorial, succ_descFactorial _ k, descFactorial_succ, succ_sub_succ, Nat.mul_left_comm]
Theorem: HasDerivWithinAt.mul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' s x
d : 𝔸
⊢ HasDerivWithinAt (fun y => c y * d) (c' * d) s x
state_after: case h.e'_7
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' s x
d : 𝔸
⊢ c' * d = c' * d + c x * 0
tactic: convert hc.mul (hasDerivWithinAt_const x s d) using 1
state_before: case h.e'_7
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' s x
d : 𝔸
⊢ c' * d = c' * d + c x * 0
state_after: no goals
tactic: rw [mul_zero, add_zero]
Theorem: MeasureTheory.Measure.restrict_sum_of_countable
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Countable ι
μ : ι → Measure α
s : Set α
⊢ (sum μ).restrict s = sum fun i => (μ i).restrict s
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
μ : ι → Measure α
s t : Set α
ht : MeasurableSet t
⊢ ((sum μ).restrict s) t = (sum fun i => (μ i).restrict s) t
tactic: ext t ht
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
μ : ι → Measure α
s t : Set α
ht : MeasurableSet t
⊢ ((sum μ).restrict s) t = (sum fun i => (μ i).restrict s) t
state_after: no goals
tactic: simp_rw [sum_apply _ ht, restrict_apply ht, sum_apply_of_countable]
Theorem: HasSum.nat_add_neg
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
⊢ HasProd (fun n => f ↑n * f (-↑n)) (m * f 0)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
⊢ ∃ v, ∀ (v' : Finset ℕ), v ⊆ v' → ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
tactic: apply (hf.mul (hasProd_ite_eq (0 : ℤ) (f 0))).hasProd_of_prod_eq fun u ↦ ?_
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
⊢ ∃ v, ∀ (v' : Finset ℕ), v ⊆ v' → ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
v' : Finset ℕ
hv' : image Int.natAbs u ⊆ v'
⊢ ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
tactic: refine ⟨u.image Int.natAbs, fun v' hv' ↦ ?_⟩
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
v' : Finset ℕ
hv' : image Int.natAbs u ⊆ v'
⊢ ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
v' : Finset ℕ
hv' : image Int.natAbs u ⊆ v'
u1 : Finset ℤ := image (fun x => ↑x) v'
⊢ ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
tactic: let u1 := v'.image fun x : ℕ ↦ (x : ℤ)
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
v' : Finset ℕ
hv' : image Int.natAbs u ⊆ v'
u1 : Finset ℤ := image (fun x => ↑x) v'
⊢ ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℤ → M
hf : HasProd f m
u : Finset ℤ
v' : Finset ℕ
hv' : image Int.natAbs u ⊆ v'
u1 : Finset ℤ := image (fun x => ↑x) v'
u2 : Finset ℤ := image (fun x => -↑x) v'
⊢ ∃ u', u ⊆ u' ∧ (∏ x ∈ u', f x * if x = 0 then f 0 else 1) = ∏ b ∈ v', f ↑b * f (-↑b)
tactic: let u2 := v'.image fun x : ℕ ↦ -(x : ℤ)
Theorem: CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Type u
c : Cone F
t : IsLimit c
x : ↑F.sections
j : J
⊢ c.π.app j ((isLimitEquivSections t).symm x) = ↑x j
state_after: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Type u
c : Cone F
t : IsLimit c
x : ↑F.sections
j : J
⊢ c.π.app j ((isLimitEquivSections t).symm x) = ↑((isLimitEquivSections t).toFun ((isLimitEquivSections t).invFun x)) j
tactic: conv_rhs => rw [← (isLimitEquivSections t).right_inv x]
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Type u
c : Cone F
t : IsLimit c
x : ↑F.sections
j : J
⊢ c.π.app j ((isLimitEquivSections t).symm x) = ↑((isLimitEquivSections t).toFun ((isLimitEquivSections t).invFun x)) j
state_after: no goals
tactic: rfl
Theorem: Units.sq_eq_sq_iff_eq_or_eq_neg
File: Mathlib/Algebra/Ring/Commute.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
a✝ b✝ : R
a b : Rˣ
⊢ a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b
state_after: no goals
tactic: simp_rw [Units.ext_iff, val_pow_eq_pow_val, sq_eq_sq_iff_eq_or_eq_neg, Units.val_neg]
Theorem: CategoryTheory.ShortComplex.exact_iff_isZero_homology
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.1319, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
⊢ S.Exact ↔ IsZero S.homology
state_after: case mp
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.1319, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
⊢ S.Exact → IsZero S.homology

case mpr
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.1319, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
⊢ IsZero S.homology → S.Exact
tactic: constructor
Theorem: ZFSet.mem_pairSep
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: p : ZFSet → ZFSet → Prop
x y z : ZFSet
⊢ z ∈ pairSep p x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b
state_after: p : ZFSet → ZFSet → Prop
x y z : ZFSet
e : ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b
⊢ z ∈ (x ∪ y).powerset.powerset
tactic: refine mem_sep.trans ⟨And.right, fun e => ⟨?_, e⟩⟩
state_before: p : ZFSet → ZFSet → Prop
x y z : ZFSet
e : ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b
⊢ z ∈ (x ∪ y).powerset.powerset
state_after: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ a.pair b ∈ (x ∪ y).powerset.powerset
tactic: rcases e with ⟨a, ax, b, bY, rfl, pab⟩
state_before: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ a.pair b ∈ (x ∪ y).powerset.powerset
state_after: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ ∀ ⦃z : ZFSet⦄, z = {a} ∨ z = {a, b} → ∀ ⦃z_1 : ZFSet⦄, z_1 ∈ z → z_1 ∈ x ∨ z_1 ∈ y
tactic: simp only [mem_powerset, subset_def, mem_union, pair, mem_pair]
state_before: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ ∀ ⦃z : ZFSet⦄, z = {a} ∨ z = {a, b} → ∀ ⦃z_1 : ZFSet⦄, z_1 ∈ z → z_1 ∈ x ∨ z_1 ∈ y
state_after: case intro.intro.intro.intro.intro.inl
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
v : ZFSet
⊢ v = a → v ∈ x ∨ v ∈ y

case intro.intro.intro.intro.intro.inr
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
v : ZFSet
⊢ v = a ∨ v = b → v ∈ x ∨ v ∈ y
tactic: rintro u (rfl | rfl) v <;> simp only [mem_singleton, mem_pair]
Theorem: Mathlib.Vector.reverse_get_zero
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.head = v.last
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.toList.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
tactic: rw [← get_zero, last_def, get_eq_get, get_eq_get]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.toList.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.reverse.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
tactic: simp_rw [toList_reverse]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.reverse.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList[v.toList.length - 1 - ↑⟨↑0, ⋯⟩]? = v.toList[↑⟨↑(Fin.last n), ⋯⟩]?

n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ ↑⟨↑0, ⋯⟩ < v.toList.length
tactic: rw [List.get_eq_getElem, List.get_eq_getElem, ← Option.some_inj, Fin.cast, Fin.cast,
    ← List.getElem?_eq_getElem, ← List.getElem?_eq_getElem, List.getElem?_reverse]
Theorem: CategoryTheory.Limits.cospanOp_inv_app
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (X_1 : WalkingCospan) → (cospan f.op g.op).obj X_1 ≅ (walkingSpanOpEquiv.inverse ⋙ (span f g).op).obj X_1
state_after: no goals
tactic: rintro (_ | _ | _) <;> rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ ∀ {X_1 Y_1 : WalkingCospan} (f_1 : X_1 ⟶ Y_1),
    (cospan f.op g.op).map f_1 ≫
        (Option.casesOn Y_1 (Iso.refl ((cospan f.op g.op).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.right)))).hom =
      (Option.casesOn X_1 (Iso.refl ((cospan f.op g.op).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.right)))).hom ≫
        (walkingSpanOpEquiv.inverse ⋙ (span f g).op).map f_1
state_after: no goals
tactic: rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> aesop_cat
Theorem: Set.image_update_Icc_right
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Icc (f i) b = Icc f (update f i b)
state_after: no goals
tactic: simpa using image_update_Icc f i (f i) b
Theorem: Interval.length_sub_le
File: Mathlib/Algebra/Order/Interval/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : OrderedAddCommGroup α
s t : Interval α
a : α
⊢ (s - t).length ≤ s.length + t.length
state_after: no goals
tactic: simpa [sub_eq_add_neg] using length_add_le s (-t)
Theorem: Matroid.eq_of_restrictSubtype_eq
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M✝ : Matroid α
N✝ : Matroid β
E X I : Set α
M N : Matroid α
hM : M.E = E
hN : N.E = E
h : M.restrictSubtype E = N.restrictSubtype E
⊢ M = N
state_after: α : Type u_1
β : Type u_2
f : α → β
E I✝ s : Set α
M✝ : Matroid α
N✝ : Matroid β
X I : Set α
M N : Matroid α
hN : N.E = M.E
h : M.restrictSubtype M.E = N.restrictSubtype M.E
⊢ M = N
tactic: subst hM
state_before: α : Type u_1
β : Type u_2
f : α → β
E I✝ s : Set α
M✝ : Matroid α
N✝ : Matroid β
X I : Set α
M N : Matroid α
hN : N.E = M.E
h : M.restrictSubtype M.E = N.restrictSubtype M.E
⊢ M = N
state_after: α : Type u_1
β : Type u_2
f : α → β
E I✝¹ s : Set α
M✝ : Matroid α
N✝ : Matroid β
X I✝ : Set α
M N : Matroid α
hN : N.E = M.E
h : M.restrictSubtype M.E = N.restrictSubtype M.E
I : Set α
hI : I ⊆ M.E
⊢ M.Indep I ↔ N.Indep I
tactic: refine eq_of_indep_iff_indep_forall (by rw [hN]) (fun I hI ↦ ?_)
state_before: α : Type u_1
β : Type u_2
f : α → β
E I✝¹ s : Set α
M✝ : Matroid α
N✝ : Matroid β
X I✝ : Set α
M N : Matroid α
hN : N.E = M.E
h : M.restrictSubtype M.E = N.restrictSubtype M.E
I : Set α
hI : I ⊆ M.E
⊢ M.Indep I ↔ N.Indep I
state_after: no goals
tactic: rwa [← restrictSubtype_indep_iff_of_subset hI, h, restrictSubtype_indep_iff_of_subset]
Theorem: isSimpleOrder_iff_isSimpleOrder_orderDual
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
⊢ IsSimpleOrder α ↔ IsSimpleOrder αᵒᵈ
state_after: case mp
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder α
⊢ IsSimpleOrder αᵒᵈ

case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder αᵒᵈ
⊢ IsSimpleOrder α
tactic: constructor <;> intro i <;> haveI := i
Theorem: IntermediateField.finrank_eq_one_iff
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ finrank F ↥K = 1 ↔ K = ⊥
state_after: no goals
tactic: rw [← toSubalgebra_eq_iff, ← finrank_eq_finrank_subalgebra, Subalgebra.finrank_eq_one_iff,
    bot_toSubalgebra]