1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: inv_le_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ b⁻¹ ↔ b ≤ a
state_after: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ * b ≤ a * b⁻¹ * b ↔ b ≤ a

tactic: simp
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ * b ≤ a * b⁻¹ * b ↔ b ≤ a
state_after: no goals
Theorem: ProbabilityTheory.kernel.snd_zero
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp [snd]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
⊢ snd 0 = 0
state_after: no goals
Theorem: div_pos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp only [division_def, mul_pos_iff, inv_pos, inv_lt_zero]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ 0 < a / b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0
state_after: no goals
Theorem: Real.mul_lt_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← inv_div]
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ 2 / π * x < sin x
state_after: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < sin x

tactic: simpa [-inv_div, mul_inv_cancel_left₀ pi_div_two_pos.ne'] using @lt_sin_mul ((π / 2)⁻¹ * x)
  (mul_pos (inv_pos.2 pi_div_two_pos) hx) (by rwa [← div_eq_inv_mul, div_lt_one pi_div_two_pos])
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < sin x
state_after: no goals

tactic: rwa [← div_eq_inv_mul, div_lt_one pi_div_two_pos]
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < 1
state_after: no goals
Theorem: SmoothBumpFunction.support_eq_symm_image
File: Mathlib/Geometry/Manifold/BumpFunction.lean

tactic: rw [f.support_eq_inter_preimage, ← extChartAt_source I,
  ← (extChartAt I c).symm_image_target_inter_eq', inter_comm,
  ball_inter_range_eq_ball_inter_target]
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ support ↑f = ↑(extChartAt I c).symm '' (ball (↑(extChartAt I c) c) f.rOut ∩ range ↑I)
state_after: no goals
Theorem: LocalRing.isLocalRingHom_residue
File: Mathlib/RingTheory/Ideal/LocalRing.lean

tactic: constructor
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ IsLocalRingHom (residue R)
state_after: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ ∀ (a : R), IsUnit ((residue R) a) → IsUnit a

tactic: intro a ha
state_before: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
⊢ ∀ (a : R), IsUnit ((residue R) a) → IsUnit a
state_after: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
⊢ IsUnit a

tactic: by_contra h
state_before: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
⊢ IsUnit a
state_after: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
h : ¬IsUnit a
⊢ False

tactic: erw [Ideal.Quotient.eq_zero_iff_mem.mpr ((LocalRing.mem_maximalIdeal _).mpr h)] at ha
state_before: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit ((residue R) a)
h : ¬IsUnit a
⊢ False
state_after: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit 0
h : ¬IsUnit a
⊢ False

tactic: exact ha.ne_zero rfl
state_before: case map_nonunit
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁵ : CommRing R
inst✝⁴ : LocalRing R
inst✝³ : CommRing S
inst✝² : LocalRing S
inst✝¹ : CommRing T
inst✝ : LocalRing T
a : R
ha : IsUnit 0
h : ¬IsUnit a
⊢ False
state_after: no goals
Theorem: Set.ncard_diff_add_ncard_of_subset
File: Mathlib/Data/Set/Card.lean

tactic: to_encard_tac
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
h : s ⊆ t
ht : autoParam t.Finite _auto✝
⊢ (t \ s).ncard + s.ncard = t.ncard
state_after: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
h : s ⊆ t
ht : autoParam t.Finite _auto✝
⊢ ↑(t \ s).ncard + ↑s.ncard = ↑t.ncard

tactic: rw [ht.cast_ncard_eq, (ht.subset h).cast_ncard_eq, (ht.diff _).cast_ncard_eq,
  encard_diff_add_encard_of_subset h]
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
h : s ⊆ t
ht : autoParam t.Finite _auto✝
⊢ ↑(t \ s).ncard + ↑s.ncard = ↑t.ncard
state_after: no goals
Theorem: EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius
File: Mathlib/Geometry/Euclidean/Angle/Sphere.lean

tactic: rw [← dist_div_cos_oangle_center_div_two_eq_radius hp₁ hp₂ h, mul_div_cancel₀ _ (two_ne_zero' ℝ)]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : Sphere P
p₁ p₂ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
h : p₁ ≠ p₂
⊢ dist p₁ p₂ / (∡ p₂ p₁ s.center).cos = 2 * s.radius
state_after: no goals
Theorem: CategoryTheory.shiftFunctorAdd'_add_zero
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: ext
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
⊢ shiftFunctorAdd' C a 0 a ⋯ =
    (shiftFunctor C a).rightUnitor.symm ≪≫ isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ (shiftFunctorAdd' C a 0 a ⋯).hom.app x✝ =
    ((shiftFunctor C a).rightUnitor.symm ≪≫ isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm).hom.app x✝

tactic: dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ (shiftFunctorAdd' C a 0 a ⋯).hom.app x✝ =
    ((shiftFunctor C a).rightUnitor.symm ≪≫ isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm).hom.app x✝
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ (eqToHom ⋯).app x✝ ≫ (shiftFunctorAdd C a 0).hom.app x✝ =
    𝟙 (((shiftMonoidalFunctor C A).obj { as := a }).obj x✝) ≫
      (shiftMonoidalFunctor C A).ε.app (((shiftMonoidalFunctor C A).obj { as := a }).obj x✝)

tactic: simp only [eqToHom_app, ε_app_obj, Discrete.addMonoidal_rightUnitor, eqToIso.inv,
  eqToHom_map, Category.id_comp]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ (eqToHom ⋯).app x✝ ≫ (shiftFunctorAdd C a 0).hom.app x✝ =
    𝟙 (((shiftMonoidalFunctor C A).obj { as := a }).obj x✝) ≫
      (shiftMonoidalFunctor C A).ε.app (((shiftMonoidalFunctor C A).obj { as := a }).obj x✝)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ eqToHom ⋯ ≫ (shiftFunctorAdd C a 0).hom.app x✝ =
    eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a } (𝟙_ (Discrete A))).inv.app x✝

tactic: rfl
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
x✝ : C
⊢ eqToHom ⋯ ≫ (shiftFunctorAdd C a 0).hom.app x✝ =
    eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a } (𝟙_ (Discrete A))).inv.app x✝
state_after: no goals
Theorem: Matrix.Fin.transpose_circulant
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective, eq_iff_true_of_subsingleton]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
R : Type u_5
⊢ ∀ (v : Fin 0 → α), (circulant v)ᵀ = circulant fun i => v (-i)
state_after: no goals
Theorem: Nat.le_floor_iff'
File: Mathlib/Algebra/Order/Floor.lean

