1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: eq_zero_of_spectrum_subset_zero
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: simpa using eq_algebraMap_of_spectrum_subset_singleton a 0 h_spec
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommSemiring R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝ : UniqueContinuousFunctionalCalculus R A
h_spec : spectrum R a ⊆ {0}
ha : autoParam (p a) _auto✝
⊢ a = 0
state_after: no goals
Theorem: Nat.multiplicative_factorization'
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: obtain rfl | hn := eq_or_ne n 0
state_before: a b m n p : ℕ
β : Type u_1
inst✝ : CommMonoid β
f : ℕ → β
h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y
hf0 : f 0 = 1
hf1 : f 1 = 1
⊢ f n = n.factorization.prod fun p k => f (p ^ k)
state_after: case inl
a b m p : ℕ
β : Type u_1
inst✝ : CommMonoid β
f : ℕ → β
h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y
hf0 : f 0 = 1
hf1 : f 1 = 1
⊢ f 0 = (factorization 0).prod fun p k => f (p ^ k)

case inr
a b m n p : ℕ
β : Type u_1
inst✝ : CommMonoid β
f : ℕ → β
h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y
hf0 : f 0 = 1
hf1 : f 1 = 1
hn : n ≠ 0
⊢ f n = n.factorization.prod fun p k => f (p ^ k)

tactic: simpa
state_before: case inl
a b m p : ℕ
β : Type u_1
inst✝ : CommMonoid β
f : ℕ → β
h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y
hf0 : f 0 = 1
hf1 : f 1 = 1
⊢ f 0 = (factorization 0).prod fun p k => f (p ^ k)
state_after: no goals

tactic: exact multiplicative_factorization _ h_mult hf1 hn
state_before: case inr
a b m n p : ℕ
β : Type u_1
inst✝ : CommMonoid β
f : ℕ → β
h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y
hf0 : f 0 = 1
hf1 : f 1 = 1
hn : n ≠ 0
⊢ f n = n.factorization.prod fun p k => f (p ^ k)
state_after: no goals
Theorem: Complex.dist_of_re_eq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [dist_eq_re_im, h, sub_self, zero_pow two_ne_zero, zero_add, Real.sqrt_sq_eq_abs, Real.dist_eq]
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
h : z.re = w.re
⊢ dist z w = dist z.im w.im
state_after: no goals
Theorem: Polynomial.support_C_mul_X
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [C_mul_X_eq_monomial, support_monomial 1 h]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
c : R
h : c ≠ 0
⊢ (C c * X).support = {1}
state_after: no goals
Theorem: Equiv.Perm.Disjoint.cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [cycleType_def, cycleType_def, cycleType_def, h.cycleFactorsFinset_mul_eq_union, ←
  Multiset.map_add, Finset.union_val, Multiset.add_eq_union_iff_disjoint.mpr _]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.Disjoint τ
⊢ (σ * τ).cycleType = σ.cycleType + τ.cycleType
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.Disjoint τ
⊢ σ.cycleFactorsFinset.val.Disjoint τ.cycleFactorsFinset.val

tactic: exact Finset.disjoint_val.2 h.disjoint_cycleFactorsFinset
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.Disjoint τ
⊢ σ.cycleFactorsFinset.val.Disjoint τ.cycleFactorsFinset.val
state_after: no goals
Theorem: fourierCoeff_eq_intervalIntegral
File: Mathlib/Analysis/Fourier/AddCircle.lean

tactic: have : ∀ x : ℝ, @fourier T (-n) x • f x = (fun z : AddCircle T => @fourier T (-n) z • f z) x := by
  intro x; rfl
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
⊢ fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fourier (-n)) ↑x • f ↑x
state_after: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
this : ∀ (x : ℝ), (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
⊢ fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fourier (-n)) ↑x • f ↑x

tactic: simp_rw (config := {singlePass := true}) [this]
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
this : ∀ (x : ℝ), (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
⊢ fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fourier (-n)) ↑x • f ↑x
state_after: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
this : ∀ (x : ℝ), (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
⊢ fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fun z => (fourier (-n)) z • f z) ↑x

