1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlternatingMap.add_compLinearMap
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
M₃ : Type u_11
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
f₁ f₂ : M [⋀^ι]→ₗ[R] N
g : M₂ →ₗ[R] M
⊢ (f₁ + f₂).compLinearMap g = f₁.compLinearMap g + f₂.compLinearMap g
state_after: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
M₃ : Type u_11
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
f₁ f₂ : M [⋀^ι]→ₗ[R] N
g : M₂ →ₗ[R] M
x✝ : ι → M₂
⊢ ((f₁ + f₂).compLinearMap g) x✝ = (f₁.compLinearMap g + f₂.compLinearMap g) x✝

tactic: simp only [compLinearMap_apply, add_apply]
state_before: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
M₃ : Type u_11
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
f₁ f₂ : M [⋀^ι]→ₗ[R] N
g : M₂ →ₗ[R] M
x✝ : ι → M₂
⊢ ((f₁ + f₂).compLinearMap g) x✝ = (f₁.compLinearMap g + f₂.compLinearMap g) x✝
state_after: no goals
Theorem: convex_closedBall
File: Mathlib/Analysis/Convex/Normed.lean

tactic: simpa only [Metric.closedBall, sep_univ] using (convexOn_univ_dist a).convex_le r
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
a : E
r : ℝ
⊢ Convex ℝ (closedBall a r)
state_after: no goals
Theorem: Vector.tail_map
File: Mathlib/Data/Vector/Basic.lean

tactic: obtain ⟨a, v', h⟩ := Vector.exists_eq_cons v
state_before: n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
⊢ (map f v).tail = map f v.tail
state_after: case intro.intro
n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
a : α
v' : Vector α n
h : v = a ::ᵥ v'
⊢ (map f v).tail = map f v.tail

tactic: rw [h, map_cons, tail_cons, tail_cons]
state_before: case intro.intro
n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
a : α
v' : Vector α n
h : v = a ::ᵥ v'
⊢ (map f v).tail = map f v.tail
state_after: no goals
Theorem: WithLp.prod_edist_self
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: rcases p.trichotomy with (rfl | rfl | h)
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp p (α × β)
⊢ edist f f = 0
state_after: case inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp 0 (α × β)
⊢ edist f f = 0

case inr.inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp ⊤ (α × β)
⊢ edist f f = 0

case inr.inr
p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp p (α × β)
h : 0 < p.toReal
⊢ edist f f = 0

tactic: classical
simp
state_before: case inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp 0 (α × β)
⊢ edist f f = 0
state_after: no goals

tactic: simp
state_before: case inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp 0 (α × β)
⊢ edist f f = 0
state_after: no goals

tactic: simp [prod_edist_eq_sup]
state_before: case inr.inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp ⊤ (α × β)
⊢ edist f f = 0
state_after: no goals

tactic: simp [prod_edist_eq_add h, ENNReal.zero_rpow_of_pos h,
  ENNReal.zero_rpow_of_pos (inv_pos.2 <| h)]
state_before: case inr.inr
p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp p (α × β)
h : 0 < p.toReal
⊢ edist f f = 0
state_after: no goals
Theorem: Ideal.norm_dvd_iff
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: rw [← Ideal.mem_span_singleton (y := x), ← eq_intCast (algebraMap ℤ S), ← Ideal.mem_comap,
  ← Ideal.span_singleton_absNorm, Ideal.mem_span_singleton, Ideal.absNorm_span_singleton,
  Int.natAbs_dvd]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ (Algebra.norm ℤ) x ∣ y ↔ x ∣ ↑y
state_after: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ Nat.Prime (absNorm (span {x}))

tactic: rwa [Ideal.absNorm_span_singleton, ← Int.prime_iff_natAbs_prime]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
x : S
hx : Prime ((Algebra.norm ℤ) x)
y : ℤ
⊢ Nat.Prime (absNorm (span {x}))
state_after: no goals
Theorem: TopCat.Presheaf.isSheaf_iff_isSheafPreservesLimitPairwiseIntersections
File: Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean

tactic: rw [isSheaf_iff_isSheafPairwiseIntersections]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheaf ↔ F.IsSheafPreservesLimitPairwiseIntersections
state_after: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPairwiseIntersections ↔ F.IsSheafPreservesLimitPairwiseIntersections

tactic: constructor
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPairwiseIntersections ↔ F.IsSheafPreservesLimitPairwiseIntersections
state_after: case mp
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPairwiseIntersections → F.IsSheafPreservesLimitPairwiseIntersections

case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPreservesLimitPairwiseIntersections → F.IsSheafPairwiseIntersections

tactic: intro h ι U
state_before: case mp
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPairwiseIntersections → F.IsSheafPreservesLimitPairwiseIntersections
state_after: case mp
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
⊢ Nonempty (PreservesLimit (Pairwise.diagram U).op F)

