1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlgebraicGeometry.IsOpenImmersion.range_pullback_to_base_of_right
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

tactic: rw [Scheme.comp_val_base, TopCat.coe_comp, Set.range_comp, range_pullback_fst_of_right,
  Opens.map_obj, Opens.carrier_eq_coe, Opens.coe_mk, Set.image_preimage_eq_inter_range,
  Set.inter_comm]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Set.range ⇑(pullback.fst ≫ g).val.base = Set.range ⇑g.val.base ∩ Set.range ⇑f.val.base
state_after: no goals
Theorem: EuclideanGeometry.angle_lt_pi_div_two_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2

tactic: rw [ne_comm, ← @vsub_ne_zero V] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ < π / 2

tactic: rw [angle, ← vsub_add_vsub_cancel p₁ p₂ p₃, add_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) < π / 2

tactic: exact angle_add_lt_pi_div_two_of_inner_eq_zero h h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) < π / 2
state_after: no goals
Theorem: LaurentPolynomial.single_eq_C_mul_T
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: simp [C, T, single_mul_single]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
n : ℤ
⊢ Finsupp.single n r = C r * T n
state_after: no goals
Theorem: Nat.minFac_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: simp [n1]
state_before: n✝ n : ℕ
n1 : n = 1
⊢ n.minFac ∣ n
state_after: no goals
Theorem: IsNilpotent.isUnit_sub_one
File: Mathlib/RingTheory/Nilpotent/Basic.lean

tactic: obtain ⟨n, hn⟩ := hnil
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (r - 1)
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ IsUnit (r - 1)

tactic: refine ⟨⟨r - 1, -∑ i ∈ Finset.range n, r ^ i, ?_, ?_⟩, rfl⟩
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ IsUnit (r - 1)
state_after: case intro.refine_1
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ (r - 1) * -∑ i ∈ Finset.range n, r ^ i = 1

case intro.refine_2
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ (-∑ i ∈ Finset.range n, r ^ i) * (r - 1) = 1

tactic: simp [mul_geom_sum, hn]
state_before: case intro.refine_1
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ (r - 1) * -∑ i ∈ Finset.range n, r ^ i = 1
state_after: no goals