tactic: rw [fourierCoeff, AddCircle.intervalIntegral_preimage T a (fun z => _ • _),
  volume_eq_smul_haarAddCircle, integral_smul_measure, ENNReal.toReal_ofReal hT.out.le,
  ← smul_assoc, smul_eq_mul, one_div_mul_cancel hT.out.ne', one_smul]
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
this : ∀ (x : ℝ), (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
⊢ fourierCoeff f n = (1 / T) • ∫ (x : ℝ) in a..a + T, (fun z => (fourier (-n)) z • f z) ↑x
state_after: no goals

tactic: intro x
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a : ℝ
⊢ ∀ (x : ℝ), (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
state_after: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a x : ℝ
⊢ (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x

tactic: rfl
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : AddCircle T → E
n : ℤ
a x : ℝ
⊢ (fourier (-n)) ↑x • f ↑x = (fun z => (fourier (-n)) z • f z) ↑x
state_after: no goals
Theorem: MeasureTheory.Conservative.ae_forall_image_mem_imp_frequently_image_mem
File: Mathlib/Dynamics/Ergodic/Conservative.lean

tactic: refine ae_all_iff.2 fun k => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
⊢ ∀ᵐ (x : α) ∂μ, ∀ (k : ℕ), f^[k] x ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
⊢ ∀ᵐ (a : α) ∂μ, f^[k] a ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] a ∈ s

tactic: refine (hf.ae_mem_imp_frequently_image_mem (hf.measurable.iterate k hs)).mono fun x hx hk => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
⊢ ∀ᵐ (a : α) ∂μ, f^[k] a ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] a ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s

tactic: rw [← map_add_atTop_eq_nat k, frequently_map]
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (a : ℕ) in atTop, f^[a + k] x ∈ s

tactic: refine (hx hk).mono fun n hn => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (a : ℕ) in atTop, f^[a + k] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
n : ℕ
hn : f^[n] x ∈ f^[k] ⁻¹' s
⊢ f^[n + k] x ∈ s

tactic: rwa [add_comm, iterate_add_apply]
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
n : ℕ
hn : f^[n] x ∈ f^[k] ⁻¹' s
⊢ f^[n + k] x ∈ s
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isInt_emod_zero
File: Mathlib/Tactic/NormNum/DivMod.lean

tactic: simp [e]
state_before: x✝¹ x✝ : ℤ
e : IsInt x✝¹ x✝
⊢ IsInt (x✝¹ % ↑0) x✝
state_after: no goals
Theorem: wittPolynomial_vars_subset
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: rw [← map_wittPolynomial p (Int.castRingHom R), ← wittPolynomial_vars p ℤ]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type u_2
inst✝ : CommRing S
hp : NeZero p
n : ℕ
⊢ (W_ R n).vars ⊆ range (n + 1)
state_after: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type u_2
inst✝ : CommRing S
hp : NeZero p
n : ℕ
⊢ ((map (Int.castRingHom R)) (W_ ℤ n)).vars ⊆ (W_ ℤ n).vars

tactic: apply vars_map
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type u_2
inst✝ : CommRing S
hp : NeZero p
n : ℕ
⊢ ((map (Int.castRingHom R)) (W_ ℤ n)).vars ⊆ (W_ ℤ n).vars
state_after: no goals
Theorem: map_mul_inv
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: rw [map_mul, map_inv]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
a b : G
⊢ f (a * b⁻¹) = f a * (f b)⁻¹
state_after: no goals
Theorem: Cardinal.mk_multiset_of_infinite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp
state_before: α : Type u
inst✝ : Infinite α
⊢ #(Multiset α) = #α
state_after: no goals
Theorem: Field.rank_mul_sepDegree_of_isSeparable
File: Mathlib/FieldTheory/PurelyInseparable.lean

tactic: simpa only [Cardinal.lift_id] using lift_rank_mul_lift_sepDegree_of_isSeparable F E K
state_before: F : Type u
E : Type v
inst✝¹¹ : Field F
inst✝¹⁰ : Field E
inst✝⁹ : Algebra F E
K✝ : Type w
inst✝⁸ : Field K✝
inst✝⁷ : Algebra F K✝
inst✝⁶ : Algebra E K✝
inst✝⁵ : IsScalarTower F E K✝
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : IsSeparable F E
⊢ Module.rank F E * sepDegree E K = sepDegree F K
state_after: no goals
Theorem: imageToKernel_op
File: Mathlib/Algebra/Homology/Opposite.lean

tactic: rw [← op_comp, w, op_zero]
state_before: V : Type u_1
inst✝¹ : Category.{?u.28, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.op ≫ f.op = 0
state_after: no goals

tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type u_1
inst✝¹ : Category.{?u.28, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0
state_after: no goals

tactic: ext
state_before: V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ =
    (imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ ≫ (kernelSubobject f.op).arrow =
    ((imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv) ≫
      (kernelSubobject f.op).arrow

tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelOpOp_inv, Category.assoc,
  imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, ← op_comp, cokernel.π_desc,
  ← imageSubobject_arrow, ← imageUnopOp_inv_comp_op_factorThruImage g.op]
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ ≫ (kernelSubobject f.op).arrow =
    ((imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv) ≫
      (kernelSubobject f.op).arrow
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (imageSubobjectIso g.op).hom ≫ (imageUnopOp g.op).inv ≫ (factorThruImage g.op.unop).op =
    (imageSubobjectIso g.op).hom ≫ (imageOpOp g).inv ≫ (factorThruImage g).op

tactic: rfl
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (imageSubobjectIso g.op).hom ≫ (imageUnopOp g.op).inv ≫ (factorThruImage g.op.unop).op =
    (imageSubobjectIso g.op).hom ≫ (imageOpOp g).inv ≫ (factorThruImage g).op
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.sum_restrict_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [← restrict_iUnion_ae (h.aedisjoint.mono fun i j h => hν h) fun g =>
    (h.nullMeasurableSet_smul g).mono_ac hν,
  restrict_congr_set (hν h.iUnion_smul_ae_eq), restrict_univ]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
hν : ν ≪ μ
⊢ (sum fun g => ν.restrict (g • s)) = ν
state_after: no goals
Theorem: UniformOnFun.nhds_eq_of_basis
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp_rw [nhds_eq_comap_uniformity, UniformOnFun.uniformity_eq_of_basis _ _ h, comap_iInf,
  comap_principal, UniformOnFun.gen, preimage_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Type u_4
s s' : Set α
x : α
p✝ : Filter ι✝
g : ι✝ → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
ι : Sort u_5
p : ι → Prop
V : ι → Set (β × β)
h : (𝓤 β).HasBasis p V
f : α →ᵤ[𝔖] β
⊢ 𝓝 f = ⨅ s ∈ 𝔖, ⨅ i, ⨅ (_ : p i), 𝓟 {g | ∀ x ∈ s, ((toFun 𝔖) f x, (toFun 𝔖) g x) ∈ V i}
state_after: no goals
Theorem: CategoryTheory.preserves_desc_mapCocone
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: simp [← G.map_comp]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝¹ : Category.{w', w} J
F : J ⥤ C
inst✝ : PreservesColimit F G
c₁ c₂ : Cocone F
t : IsColimit c₁
⊢ ∀ (j : J), (G.mapCocone c₁).ι.app j ≫ G.map (t.desc c₂) = (G.mapCocone c₂).ι.app j
state_after: no goals
Theorem: LinearMap.polar_weak_closed
File: Mathlib/Analysis/LocallyConvex/Polar.lean

tactic: rw [polar_eq_iInter]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
⊢ IsClosed (B.polar s)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
⊢ IsClosed (⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1})

tactic: refine isClosed_iInter fun x => isClosed_iInter fun _ => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
⊢ IsClosed (⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1})
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
x : E
x✝ : x ∈ s
⊢ IsClosed {y | ‖(B x) y‖ ≤ 1}

tactic: exact isClosed_le (WeakBilin.eval_continuous B.flip x).norm continuous_const
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
x : E
x✝ : x ∈ s
⊢ IsClosed {y | ‖(B x) y‖ ≤ 1}
state_after: no goals
Theorem: Orientation.tan_oangle_sub_right_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: have hs : (o.oangle y (y - x)).sign = 1 := by
  rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle y (y - x)).tan = ‖x‖ / ‖y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle y (y - x)).sign = 1
⊢ (o.oangle y (y - x)).tan = ‖x‖ / ‖y‖

tactic: rw [o.oangle_eq_angle_of_sign_eq_one hs, Real.Angle.tan_coe,
  InnerProductGeometry.tan_angle_sub_of_inner_eq_zero
    (o.inner_rev_eq_zero_of_oangle_eq_pi_div_two h)]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle y (y - x)).sign = 1
⊢ (o.oangle y (y - x)).tan = ‖x‖ / ‖y‖
state_after: no goals

tactic: rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle y (y - x)).sign = 1
state_after: no goals
Theorem: Num.ofNat'_one
File: Mathlib/Data/Num/Lemmas.lean

tactic: erw [ofNat'_bit true 0, cond, ofNat'_zero]
state_before: α : Type u_1
⊢ ofNat' 1 = 1
state_after: α : Type u_1
⊢ (match (motive := Bool → Num → Num) true with
      | true => Num.bit1
      | false => Num.bit0)
      0 =
    1

tactic: rfl
state_before: α : Type u_1
⊢ (match (motive := Bool → Num → Num) true with
      | true => Num.bit1
      | false => Num.bit0)
      0 =
    1
state_after: no goals
Theorem: smul_add_smul_lt_smul_add_smul'
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [add_comm (b₁ • d), add_comm (b₁ • a)]
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ b₂ : α
a d : β
hba : b₂ < b₁
hdc : d < a
⊢ b₁ • d + b₂ • a < b₁ • a + b₂ • d
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ b₂ : α
a d : β
hba : b₂ < b₁
hdc : d < a
⊢ b₂ • a + b₁ • d < b₂ • d + b₁ • a

tactic: exact smul_add_smul_lt_smul_add_smul hba hdc
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ b₂ : α
a d : β
hba : b₂ < b₁
hdc : d < a
⊢ b₂ • a + b₁ • d < b₂ • d + b₁ • a
state_after: no goals
Theorem: List.sigma_eq_sigmaTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: funext α β l₁ l₂
state_before: ⊢ @List.sigma = @sigmaTR
state_after: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ l₁.sigma l₂ = l₁.sigmaTR l₂

tactic: simp [List.sigma, sigmaTR]
state_before: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ l₁.sigma l₂ = l₁.sigmaTR l₂
state_after: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ (l₁.bind fun a => map (Sigma.mk a) (l₂ a)) =
    (foldl (fun acc a => foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)) #[] l₁).data

tactic: rw [Array.foldl_data_eq_bind]
state_before: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ (l₁.bind fun a => map (Sigma.mk a) (l₂ a)) =
    (foldl (fun acc a => foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)) #[] l₁).data
state_after: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ (l₁.bind fun a => map (Sigma.mk a) (l₂ a)) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ α → List ((a : α) × β a)

case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ ∀ (acc : Array ((a : α) × β a)) (a : α),
    (foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)).data = acc.data ++ ?h.h.h.h.G a

tactic: rfl
state_before: case h.h.h.h
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ (l₁.bind fun a => map (Sigma.mk a) (l₂ a)) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ α → List ((a : α) × β a)

case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ ∀ (acc : Array ((a : α) × β a)) (a : α),
    (foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)).data = acc.data ++ ?h.h.h.h.G a