tactic: obtain ha | ha := le_total a 0
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
⊢ n ≤ ⌊a⌋₊ ↔ ↑n ≤ a
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : a ≤ 0
⊢ n ≤ ⌊a⌋₊ ↔ ↑n ≤ a

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : 0 ≤ a
⊢ n ≤ ⌊a⌋₊ ↔ ↑n ≤ a

tactic: rw [floor_of_nonpos ha]
state_before: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : a ≤ 0
⊢ n ≤ ⌊a⌋₊ ↔ ↑n ≤ a
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : a ≤ 0
⊢ n ≤ 0 ↔ ↑n ≤ a

tactic: exact
  iff_of_false (Nat.pos_of_ne_zero hn).not_le
    (not_le_of_lt <| ha.trans_lt <| cast_pos.2 <| Nat.pos_of_ne_zero hn)
state_before: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : a ≤ 0
⊢ n ≤ 0 ↔ ↑n ≤ a
state_after: no goals

tactic: exact le_floor_iff ha
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
ha : 0 ≤ a
⊢ n ≤ ⌊a⌋₊ ↔ ↑n ≤ a
state_after: no goals
Theorem: Real.nnabs_coe
File: Mathlib/Data/NNReal/Basic.lean

tactic: simp
state_before: x : ℝ≥0
⊢ nnabs ↑x = x
state_after: no goals
Theorem: PartENat.toWithTop_zero'
File: Mathlib/Data/Nat/PartENat.lean

tactic: convert toWithTop_zero
state_before: h : Decidable (Dom 0)
⊢ toWithTop 0 = 0
state_after: no goals
Theorem: algebraMap_monotone
File: Mathlib/Algebra/Order/Algebra.lean

tactic: rw [Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one, ← sub_nonneg, ← sub_smul]
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ (algebraMap R A) a ≤ (algebraMap R A) b
state_after: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 1

tactic: trans (b - a) • (0 : A)
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 1
state_after: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 0

R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ (b - a) • 0 ≤ (b - a) • 1

tactic: simp
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 0
state_after: no goals