tactic: exact ⟨preservesLimitOfPreservesLimitCone (Pairwise.coconeIsColimit U).op (h U).some⟩
state_before: case mp
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
⊢ Nonempty (PreservesLimit (Pairwise.diagram U).op F)
state_after: no goals

tactic: intro h ι U
state_before: case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
⊢ F.IsSheafPreservesLimitPairwiseIntersections → F.IsSheafPairwiseIntersections
state_after: case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPreservesLimitPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
⊢ Nonempty (IsLimit (Functor.mapCone F (Pairwise.cocone U).op))

tactic: haveI := (h U).some
state_before: case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPreservesLimitPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
⊢ Nonempty (IsLimit (Functor.mapCone F (Pairwise.cocone U).op))
state_after: case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPreservesLimitPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
this : PreservesLimit (Pairwise.diagram U).op F
⊢ Nonempty (IsLimit (Functor.mapCone F (Pairwise.cocone U).op))

tactic: exact ⟨PreservesLimit.preserves (Pairwise.coconeIsColimit U).op⟩
state_before: case mpr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
h : F.IsSheafPreservesLimitPairwiseIntersections
ι : Type w
U : ι → Opens ↑X
this : PreservesLimit (Pairwise.diagram U).op F
⊢ Nonempty (IsLimit (Functor.mapCone F (Pairwise.cocone U).op))
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp [gluedLiftPullbackMap]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst =
    pullback.fst ≫
      (pullbackSymmetry s.fst (𝒰.map i)).hom ≫ pullback.map (𝒰.map i) s.fst (𝒰.map i ≫ f) g (𝟙 (𝒰.obj i)) s.snd f ⋯ ⋯
state_after: no goals
Theorem: cauchy_map_iff
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rw [Cauchy, map_neBot_iff, prod_map_map_eq, Tendsto]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
l : Filter β
f : β → α
⊢ Cauchy (map f l) ↔ l.NeBot ∧ Tendsto (fun p => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α)
state_after: no goals
Theorem: Real.sign_mul_pos_of_ne_zero
File: Mathlib/Data/Real/Sign.lean

tactic: refine lt_of_le_of_ne (sign_mul_nonneg r) fun h => hr ?_
state_before: r : ℝ
hr : r ≠ 0
⊢ 0 < r.sign * r
state_after: r : ℝ
hr : r ≠ 0
h : 0 = r.sign * r
⊢ r = 0

tactic: have hs0 := (zero_eq_mul.mp h).resolve_right hr
state_before: r : ℝ
hr : r ≠ 0
h : 0 = r.sign * r
⊢ r = 0
state_after: r : ℝ
hr : r ≠ 0
h : 0 = r.sign * r
hs0 : r.sign = 0
⊢ r = 0

tactic: exact sign_eq_zero_iff.mp hs0
state_before: r : ℝ
hr : r ≠ 0
h : 0 = r.sign * r
hs0 : r.sign = 0
⊢ r = 0
state_after: no goals
Theorem: Ordinal.mod_eq_zero_of_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rcases H with ⟨c, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
H : b ∣ a
⊢ a % b = 0
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
⊢ b * c % b = 0

tactic: rcases eq_or_ne b 0 with (rfl | hb)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
⊢ b * c % b = 0
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Ordinal.{u_4}
⊢ 0 * c % 0 = 0

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
hb : b ≠ 0
⊢ b * c % b = 0

tactic: simp
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Ordinal.{u_4}
⊢ 0 * c % 0 = 0
state_after: no goals