tactic: simp [geom_sum_mul, hn]
state_before: case intro.refine_2
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
n : ℕ
hn : r ^ n = 0
⊢ (-∑ i ∈ Finset.range n, r ^ i) * (r - 1) = 1
state_after: no goals
Theorem: WeierstrassCurve.VariableChange.comp_map
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [comp, map]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ map φ (C.comp C') = (map φ C).comp (map φ C')
state_after: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ { u := (Units.map ↑φ) (C.u * C'.u), r := φ (C.r * ↑C'.u ^ 2 + C'.r), s := φ (↑C'.u * C.s + C'.s),
      t := φ (C.t * ↑C'.u ^ 3 + C.r * C'.s * ↑C'.u ^ 2 + C'.t) } =
    { u := (Units.map ↑φ) C.u * (Units.map ↑φ) C'.u, r := φ C.r * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.r,
      s := ↑((Units.map ↑φ) C'.u) * φ C.s + φ C'.s,
      t := φ C.t * ↑((Units.map ↑φ) C'.u) ^ 3 + φ C.r * φ C'.s * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.t }

tactic: ext <;> map_simp <;> simp only [Units.coe_map, Units.coe_map_inv, MonoidHom.coe_coe]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ { u := (Units.map ↑φ) (C.u * C'.u), r := φ (C.r * ↑C'.u ^ 2 + C'.r), s := φ (↑C'.u * C.s + C'.s),
      t := φ (C.t * ↑C'.u ^ 3 + C.r * C'.s * ↑C'.u ^ 2 + C'.t) } =
    { u := (Units.map ↑φ) C.u * (Units.map ↑φ) C'.u, r := φ C.r * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.r,
      s := ↑((Units.map ↑φ) C'.u) * φ C.s + φ C'.s,
      t := φ C.t * ↑((Units.map ↑φ) C'.u) ^ 3 + φ C.r * φ C'.s * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.t }
state_after: no goals
Theorem: wcovBy_eq_reflGen_covBy
File: Mathlib/Order/Cover.lean

tactic: ext x y
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
⊢ (fun x x_1 => x ⩿ x_1) = ReflGen fun x x_1 => x ⋖ x_1
state_after: case h.h.a
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
x y : α
⊢ x ⩿ y ↔ ReflGen (fun x x_1 => x ⋖ x_1) x y

tactic: simp_rw [wcovBy_iff_eq_or_covBy, @eq_comm _ x, reflGen_iff]
state_before: case h.h.a
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
x y : α
⊢ x ⩿ y ↔ ReflGen (fun x x_1 => x ⋖ x_1) x y
state_after: no goals
Theorem: IsPoly.add
File: Mathlib/NumberTheory/Dioph.lean

tactic: rw [← sub_neg_eq_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : (α → ℕ) → ℤ
hf : IsPoly f
hg : IsPoly g
⊢ IsPoly (f + g)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f g : (α → ℕ) → ℤ
hf : IsPoly f
hg : IsPoly g
⊢ IsPoly (f - -g)

tactic: exact hf.sub hg.neg
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : (α → ℕ) → ℤ
hf : IsPoly f
hg : IsPoly g
⊢ IsPoly (f - -g)
state_after: no goals
Theorem: Module.End.IsSemisimple_smul
File: Mathlib/LinearAlgebra/Semisimple.lean

tactic: wlog ht : t ≠ 0
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
h : f.IsSemisimple
⊢ (t • f).IsSemisimple
state_after: case inr
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
h : f.IsSemisimple
this :
  ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst : Module R M] {K : Type u_3}
    [inst : Field K] [inst_2 : Module K M] {f : End K M} {g : End K M} (t : K),
    f.IsSemisimple → t ≠ 0 → (t • f).IsSemisimple
ht : ¬t ≠ 0
⊢ (t • f).IsSemisimple

M✝ : Type u_2
inst✝⁷ : AddCommGroup M✝
K✝ : Type u_3
inst✝⁶ : Field K✝
inst✝⁵ : Module K✝ M✝
f✝ : End K✝ M✝
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
h : f.IsSemisimple
ht : t ≠ 0
⊢ (t • f).IsSemisimple

tactic: rwa [IsSemisimple_smul_iff ht]
state_before: M✝ : Type u_2
inst✝⁷ : AddCommGroup M✝
K✝ : Type u_3
inst✝⁶ : Field K✝
inst✝⁵ : Module K✝ M✝
f✝ : End K✝ M✝
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
h : f.IsSemisimple
ht : t ≠ 0
⊢ (t • f).IsSemisimple
state_after: no goals

tactic: simp [not_not.mp ht]
state_before: case inr
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
h : f.IsSemisimple
this :
  ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst : Module R M] {K : Type u_3}
    [inst : Field K] [inst_2 : Module K M] {f : End K M} {g : End K M} (t : K),
    f.IsSemisimple → t ≠ 0 → (t • f).IsSemisimple
ht : ¬t ≠ 0
⊢ (t • f).IsSemisimple
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.self_eq_mass_mul_normalize
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: obtain rfl | h := eq_or_ne μ 0
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
⊢ μ s = μ.mass * μ.normalize s
state_after: case inl
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
s : Set Ω
⊢ 0 s = mass 0 * (normalize 0) s

case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
⊢ μ s = μ.mass * μ.normalize s

tactic: have mass_nonzero : μ.mass ≠ 0 := by rwa [μ.mass_nonzero_iff]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
⊢ μ s = μ.mass * μ.normalize s
state_after: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : μ.mass ≠ 0
⊢ μ s = μ.mass * μ.normalize s

tactic: simp only [normalize, dif_neg mass_nonzero]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : μ.mass ≠ 0
⊢ μ s = μ.mass * μ.normalize s
state_after: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : μ.mass ≠ 0
⊢ μ s = μ.mass * ⟨↑(μ.mass⁻¹ • μ), ⋯⟩ s

tactic: simp [ProbabilityMeasure.coe_mk, toMeasure_smul, mul_inv_cancel_left₀ mass_nonzero, coeFn_def]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : μ.mass ≠ 0
⊢ μ s = μ.mass * ⟨↑(μ.mass⁻¹ • μ), ⋯⟩ s
state_after: no goals

tactic: simp
state_before: case inl
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
s : Set Ω
⊢ 0 s = mass 0 * (normalize 0) s
state_after: no goals

tactic: rwa [μ.mass_nonzero_iff]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
⊢ μ.mass ≠ 0
state_after: no goals
Theorem: MeasureTheory.Measure.addHaar_closedBall_mul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: have : closedBall (0 : E) (r * s) = r • closedBall (0 : E) s := by
  simp [smul_closedBall r (0 : E) hs, abs_of_nonneg hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)

tactic: simp only [this, addHaar_smul, abs_of_nonneg hr, addHaar_closedBall_center, abs_pow]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: no goals

tactic: simp [smul_closedBall r (0 : E) hs, abs_of_nonneg hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
⊢ closedBall 0 (r * s) = r • closedBall 0 s
state_after: no goals
Theorem: BoundedContinuousFunction.integral_eq_integral_nnrealPart_sub
File: Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean

tactic: simp only [f.self_eq_nnrealPart_sub_nnrealPart_neg, Pi.sub_apply, integral_sub,
           integrable_of_nnreal]
state_before: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasure μ
f : X →ᵇ ℝ
⊢ ∫ (x : X), f x ∂μ = ∫ (x : X), ↑(f.nnrealPart x) ∂μ - ∫ (x : X), ↑((-f).nnrealPart x) ∂μ
state_after: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasure μ
f : X →ᵇ ℝ
⊢ ∫ (a : X), (NNReal.toReal ∘ ⇑f.nnrealPart) a ∂μ - ∫ (a : X), (NNReal.toReal ∘ ⇑(-f).nnrealPart) a ∂μ =
    ∫ (x : X), ↑(f.nnrealPart x) ∂μ - ∫ (x : X), ↑((-f).nnrealPart x) ∂μ

tactic: simp only [Function.comp_apply]
state_before: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasure μ
f : X →ᵇ ℝ
⊢ ∫ (a : X), (NNReal.toReal ∘ ⇑f.nnrealPart) a ∂μ - ∫ (a : X), (NNReal.toReal ∘ ⇑(-f).nnrealPart) a ∂μ =
    ∫ (x : X), ↑(f.nnrealPart x) ∂μ - ∫ (x : X), ↑((-f).nnrealPart x) ∂μ
state_after: no goals
Theorem: Set.empty_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', empty_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
state_after: no goals
Theorem: TopCat.Presheaf.SheafConditionEqualizerProducts.res_π
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

tactic: rw [res, limit.lift_π, Fan.mk_π_app]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
i : ι
⊢ res F U ≫ limit.π (Discrete.functor fun i => F.obj { unop := U i }) { as := i } = F.map (leSupr U i).op
state_after: no goals
Theorem: Ideal.associatesEquivIsPrincipal_mul
File: Mathlib/RingTheory/Ideal/IsPrincipal.lean

tactic: rw [← Associates.quot_out x, ← Associates.quot_out y]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
x y : Associates R
⊢ ↑((associatesEquivIsPrincipal R) (x * y)) = ↑((associatesEquivIsPrincipal R) x) * ↑((associatesEquivIsPrincipal R) y)
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
x y : Associates R
⊢ ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out x) * Associates.mk (Quot.out y))) =
    ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out x))) *
      ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out y)))

