ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.Walk.toSubgraph_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
u v w : V
p : G.Walk u v
⊢ p.reverse.toSubgraph = p.toSubgraph
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons _ _ _ =>
    simp only [*, Walk.toSubgraph, reverse_cons, toSubgraph_append, subgraphOfAdj_symm]
    rw [sup_comm]
    congr
    ext <;> simp [-Set.bot_eq_empty]
Theorem: WeierstrassCurve.map_b₆
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ (W.map φ).b₆ = φ W.b₆
state_after: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₃ ^ 2 + 4 * φ W.a₆ = φ (W.a₃ ^ 2 + 4 * W.a₆)
tactic: simp only [b₆, map_a₃, map_a₆]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₃ ^ 2 + 4 * φ W.a₆ = φ (W.a₃ ^ 2 + 4 * W.a₆)
state_after: no goals
tactic: map_simp
Theorem: SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
File: Mathlib/SetTheory/Game/Domineering.lean

Proof steps:
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
⊢ (m.1, m.2 - 1) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1, m.2 - 1) ∈ b
⊢ (m.1, m.2 - 1) ∈ Finset.erase b m
tactic: rw [mem_left] at h
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1, m.2 - 1) ∈ b
⊢ (m.1, m.2 - 1) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1, m.2 - 1) ∈ b
⊢ (m.1, m.2 - 1) ≠ m
tactic: apply Finset.mem_erase_of_ne_of_mem _ h.2
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1, m.2 - 1) ∈ b
⊢ (m.1, m.2 - 1) ≠ m
state_after: no goals
tactic: exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
Theorem: MeasureTheory.Measure.univ_pi_Iio_ae_eq_Iic
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Iio (f i)) =ᶠ[ae (Measure.pi μ)] Iic f
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Iio (f i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Iic (f i)
tactic: rw [← pi_univ_Iic]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Iio (f i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Iic (f i)
state_after: no goals
tactic: exact pi_Iio_ae_eq_pi_Iic
Theorem: Finset.univ_prod_mulSingle
File: Mathlib/Algebra/BigOperators/Pi.lean

Proof steps:
state_before: I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
⊢ ∏ i : I, Pi.mulSingle i (f i) = f
state_after: case h
I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
a : I
⊢ (∏ i : I, Pi.mulSingle i (f i)) a = f a
tactic: ext a
state_before: case h
I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
a : I
⊢ (∏ i : I, Pi.mulSingle i (f i)) a = f a
state_after: no goals
tactic: simp
Theorem: Choose.choose_modEq_choose_mod_mul_choose_div_nat
File: Mathlib/Data/Nat/Choose/Lucas.lean

Proof steps:
state_before: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ n.choose k ≡ (n % p).choose (k % p) * (n / p).choose (k / p) [MOD p]
state_after: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ↑(n.choose k) ≡ ↑((n % p).choose (k % p) * (n / p).choose (k / p)) [ZMOD ↑p]
tactic: rw [← Int.natCast_modEq_iff]
state_before: n k p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ↑(n.choose k) ≡ ↑((n % p).choose (k % p) * (n / p).choose (k / p)) [ZMOD ↑p]
state_after: no goals
tactic: exact_mod_cast choose_modEq_choose_mod_mul_choose_div
Theorem: Matrix.diagonal_sub
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
inst✝¹ : DecidableEq n
inst✝ : SubNegZeroMonoid α
d₁ d₂ : n → α
⊢ diagonal d₁ - diagonal d₂ = diagonal fun i => d₁ i - d₂ i
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
inst✝¹ : DecidableEq n
inst✝ : SubNegZeroMonoid α
d₁ d₂ : n → α
i j : n
⊢ (diagonal d₁ - diagonal d₂) i j = diagonal (fun i => d₁ i - d₂ i) i j
tactic: ext i j
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
inst✝¹ : DecidableEq n
inst✝ : SubNegZeroMonoid α
d₁ d₂ : n → α
i j : n
⊢ (diagonal d₁ - diagonal d₂) i j = diagonal (fun i => d₁ i - d₂ i) i j
state_after: no goals
tactic: by_cases h : i = j <;>
  simp [h]
Theorem: MeasureTheory.SignedMeasure.measurable_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable (s.rnDeriv μ)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable fun x =>
    (s.toJordanDecomposition.posPart.rnDeriv μ x).toReal - (s.toJordanDecomposition.negPart.rnDeriv μ x).toReal
tactic: rw [rnDeriv_def]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable fun x =>
    (s.toJordanDecomposition.posPart.rnDeriv μ x).toReal - (s.toJordanDecomposition.negPart.rnDeriv μ x).toReal
state_after: no goals
tactic: fun_prop
Theorem: Finset.Iic_mul_Iio_subset'
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrderBot α
a b : α
⊢ ↑(Iic a * Iio b) ⊆ ↑(Iio (a * b))
state_after: no goals
tactic: simpa using Set.Iic_mul_Iio_subset' _ _
Theorem: LinearPMap.closure_def
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ f.closure = Exists.choose hf
state_after: no goals
tactic: simp [closure, hf]
Theorem: PMF.support_pure
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a'✝ a' : α
⊢ a' ∈ (pure a).support ↔ a' ∈ {a}
state_after: no goals
tactic: simp [mem_support_iff]
Theorem: Function.invFunOn_injOn_image
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
⊢ InjOn (invFunOn f s) (f '' s)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
x : α
hx : x ∈ s
x' : α
hx' : x' ∈ s
he : invFunOn f s (f x) = invFunOn f s (f x')
⊢ f x = f x'
tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨x', hx', rfl⟩ he
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
x : α
hx : x ∈ s
x' : α
hx' : x' ∈ s
he : invFunOn f s (f x) = invFunOn f s (f x')
⊢ f x = f x'
state_after: no goals
tactic: rw [← invFunOn_apply_eq (f := f) hx, he, invFunOn_apply_eq (f := f) hx']
Theorem: orthogonalProjection_norm_le
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ 0 ≤ 1
state_after: no goals
tactic: norm_num
Theorem: FreeSemigroup.lift_of_mul
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semigroup β
f : α → β
x : α
y : FreeSemigroup α
⊢ (lift f) (of x * y) = f x * (lift f) y
state_after: no goals
tactic: rw [map_mul, lift_of]
Theorem: ContinuousLinearEquiv.homothety_inverse
File: Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
inst✝⁷ : Ring 𝕜
inst✝⁶ : Ring 𝕜₂
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : SeminormedAddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜₂ F
σ : 𝕜 →+* 𝕜₂
f✝ : E →ₛₗ[σ] F
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝¹ : RingHomInvPair σ σ₂₁
inst✝ : RingHomInvPair σ₂₁ σ
a : ℝ
ha : 0 < a
f : E ≃ₛₗ[σ] F
⊢ (∀ (x : E), ‖f x‖ = a * ‖x‖) → ∀ (y : F), ‖f.symm y‖ = a⁻¹ * ‖y‖
state_after: 𝕜 : Type u_1
𝕜₂ : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
inst✝⁷ : Ring 𝕜
inst✝⁶ : Ring 𝕜₂
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : SeminormedAddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜₂ F
σ : 𝕜 →+* 𝕜₂
f✝ : E →ₛₗ[σ] F
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝¹ : RingHomInvPair σ σ₂₁
inst✝ : RingHomInvPair σ₂₁ σ
a : ℝ
ha : 0 < a
f : E ≃ₛₗ[σ] F
hf : ∀ (x : E), ‖f x‖ = a * ‖x‖
y : F
⊢ ‖f.symm y‖ = a⁻¹ * ‖y‖
tactic: intro hf y
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
inst✝⁷ : Ring 𝕜
inst✝⁶ : Ring 𝕜₂
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : SeminormedAddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜₂ F
σ : 𝕜 →+* 𝕜₂
f✝ : E →ₛₗ[σ] F
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝¹ : RingHomInvPair σ σ₂₁
inst✝ : RingHomInvPair σ₂₁ σ
a : ℝ
ha : 0 < a
f : E ≃ₛₗ[σ] F
hf : ∀ (x : E), ‖f x‖ = a * ‖x‖
y : F
⊢ ‖f.symm y‖ = a⁻¹ * ‖y‖
state_after: no goals
tactic: calc
    ‖f.symm y‖ = a⁻¹ * (a * ‖f.symm y‖) := by
      rw [← mul_assoc, inv_mul_cancel (ne_of_lt ha).symm, one_mul]
    _ = a⁻¹ * ‖f (f.symm y)‖ := by rw [hf]
    _ = a⁻¹ * ‖y‖ := by simp
Theorem: CovBy.card_multiset
File: Mathlib/Data/Finset/Grade.lean

Proof steps:
state_before: α : Type u_1
s t : Multiset α
a : α
h : s ⋖ t
⊢ card s ⋖ card t
state_after: case intro
α : Type u_1
s : Multiset α
a✝ a : α
h : s ⋖ a ::ₘ s
⊢ card s ⋖ card (a ::ₘ s)
tactic: obtain ⟨a, rfl⟩ := h.exists_multiset_cons
state_before: case intro
α : Type u_1
s : Multiset α
a✝ a : α
h : s ⋖ a ::ₘ s
⊢ card s ⋖ card (a ::ₘ s)
state_after: case intro
α : Type u_1
s : Multiset α
a✝ a : α
h : s ⋖ a ::ₘ s
⊢ card s ⋖ card s + 1
tactic: rw [card_cons]
state_before: case intro
α : Type u_1
s : Multiset α
a✝ a : α
h : s ⋖ a ::ₘ s
⊢ card s ⋖ card s + 1
state_after: no goals
tactic: exact covBy_succ _
Theorem: Equiv.Perm.apply_zpow_apply_eq_iff
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f : Perm α
n : ℤ
x : α
⊢ f ((f ^ n) x) = (f ^ n) x ↔ f x = x
state_after: no goals
tactic: rw [← mul_apply, Commute.self_zpow f, mul_apply, apply_eq_iff_eq]
Theorem: mul_eq_mul_left_iff
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : CancelMonoidWithZero M₀
a b c : M₀
⊢ a * b = a * c ↔ b = c ∨ a = 0
state_after: no goals
tactic: by_cases ha : a = 0 <;> [simp only [ha, zero_mul, or_true]; simp [mul_right_inj', ha]]
Theorem: MeasureTheory.integral_image_eq_integral_abs_deriv_smul
File: Mathlib/MeasureTheory/Function/Jacobian.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s✝ : Set E
f✝ : E → E
f'✝ : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set ℝ
f f' : ℝ → ℝ
hs : MeasurableSet s
hf' : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x
hf : InjOn f s
g : ℝ → F
⊢ ∫ (x : ℝ) in f '' s, g x = ∫ (x : ℝ) in s, |f' x| • g (f x)
state_after: no goals
tactic: simpa only [det_one_smulRight] using
    integral_image_eq_integral_abs_det_fderiv_smul volume hs
      (fun x hx => (hf' x hx).hasFDerivWithinAt) hf g
Theorem: EuclideanGeometry.orthogonalProjection_mem_subspace_eq_self
File: Mathlib/Geometry/Euclidean/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : ↥s
⊢ (orthogonalProjection s) ↑p = p
state_after: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : ↥s
⊢ ↑((orthogonalProjection s) ↑p) = ↑p
tactic: ext
state_before: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : ↥s
⊢ ↑((orthogonalProjection s) ↑p) = ↑p
state_after: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : ↥s
⊢ ↑p ∈ s
tactic: rw [orthogonalProjection_eq_self_iff]
state_before: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : ↥s
⊢ ↑p ∈ s
state_after: no goals
tactic: exact p.2
Theorem: MeasureTheory.fundamentalFrontier_smul
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁴ : Group G
inst✝³ : MulAction G α
s : Set α
x : α
inst✝² : Group H
inst✝¹ : MulAction H α
inst✝ : SMulCommClass H G α
g : H
⊢ fundamentalFrontier G (g • s) = g • fundamentalFrontier G s
state_after: no goals
tactic: simp_rw [fundamentalFrontier, smul_set_inter, smul_set_iUnion, smul_comm g (_ : G) (_ : Set α)]
Theorem: isClosed_iSup_iff
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
ι : Sort v
t : ι → TopologicalSpace α
s : Set α
⊢ IsClosed s ↔ ∀ (i : ι), IsClosed s
state_after: no goals
tactic: simp [← @isOpen_compl_iff _ _ (⨆ i, t i), ← @isOpen_compl_iff _ _ (t _), isOpen_iSup_iff]
Theorem: MeasureTheory.SimpleFunc.bind_const
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
⊢ f.bind (const α) = f
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
a✝ : α
⊢ ↑(f.bind (const α)) a✝ = ↑f a✝
tactic: ext
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
a✝ : α
⊢ ↑(f.bind (const α)) a✝ = ↑f a✝
state_after: no goals
tactic: simp
Theorem: CategoryTheory.LocalizerMorphism.smallHomMap_comp
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C₁ : Type u₁
inst✝¹¹ : Category.{v₁, u₁} C₁
W₁ : MorphismProperty C₁
C₂ : Type u₂
inst✝¹⁰ : Category.{v₂, u₂} C₂
W₂ : MorphismProperty C₂
D₁ : Type u₃
inst✝⁹ : Category.{v₃, u₃} D₁
D₂ : Type u₄
inst✝⁸ : Category.{v₄, u₄} D₂
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝⁷ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝⁶ : L₂.IsLocalization W₂
W : ?m.49815
X Y Z : C₁
inst✝⁵ : HasSmallLocalizedHom W₁ X Y
inst✝⁴ : HasSmallLocalizedHom W₁ Y Z
inst✝³ : HasSmallLocalizedHom W₁ X Z
inst✝² : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Y)
inst✝¹ : HasSmallLocalizedHom W₂ (Φ.functor.obj Y) (Φ.functor.obj Z)
inst✝ : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Z)
f : SmallHom W₁ X Y
g : SmallHom W₁ Y Z
⊢ Φ.smallHomMap (f.comp g) = (Φ.smallHomMap f).comp (Φ.smallHomMap g)
state_after: case a
C₁ : Type u₁
inst✝¹¹ : Category.{v₁, u₁} C₁
W₁ : MorphismProperty C₁
C₂ : Type u₂
inst✝¹⁰ : Category.{v₂, u₂} C₂
W₂ : MorphismProperty C₂
D₁ : Type u₃
inst✝⁹ : Category.{v₃, u₃} D₁
D₂ : Type u₄
inst✝⁸ : Category.{v₄, u₄} D₂
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝⁷ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝⁶ : L₂.IsLocalization W₂
W : ?m.49815
X Y Z : C₁
inst✝⁵ : HasSmallLocalizedHom W₁ X Y
inst✝⁴ : HasSmallLocalizedHom W₁ Y Z
inst✝³ : HasSmallLocalizedHom W₁ X Z
inst✝² : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Y)
inst✝¹ : HasSmallLocalizedHom W₂ (Φ.functor.obj Y) (Φ.functor.obj Z)
inst✝ : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Z)
f : SmallHom W₁ X Y
g : SmallHom W₁ Y Z
⊢ (SmallHom.equiv W₂ W₂.Q) (Φ.smallHomMap (f.comp g)) =
    (SmallHom.equiv W₂ W₂.Q) ((Φ.smallHomMap f).comp (Φ.smallHomMap g))
tactic: apply (SmallHom.equiv W₂ W₂.Q).injective
state_before: case a
C₁ : Type u₁
inst✝¹¹ : Category.{v₁, u₁} C₁
W₁ : MorphismProperty C₁
C₂ : Type u₂
inst✝¹⁰ : Category.{v₂, u₂} C₂
W₂ : MorphismProperty C₂
D₁ : Type u₃
inst✝⁹ : Category.{v₃, u₃} D₁
D₂ : Type u₄
inst✝⁸ : Category.{v₄, u₄} D₂
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝⁷ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝⁶ : L₂.IsLocalization W₂
W : ?m.49815
X Y Z : C₁
inst✝⁵ : HasSmallLocalizedHom W₁ X Y
inst✝⁴ : HasSmallLocalizedHom W₁ Y Z
inst✝³ : HasSmallLocalizedHom W₁ X Z
inst✝² : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Y)
inst✝¹ : HasSmallLocalizedHom W₂ (Φ.functor.obj Y) (Φ.functor.obj Z)
inst✝ : HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Z)
f : SmallHom W₁ X Y
g : SmallHom W₁ Y Z
⊢ (SmallHom.equiv W₂ W₂.Q) (Φ.smallHomMap (f.comp g)) =
    (SmallHom.equiv W₂ W₂.Q) ((Φ.smallHomMap f).comp (Φ.smallHomMap g))
state_after: no goals
tactic: simp [Φ.equiv_smallHomMap W₁.Q W₂.Q (Φ.localizedFunctor W₁.Q W₂.Q) (CatCommSq.iso _ _ _ _),
    SmallHom.equiv_comp]
Theorem: TopCat.prodIsoProd_hom_fst
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ (X.prodIsoProd Y).hom ≫ prodFst = prod.fst
state_after: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ prodFst = (X.prodBinaryFan Y).fst
tactic: simp [← Iso.eq_inv_comp, prodIsoProd]
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ prodFst = (X.prodBinaryFan Y).fst
state_after: no goals
tactic: rfl
Theorem: Real.Angle.sin_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ₁ θ₂ : Angle
⊢ (θ₁ + θ₂).sin = θ₁.sin * θ₂.cos + θ₁.cos * θ₂.sin
state_after: case h
θ₂ : Angle
x✝ : ℝ
⊢ (↑x✝ + θ₂).sin = (↑x✝).sin * θ₂.cos + (↑x✝).cos * θ₂.sin
tactic: induction θ₁ using Real.Angle.induction_on
state_before: case h
θ₂ : Angle
x✝ : ℝ
⊢ (↑x✝ + θ₂).sin = (↑x✝).sin * θ₂.cos + (↑x✝).cos * θ₂.sin
state_after: case h.h
x✝¹ x✝ : ℝ
⊢ (↑x✝¹ + ↑x✝).sin = (↑x✝¹).sin * (↑x✝).cos + (↑x✝¹).cos * (↑x✝).sin
tactic: induction θ₂ using Real.Angle.induction_on
state_before: case h.h
x✝¹ x✝ : ℝ
⊢ (↑x✝¹ + ↑x✝).sin = (↑x✝¹).sin * (↑x✝).cos + (↑x✝¹).cos * (↑x✝).sin
state_after: no goals
tactic: exact Real.sin_add _ _
Theorem: IsSubmonoid.list_prod_mem
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
hs : IsSubmonoid s
a : M
l : List M
h : ∀ x ∈ a :: l, x ∈ s
this : a * l.prod ∈ s
⊢ (a :: l).prod ∈ s
state_after: no goals
tactic: simpa
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
hs : IsSubmonoid s
a : M
l : List M
h : ∀ x ∈ a :: l, x ∈ s
⊢ a ∈ s ∧ ∀ x ∈ l, x ∈ s
state_after: no goals
tactic: simpa using h
Theorem: Nat.fib_add_two_sub_fib_add_one
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ fib (n + 2) - fib (n + 1) = fib n
state_after: no goals
tactic: rw [fib_add_two, add_tsub_cancel_right]
Theorem: Finset.Ici_erase
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : DecidableEq α
a : α
⊢ (Ici a).erase a = Ioi a
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ (Ici a).erase a ↔ a✝ ∈ Ioi a
tactic: ext
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ (Ici a).erase a ↔ a✝ ∈ Ioi a
state_after: no goals
tactic: simp_rw [Finset.mem_erase, mem_Ici, mem_Ioi, lt_iff_le_and_ne, and_comm, ne_comm]
Theorem: Stream'.const_eq
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
a : α
⊢ const a = a :: const a
state_after: case a
α : Type u
β : Type v
δ : Type w
a : α
⊢ ∀ (n : ℕ), (const a).get n = (a :: const a).get n
tactic: apply Stream'.ext
state_before: case a
α : Type u
β : Type v
δ : Type w
a : α
⊢ ∀ (n : ℕ), (const a).get n = (a :: const a).get n
state_after: case a
α : Type u
β : Type v
δ : Type w
a : α
n : ℕ
⊢ (const a).get n = (a :: const a).get n
tactic: intro n
state_before: case a
α : Type u
β : Type v
δ : Type w
a : α
n : ℕ
⊢ (const a).get n = (a :: const a).get n
state_after: no goals
tactic: cases n <;> rfl
Theorem: CategoryTheory.Square.toArrowArrowFunctor'_obj_right_right
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.Limits.biprod.add_eq_lift_id_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
X Y : C
f g : X ⟶ Y
inst✝ : HasBinaryBiproduct X X
⊢ f + g = lift (𝟙 X) (𝟙 X) ≫ desc f g
state_after: no goals
tactic: simp
Theorem: Function.Exact.inl_snd
File: Mathlib/Algebra/Exact.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
⊢ Exact ⇑(LinearMap.inl R M N) ⇑(LinearMap.snd R M N)
state_after: case mk
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
x : M
y : N
⊢ (LinearMap.snd R M N) (x, y) = 0 ↔ (x, y) ∈ Set.range ⇑(LinearMap.inl R M N)
tactic: rintro ⟨x, y⟩
state_before: case mk
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
x : M
y : N
⊢ (LinearMap.snd R M N) (x, y) = 0 ↔ (x, y) ∈ Set.range ⇑(LinearMap.inl R M N)
state_after: no goals
tactic: simp only [LinearMap.snd_apply, @eq_comm _ y, LinearMap.coe_inl, Set.mem_range, Prod.mk.injEq,
    exists_eq_left]