tactic: simp [mod_def, hb]
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
hb : b ≠ 0
⊢ b * c % b = 0
state_after: no goals
Theorem: PartialEquiv.trans_refl_restr
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp [trans_source]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set β
⊢ (e.trans ((PartialEquiv.refl β).restr s)).source = (e.restr (↑e ⁻¹' s)).source
state_after: no goals
Theorem: Function.IsPeriodicPt.minimalPeriod_le
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [minimalPeriod, dif_pos (mk_mem_periodicPts hn hx)]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : 0 < n
hx : IsPeriodicPt f n x
⊢ minimalPeriod f x ≤ n
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : 0 < n
hx : IsPeriodicPt f n x
⊢ Nat.find ⋯ ≤ n

tactic: exact Nat.find_min' (mk_mem_periodicPts hn hx) ⟨hn, hx⟩
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : 0 < n
hx : IsPeriodicPt f n x
⊢ Nat.find ⋯ ≤ n
state_after: no goals
Theorem: Nat.totient_eq_iff_prime
File: Mathlib/Data/Nat/Totient.lean

tactic: refine ⟨fun h => ?_, totient_prime⟩
state_before: p : ℕ
hp : 0 < p
⊢ φ p = p - 1 ↔ Prime p
state_after: p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ Prime p

tactic: rw [totient_eq_card_coprime, range_eq_Ico, ← Ico_insert_succ_left hp.le, Finset.filter_insert,
  if_neg (not_coprime_of_dvd_of_dvd hp (dvd_refl p) (dvd_zero p)), ← Nat.card_Ico 1 p] at h
state_before: p : ℕ
h : φ p = p - 1
hp : 1 < p
⊢ Prime p
state_after: p : ℕ
h : (filter p.Coprime (Ico (succ 0) p)).card = (Ico 1 p).card
hp : 1 < p
⊢ Prime p

tactic: refine
  p.prime_of_coprime hp fun n hn hnz => Finset.filter_card_eq h n <| Finset.mem_Ico.mpr ⟨?_, hn⟩
state_before: p : ℕ
h : (filter p.Coprime (Ico (succ 0) p)).card = (Ico 1 p).card
hp : 1 < p
⊢ Prime p
state_after: p : ℕ
h : (filter p.Coprime (Ico (succ 0) p)).card = (Ico 1 p).card
hp : 1 < p
n : ℕ
hn : n < p
hnz : n ≠ 0
⊢ succ 0 ≤ n

tactic: rwa [succ_le_iff, pos_iff_ne_zero]
state_before: p : ℕ
h : (filter p.Coprime (Ico (succ 0) p)).card = (Ico 1 p).card
hp : 1 < p
n : ℕ
hn : n < p
hnz : n ≠ 0
⊢ succ 0 ≤ n
state_after: no goals

tactic: apply lt_of_le_of_ne
state_before: p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 < p
state_after: case a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≤ p

case a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≠ p

tactic: rwa [succ_le_iff]
state_before: case a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≤ p
state_after: no goals

tactic: rintro rfl
state_before: case a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≠ p
state_after: case a
hp : 0 < 1
h : φ 1 = 1 - 1
⊢ False

tactic: rw [totient_one, tsub_self] at h
state_before: case a
hp : 0 < 1
h : φ 1 = 1 - 1
⊢ False
state_after: case a
hp : 0 < 1
h : 1 = 0
⊢ False

tactic: exact one_ne_zero h
state_before: case a
hp : 0 < 1
h : 1 = 0
⊢ False
state_after: no goals
Theorem: Set.univ_pi_singleton
File: Mathlib/Data/Set/Prod.lean

tactic: simp [funext_iff]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f g : (i : ι) → α i
⊢ (g ∈ univ.pi fun i => {f i}) ↔ g ∈ {f}
state_after: no goals
Theorem: Set.image_restrictPreimage
File: Mathlib/Data/Set/Function.lean

tactic: delta Set.restrictPreimage
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ t.restrictPreimage f '' (Subtype.val ⁻¹' s) = Subtype.val ⁻¹' (f '' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ MapsTo.restrict f (f ⁻¹' t) t ⋯ '' (Subtype.val ⁻¹' s) = Subtype.val ⁻¹' (f '' s)

tactic: rw [← (Subtype.coe_injective).image_injective.eq_iff, ← image_comp, MapsTo.restrict_commutes,
  image_comp, Subtype.image_preimage_coe, Subtype.image_preimage_coe, image_preimage_inter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ MapsTo.restrict f (f ⁻¹' t) t ⋯ '' (Subtype.val ⁻¹' s) = Subtype.val ⁻¹' (f '' s)
state_after: no goals
Theorem: cardinal_lt_aleph0_of_finiteDimensional
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

tactic: rw [← lift_lt_aleph0.{v, u}, lift_cardinal_mk_eq_lift_cardinal_mk_field_pow_lift_rank K V]
state_before: K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : StrongRankCondition K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
inst✝² : Finite K
inst✝¹ : Module.Free K V
inst✝ : Module.Finite K V
⊢ #V < ℵ₀
state_after: K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : StrongRankCondition K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
inst✝² : Finite K
inst✝¹ : Module.Free K V
inst✝ : Module.Finite K V
⊢ lift.{v, u} #K ^ lift.{u, v} (Module.rank K V) < ℵ₀

tactic: exact power_lt_aleph0 (lift_lt_aleph0.2 (lt_aleph0_of_finite K))
  (lift_lt_aleph0.2 (rank_lt_aleph0 K V))
state_before: K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : StrongRankCondition K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
inst✝² : Finite K
inst✝¹ : Module.Free K V
inst✝ : Module.Finite K V
⊢ lift.{v, u} #K ^ lift.{u, v} (Module.rank K V) < ℵ₀
state_after: no goals
Theorem: FirstOrder.Language.ElementarilyEquivalent.theory_model_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Theory.model_iff_subset_completeTheory, Theory.model_iff_subset_completeTheory,
  h.completeTheory_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
h : M ≅[L] N
⊢ M ⊨ T ↔ N ⊨ T
state_after: no goals
Theorem: xor_iff_not_iff'
File: Mathlib/Logic/Basic.lean

tactic: simp only [← @xor_not_left _ b, not_not]
state_before: a b : Prop
⊢ Xor' a b ↔ (¬a ↔ b)
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.semanticallyEquivalent_all_liftAt
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [realize_iff, realize_all_liftAt_one_self]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⇔ ∀'liftAt 1 n φ).Realize v xs
state_after: no goals
Theorem: Ideal.fst_comp_quotientMulEquivQuotientProd
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: apply Quotient.ringHom_ext
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ (fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime) = factor (I * J) I ⋯
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ ((fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J)) =
    (factor (I * J) I ⋯).comp (Quotient.mk (I * J))

tactic: ext
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ ((fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J)) =
    (factor (I * J) I ⋯).comp (Quotient.mk (I * J))
state_after: case h.a
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
x✝ : R
⊢ (((fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J))) x✝ =
    ((factor (I * J) I ⋯).comp (Quotient.mk (I * J))) x✝

tactic: rfl
state_before: case h.a
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
x✝ : R
⊢ (((fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J))) x✝ =
    ((factor (I * J) I ⋯).comp (Quotient.mk (I * J))) x✝
state_after: no goals
Theorem: contDiff_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: convert (reCLM : 𝕜 →L[ℝ] ℝ).contDiff.comp ((contDiff_id (E := E)).inner 𝕜 (contDiff_id (E := E)))
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
⊢ ContDiff ℝ n fun x => ‖x‖ ^ 2
state_after: case h.e'_10.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
x✝ : E
⊢ ‖x✝‖ ^ 2 = (⇑reCLM ∘ fun x => ⟪id x, id x⟫_𝕜) x✝

tactic: exact (inner_self_eq_norm_sq _).symm
state_before: case h.e'_10.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
x✝ : E
⊢ ‖x✝‖ ^ 2 = (⇑reCLM ∘ fun x => ⟪id x, id x⟫_𝕜) x✝
state_after: no goals
Theorem: Order.pred_eq_pred_iff_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [eq_iff_le_not_lt, eq_iff_le_not_lt, pred_le_pred_iff_of_not_isMin ha hb,
  pred_lt_pred_iff_of_not_isMin ha hb]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
hb : ¬IsMin b
⊢ pred a = pred b ↔ a = b
state_after: no goals
Theorem: RingCon.ringConGen_le
File: Mathlib/RingTheory/Congruence/Basic.lean

tactic: rw [ringConGen_eq]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
r : R → R → Prop
c : RingCon R
h : ∀ (x y : R), r x y → c x y
⊢ ringConGen r ≤ c
state_after: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
r : R → R → Prop
c : RingCon R
h : ∀ (x y : R), r x y → c x y
⊢ sInf {s | ∀ (x y : R), r x y → s x y} ≤ c

tactic: exact sInf_le h
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
r : R → R → Prop
c : RingCon R
h : ∀ (x y : R), r x y → c x y
⊢ sInf {s | ∀ (x y : R), r x y → s x y} ≤ c
state_after: no goals
Theorem: div_neg
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← div_neg_eq_neg_div]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ a / -b = -(a / b)
state_after: no goals
Theorem: Int.pred_self_lt
File: Mathlib/Data/Int/Defs.lean

tactic: unfold pred
state_before: a✝ b c d m n a : ℤ
⊢ a.pred < a
state_after: a✝ b c d m n a : ℤ
⊢ a - 1 < a

tactic: omega
state_before: a✝ b c d m n a : ℤ
⊢ a - 1 < a
state_after: no goals
Theorem: HahnSeries.ofPowerSeries_apply
File: Mathlib/RingTheory/HahnSeries/PowerSeries.lean

tactic: simp only [Function.Embedding.coeFn_mk]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, { toFun := Nat.cast, inj' := ⋯ } a ≤ { toFun := Nat.cast, inj' := ⋯ } b ↔ a ≤ b
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, ↑a ≤ ↑b ↔ a ≤ b

tactic: exact Nat.cast_le
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, ↑a ≤ ↑b ↔ a ≤ b
state_after: no goals
Theorem: Complex.angle_mul_right
File: Mathlib/Analysis/Complex/Angle.lean

tactic: simp [mul_comm, angle_mul_left ha]
state_before: a x✝ y✝ : ℂ
ha : a ≠ 0
x y : ℂ
⊢ angle (x * a) (y * a) = angle x y
state_after: no goals