tactic: exact smul_le_smul_of_nonneg_left zero_le_one (sub_nonneg.mpr h)
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ (b - a) • 0 ≤ (b - a) • 1
state_after: no goals
Theorem: AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullback_snd_isIso_of_range_subset
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: apply (config := {allowSynthFailures := true}) Functor.ReflectsIsomorphisms.reflects
  (F := LocallyRingedSpace.forgetToSheafedSpace)
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso pullback.snd
state_after: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso (forgetToSheafedSpace.map pullback.snd)

tactic: apply (config := {allowSynthFailures := true}) Functor.ReflectsIsomorphisms.reflects
  (F := SheafedSpace.forgetToPresheafedSpace)
state_before: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso (forgetToSheafedSpace.map pullback.snd)
state_after: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso (SheafedSpace.forgetToPresheafedSpace.map (forgetToSheafedSpace.map pullback.snd))

tactic: erw [← PreservesPullback.iso_hom_snd
    (LocallyRingedSpace.forgetToSheafedSpace ⋙ SheafedSpace.forgetToPresheafedSpace) f g]
state_before: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso (SheafedSpace.forgetToPresheafedSpace.map (forgetToSheafedSpace.map pullback.snd))
state_after: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso ((PreservesPullback.iso (forgetToSheafedSpace ⋙ SheafedSpace.forgetToPresheafedSpace) f g).hom ≫ pullback.snd)

tactic: exact @IsIso.comp_isIso _ _ _ _ _ _ _ _ <|
  PresheafedSpace.IsOpenImmersion.pullback_snd_isIso_of_range_subset _ _ H'
state_before: case inst
C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ IsIso ((PreservesPullback.iso (forgetToSheafedSpace ⋙ SheafedSpace.forgetToPresheafedSpace) f g).hom ≫ pullback.snd)
state_after: no goals
Theorem: Finsupp.toMultiset_strictMono
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: classical exact (@orderIsoMultiset ι _).strictMono
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
⊢ StrictMono ⇑toMultiset
state_after: no goals

tactic: exact (@orderIsoMultiset ι _).strictMono
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
⊢ StrictMono ⇑toMultiset
state_after: no goals
Theorem: SeparationQuotient.map_mk_nhds
File: Mathlib/Topology/Inseparable.lean

tactic: rw [← comap_mk_nhds_mk, map_comap_of_surjective surjective_mk]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
⊢ Filter.map mk (𝓝 x) = 𝓝 (mk x)
state_after: no goals
Theorem: integrableOn_Icc_iff_integrableOn_Ioc'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: by_cases hab : a ≤ b
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioc a b) μ
state_after: case pos
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioc a b) μ

case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : ¬a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioc a b) μ

tactic: rw [← Ioc_union_left hab, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr ha.lt_top), and_true_iff]
state_before: case pos
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioc a b) μ
state_after: no goals

tactic: rw [Icc_eq_empty hab, Ioc_eq_empty]
state_before: case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : ¬a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioc a b) μ
state_after: case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : ¬a ≤ b
⊢ ¬a < b

tactic: contrapose! hab
state_before: case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : ¬a ≤ b
⊢ ¬a < b
state_after: case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : a < b
⊢ a ≤ b

tactic: exact hab.le
state_before: case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hab : a < b
⊢ a ≤ b
state_after: no goals
Theorem: Int.natAbs_ediv
File: Mathlib/Data/Int/Defs.lean

tactic: rcases Nat.eq_zero_or_pos (natAbs b) with (h | h)
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
⊢ (a / b).natAbs = a.natAbs / b.natAbs
state_after: case inl
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs = 0
⊢ (a / b).natAbs = a.natAbs / b.natAbs

case inr
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs = a.natAbs / b.natAbs

tactic: calc
  natAbs (a / b) = natAbs (a / b) * 1 := by rw [Nat.mul_one]
  _ = natAbs (a / b) * (natAbs b / natAbs b) := by rw [Nat.div_self h]
  _ = natAbs (a / b) * natAbs b / natAbs b := by rw [Nat.mul_div_assoc _ b.natAbs.dvd_refl]
  _ = natAbs (a / b * b) / natAbs b := by rw [natAbs_mul (a / b) b]
  _ = natAbs a / natAbs b := by rw [Int.ediv_mul_cancel H]