tactic: simp_rw [Associates.mk_mul_mk, ← Associates.quotient_mk_eq_mk, associatesEquivIsPrincipal_apply,
  span_singleton_mul_span_singleton]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
x y : Associates R
⊢ ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out x) * Associates.mk (Quot.out y))) =
    ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out x))) *
      ↑((associatesEquivIsPrincipal R) (Associates.mk (Quot.out y)))
state_after: no goals
Theorem: MeasureTheory.locallyIntegrableOn_univ
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: simp only [LocallyIntegrableOn, nhdsWithin_univ, mem_univ, true_imp_iff]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ LocallyIntegrableOn f univ μ ↔ LocallyIntegrable f μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ (∀ (x : X), IntegrableAtFilter f (𝓝 x) μ) ↔ LocallyIntegrable f μ

tactic: rfl
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ (∀ (x : X), IntegrableAtFilter f (𝓝 x) μ) ↔ LocallyIntegrable f μ
state_after: no goals
Theorem: CategoryTheory.NatTrans.exchange
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G H I✝ : C ⥤ D
I J K : D ⥤ E
α : F ⟶ G
β : G ⟶ H
γ : I ⟶ J
δ : J ⟶ K
⊢ (α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫ δ
state_after: no goals
Theorem: dNext_eq_zero
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [dNext]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ (dNext i) f = 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ C.d i (c.next i) ≫ f (c.next i) i = 0

tactic: rw [shape _ _ _ hi, zero_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ C.d i (c.next i) ≫ f (c.next i) i = 0
state_after: no goals
Theorem: LinearMap.trace_eq_matrix_trace
File: Mathlib/LinearAlgebra/Trace.lean

tactic: rw [trace_eq_matrix_trace_of_finset R b.reindexFinsetRange, ← traceAux_def, ← traceAux_def,
  traceAux_eq R b b.reindexFinsetRange]
state_before: R : Type u
inst✝⁶ : CommSemiring R
M : Type v
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
ι : Type w
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : Fintype κ
b : Basis ι R M
c : Basis κ R M
f : M →ₗ[R] M
⊢ (trace R M) f = ((toMatrix b b) f).trace
state_after: no goals
Theorem: Function.Embedding.equiv_symm_toEmbedding_trans_toEmbedding
File: Mathlib/Logic/Embedding/Basic.lean

tactic: ext
state_before: α : Sort u_1
β : Sort u_2
e : α ≃ β
⊢ e.symm.toEmbedding.trans e.toEmbedding = Embedding.refl β
state_after: case h
α : Sort u_1
β : Sort u_2
e : α ≃ β
x✝ : β
⊢ (e.symm.toEmbedding.trans e.toEmbedding) x✝ = (Embedding.refl β) x✝

tactic: simp
state_before: case h
α : Sort u_1
β : Sort u_2
e : α ≃ β
x✝ : β
⊢ (e.symm.toEmbedding.trans e.toEmbedding) x✝ = (Embedding.refl β) x✝
state_after: no goals
Theorem: div_left_inj
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ b / a = c / a ↔ b = c
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ b * a⁻¹ = c * a⁻¹ ↔ b = c

tactic: exact mul_left_inj _
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ b * a⁻¹ = c * a⁻¹ ↔ b = c
state_after: no goals
Theorem: iUnion_compactCovering
File: Mathlib/Topology/Compactness/SigmaCompact.lean

tactic: rw [compactCovering, iUnion_accumulate]
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
⊢ ⋃ n, compactCovering X n = univ
state_after: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
⊢ ⋃ x, ⋯.choose x = univ

tactic: exact (Classical.choose_spec SigmaCompactSpace.exists_compact_covering).2
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
⊢ ⋃ x, ⋯.choose x = univ
state_after: no goals
Theorem: MeasureTheory.IsProjectiveLimit.measure_univ_unique
File: Mathlib/MeasureTheory/Constructions/Projective.lean

tactic: rw [hμ.measure_univ_eq (∅ : Finset ι), hν.measure_univ_eq (∅ : Finset ι)]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
⊢ μ univ = ν univ
state_after: no goals
Theorem: Num.castNum_and
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> rfl
state_before: α : Type u_1
⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n
state_after: no goals

tactic: try cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).land (PosNum.bit b✝ n✝) = bit (a✝ && b✝) (m✝.land n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).land (PosNum.bit false n✝) = bit (false && false) (m✝.land n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).land (PosNum.bit true n✝) = bit (false && true) (m✝.land n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).land (PosNum.bit false n✝) = bit (true && false) (m✝.land n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).land (PosNum.bit true n✝) = bit (true && true) (m✝.land n✝)

tactic: cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).land (PosNum.bit b✝ n✝) = bit (a✝ && b✝) (m✝.land n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).land (PosNum.bit false n✝) = bit (false && false) (m✝.land n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).land (PosNum.bit true n✝) = bit (false && true) (m✝.land n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).land (PosNum.bit false n✝) = bit (true && false) (m✝.land n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).land (PosNum.bit true n✝) = bit (true && true) (m✝.land n✝)