state_after: case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ ∀ (acc : Array ((a : α) × β a)) (a : α),
    (foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)).data = acc.data ++ map (Sigma.mk a) (l₂ a)

tactic: intros
state_before: case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
⊢ ∀ (acc : Array ((a : α) × β a)) (a : α),
    (foldl (fun acc b => acc.push ⟨a, b⟩) acc (l₂ a)).data = acc.data ++ map (Sigma.mk a) (l₂ a)
state_after: case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
acc✝ : Array ((a : α) × β a)
a✝ : α
⊢ (foldl (fun acc b => acc.push ⟨a✝, b⟩) acc✝ (l₂ a✝)).data = acc✝.data ++ map (Sigma.mk a✝) (l₂ a✝)

tactic: apply Array.foldl_data_eq_map
state_before: case h.h.h.h.H
α : Type u_2
β : α → Type u_1
l₁ : List α
l₂ : (a : α) → List (β a)
acc✝ : Array ((a : α) × β a)
a✝ : α
⊢ (foldl (fun acc b => acc.push ⟨a✝, b⟩) acc✝ (l₂ a✝)).data = acc✝.data ++ map (Sigma.mk a✝) (l₂ a✝)
state_after: no goals
Theorem: Int.ceil_sub_self_eq
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [(or_iff_right ha).mp (fract_eq_zero_or_add_one_sub_ceil a)]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : fract a ≠ 0
⊢ ↑⌈a⌉ - a = 1 - fract a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : fract a ≠ 0
⊢ ↑⌈a⌉ - a = 1 - (a + 1 - ↑⌈a⌉)

tactic: abel
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : fract a ≠ 0
⊢ ↑⌈a⌉ - a = 1 - (a + 1 - ↑⌈a⌉)
state_after: no goals
Theorem: openSegment_eq_image
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [add_sub_cancel_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
x✝ : z ∈ openSegment 𝕜 x y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • x + b • y = z
⊢ (fun θ => (a + b - θ) • x + θ • y) b = a • x + b • y
state_after: no goals