state_before: case inr
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs = a.natAbs / b.natAbs
state_after: no goals

tactic: rw [natAbs_eq_zero.1 h]
state_before: case inl
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs = 0
⊢ (a / b).natAbs = a.natAbs / b.natAbs
state_after: case inl
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs = 0
⊢ (a / 0).natAbs = a.natAbs / natAbs 0

tactic: simp [Int.ediv_zero]
state_before: case inl
a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs = 0
⊢ (a / 0).natAbs = a.natAbs / natAbs 0
state_after: no goals

tactic: rw [Nat.mul_one]
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs = (a / b).natAbs * 1
state_after: no goals

tactic: rw [Nat.div_self h]
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs * 1 = (a / b).natAbs * (b.natAbs / b.natAbs)
state_after: no goals

tactic: rw [Nat.mul_div_assoc _ b.natAbs.dvd_refl]
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs * (b.natAbs / b.natAbs) = (a / b).natAbs * b.natAbs / b.natAbs
state_after: no goals

tactic: rw [natAbs_mul (a / b) b]
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b).natAbs * b.natAbs / b.natAbs = (a / b * b).natAbs / b.natAbs
state_after: no goals

tactic: rw [Int.ediv_mul_cancel H]
state_before: a✝ b✝ c d m n a b : ℤ
H : b ∣ a
h : b.natAbs > 0
⊢ (a / b * b).natAbs / b.natAbs = a.natAbs / b.natAbs
state_after: no goals
Theorem: TensorProduct.tmul_ite
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: split_ifs <;> simp
state_before: R : Type u_1
inst✝¹⁹ : CommSemiring R
R' : Type u_2
inst✝¹⁸ : Monoid R'
R'' : Type u_3
inst✝¹⁷ : Semiring R''
M : Type u_4
N : Type u_5
P✝ : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : AddCommMonoid N
inst✝¹⁴ : AddCommMonoid P✝
inst✝¹³ : AddCommMonoid Q
inst✝¹² : AddCommMonoid S
inst✝¹¹ : AddCommMonoid T
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P✝
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : Module R T
inst✝⁴ : DistribMulAction R' M
inst✝³ : Module R'' M
inst✝² : SMulCommClass R R' M
inst✝¹ : SMulCommClass R R'' M
x₁ : M
x₂ : N
P : Prop
inst✝ : Decidable P
⊢ (x₁ ⊗ₜ[R] if P then x₂ else 0) = if P then x₁ ⊗ₜ[R] x₂ else 0
state_after: no goals
Theorem: ZMod.val_eq_ite_valMinAbs
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [valMinAbs_def_pos]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = a.valMinAbs + ↑(if a.val ≤ n / 2 then 0 else n)
state_after: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = (if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n) + ↑(if a.val ≤ n / 2 then 0 else n)

tactic: split_ifs <;> simp [add_zero, sub_add_cancel]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = (if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n) + ↑(if a.val ≤ n / 2 then 0 else n)
state_after: no goals
Theorem: PadicInt.maximalIdeal_eq_span_p
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: apply le_antisymm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ maximalIdeal ℤ_[p] = Ideal.span {↑p}
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ maximalIdeal ℤ_[p] ≤ Ideal.span {↑p}

case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ Ideal.span {↑p} ≤ maximalIdeal ℤ_[p]

tactic: intro x hx
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ maximalIdeal ℤ_[p] ≤ Ideal.span {↑p}
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ∈ maximalIdeal ℤ_[p]
⊢ x ∈ Ideal.span {↑p}

tactic: simp only [LocalRing.mem_maximalIdeal, mem_nonunits] at hx
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ∈ maximalIdeal ℤ_[p]
⊢ x ∈ Ideal.span {↑p}
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ‖x‖ < 1
⊢ x ∈ Ideal.span {↑p}

tactic: rwa [Ideal.mem_span_singleton, ← norm_lt_one_iff_dvd]
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ‖x‖ < 1
⊢ x ∈ Ideal.span {↑p}
state_after: no goals

tactic: rw [Ideal.span_le, Set.singleton_subset_iff]
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ Ideal.span {↑p} ≤ maximalIdeal ℤ_[p]
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ ↑p ∈ ↑(maximalIdeal ℤ_[p])

tactic: exact p_nonnunit
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ ↑p ∈ ↑(maximalIdeal ℤ_[p])
state_after: no goals